数据分析相关概念

矢量

矢量是指一堆形成的集合。

多维数组也叫做矢量化计算。

单独一个数叫做标量

例：

 1 import datetime as dt
 2 import numpy as np
 3 
 4 n2=10000
 5 start2 =dt.datetime.now()
 6 a,b = [],[]
 7 
 8 for i in range(n2):
 9     a.append(i**2)
10     b.append(i**3)
11 
12 c=[]
13 
14 for a,b in zip(a,b):    #zip()函数用于将可迭代的对象作为参数，将对象中的对应元素打包成一个元组，返回这些元组组成的列表
15     c.append(a+b)
16 
17 print((dt.datetime.now()-start2).microseconds)
18 
19 n=100000
20 start = dt.datetime.now()
21 
22 c=np.arange(n)**2 + np.arange(n)**3
23 print(c)
24 print((dt.datetime.now()-start).microseconds)
25 
26 '''
27 1.arange和python里range非常的相似
28 2.arange产生的也是一个连续的序列。序列的类型不再是列表，是数组array。
29 3.两数组可直接相加。
30 4.numpy内部完成循环。
31 
32 '''

多维数组

1.numpy对多维数组的定义：

　　用numpy.ndarray类。（n代表n个数，d代表dimision维度）。

　　ndarray本身是一个类，由这个类实例化出来的对象，就是多维数组。

　　多维数组也是一个对象。

2.创建多维数组对象的方法：

　　 1）numpy.arange(起始，终止，步长)

　　　　它是通过numpy来访问。是一个numpy里的函数。

　　　　它返回的数组是一个等差列的一维数组。

　　 2）numpy.array()

　　　　这个array不是类。是一个numpy里函数。

　　　　在numpy.array()函数，括号里可以输入任何可被解释程数组的容器。（列表和元组。）

　　　　例：

 1 import numpy as np
 2 from numpy import pi
 3 
 4 a = np.array([[1,1],
 5              [0,1]])
 6 
 7 b = np.array([[2,0],
 8             [3,4]])
 9 
10 c = a * b
11 print(c)
12 
13 #矩阵成集
14 c= a @ b
15 print(c)
16 
17 
18 print(a.dot(b))
19 
20 
21 a1 = np.ones((2,3),dtype=int)
22 b1=np.random.random((2,3))
23 a1*=3
24 print(a1)
25 print(b1)
26 
27 
28 a2=np.ones(3,dtype=np.int32)
29 b2=np.linspace(0,pi,3)
30 b2.dtype.name
31 print(b2.dtype)
32 c2=a+b
33 print(c2)
34 c2.dtype.name
35 d=np.exp(c2*1j)
36 print(d)
37 d.dtype.name
38 
39 
40 e1=1
41 e2=2
42 print(np.exp(e1))
43 print(np.exp(e2))
44 
45 
46 a4 = np.random.random((2,3))
47 
48 print(a4)
49 print(a4.sum())
50 print(a4.min())
51 print(a4.max())
52 
53 
54 z =np.arange(12).reshape(3,4)
55 print(z)
56 print(z.sum(axis=0))    # 列的总和,0代表列
57 print(z.min(axis=1))    # 行的总和，1代表行
58 print(z.cumsum(axis=1))     #cumsum是指定行或者列，前数与现在的数字累加

 

　　获取数组元素类型的方法：

　　　　　　1：type([0][0]) =>python取类型的方法 方法

　　　　　　2：f.dtype =>numpy的方法 “int32”,代表4个字节的整型数。

　　为什么是int32？

　　　　原有是，在定义时未指定具体类型。而现在使用4个字节整形正好能保存f的数据，所以default缺省值就是4个字节。

　　3）查询结果的意义：

　　　　“<u1”的意义（输入字符串，用.dtype查询时）：

　　　　　　1.unicode每个编码占4个字节。有高低之分。分为小端序和大端序。

　　　　　　2.“u”代表是unicode编码。

　　　　　　3.“<”表示小端字节序。

　　　　　　4.“1”代表每个字符串里只有一个字符

　　　　“numpy.str”的含义（使用type(g[0] 查询时)）：

　　　　　　1.“str”代表字符串。

　　　　　　2.“ ”和python作区分而加成的。

　　4）手动值定类型的写法： g=np.array(['1','2','3'].dtype=np.int32)

　　　　1.值要设置手动指定类型，它的数据类型就做自动转换了。虽然值是是字符串，但是我们给了指定目标类型是整形

　　　　2.场景：如果觉得还是字符串式好，还能用astype改回。

所有和类型转换有关的其实都不是类型转换，都是复制，都是按新类型在你复制一份，但是对于源是不变的 dtype是属性，取元素的类型。

　　　　3.关于维度的属性： shape属性的值是一个元组类型，一个元组内包含多个元素。分别是从高到低类表示他每一个维度的数。

　　思考：一个二位数组有行和列，行高还是列高？

　　　　如果有页 行 列

　　　　　页：最高维度

　　　　　行：次之

　　　　　列：最低

　　　　4.areange和array都可以创建数组，有时候可以混用。

　　　　　用shape属性可以看到维度。

　　　　　numpy中多用二维数组，三维很少用。

　　　　5.元素索引

　　　　　　元素索引是从0开始

　　　　　　　　数组[索引]

　　　　　　　　数组[行索引][列索引]

　　　　　　　　数组[页索引][行索引][列索引]或者[页索引，行索引，列索引]

 

numpy的内置类型和自定义类型：

　　　　 1.内置类型：

　　　　　　优点： 可显示占内存多少，可灵活变化

　　　　　　缺点： 因为具有灵活可变性，性能方面做出牺牲。（因需要留出足够多空间）。

　　　　　　　　　无法使用固定内存地址的计算方法；

　　　　　　　　　它只能用动态来完成，有关地址运算就要占用运用时间。　

　　　　　　注：在numpy里为每一种类型都提供了固定的大小，所以有关地址运算完全可以通过类型来确定。numpy自己定义一套属于自己的数据类型体系。它的数据类型有固定长度。字节数都是固定的。

　　　　　　 举例： 　

　　　　　　　　　　numpy.bool　　 一个布尔占一个字节

　　　　　　　　　　有符号版本：

　　　　　　　　　　　　　　　　int8 1字节有符号类型

　　　　　　　　　　　　　　　　int16 2字节有符号类型

　　　　　　　　　　　　　　　　int32 4字节有符号类型

　　　　　　　　　　无符号版本（只有正整，没有负数）：

　　　　　　　　　　　　　　　　 uint8 1字节有符号类型

　　　　　　　　　　　　　　　　uint16 2字节有符号类型

　　　　　　　　　　　　　　　　uint32 4字节有符号类型

　　　　　　　　　　 浮点类型：

　　　　　　　　　　　　　　　　float16 2字节浮点型

　　　　　　　　　　　　　　　　float32 4字节浮点型

　　　　　　　　　　　　　　　　float64 8字节浮点型

　　　　　　　　　　复数类型：（实部和虚部都用2个4字节浮点型表示）

　　　　　　　　　　　　　　　　complex64 8字节复数型

　　　　　　　　　　　　　　　　complex128 16字节复数型

　　　　　　　　　　注：1复数=2个浮点型的组合

　　　　　　　　　　字符串类型： str

　　　　　　　　　　　　　　　　字符串型没有规定多少字节，因为字符串型取决于字符串unicode有多长。

　　　　　　　　　　　　　　　　字符串型的长度根据字符串所包含的字符串来决定，有多少字符，就有多少个字节。

　　　　　　　　　　 注：lunicode=4个字节 可以用dtype和astype来设置类型转换

　　　　2自定义类型：

　　　　　　　　 1.直接使用内置类型的原始名

　　　　　　　　 2.使用紧凑类型格式（类型编码字符串）

　　　　　　　　　　简化操作：（可以更少的字符串表示）

　　　　　　　　　　　　　　全称 　　　　　　简化格式

　　　　　　　　　　　　　　numpy.int8　　　　 i1

　　　　　　　　　　　　　　int16　　　  　　　  i2　　　　

　　　　　　　　　　　　　　uint32    　　　　　 u4

　　　　　　　　　　　　　　float64 　　　      　f8

　　　　　　　　　　　　　　complex128　　 　  c16

　　　　　　　　3多字节的整数存在大小端序

　　　　　　　　　　　对于多字节整数可以加上字节序前缀 前缀类型：（位数越低，地址越低）

　　　　　　 “　　　　　　　　”<”，小端字节序，低数位低地址低。

　　　　　　　　　　　　　　 “=”，系统默认，不能人为指定。由系统决定。

　　　　　　　　　　　　　　 “>”，大端字节序，低数位高地址。

　　　　　　　　　　　 例子：

　　　　　　　　　　　　　　十六进制：0x1234

　　　　　　　　　　　小端字节序：

　　　　　　　　　　　　　　l 　　　　h

　　　　　　　　　　　　　　0x12 　　0x34

　　　　　　　　　　　大端字节序：

　　　　　　　　　　　　　　l 　　　　h

　　　　　　　　　　　　　　0x34　　 0x12

　　　　　　　　　　　注：有时为了防止某个代码功能在不同处理器上取移植带来的一些兼容性问题。所以强制加上“<”或“>”

　　　　　　　　4.关于字节序：

　　　　　　　　　　　不需添加字节序的数据类型：

　　　　　　　　　　　　　单字节整数

　　　　　　　　　　　　　布尔值

　　　　　　　　　　　　　复数类型

　　　　　　　　　　　　　浮点型

　　　　　　　　　　　其他情况：

　　　　　　　　　　　　　numpy.str 　=>u+字符数

　　　　　　　　　　　　　unicode 本身就是多字节整正

　　　　　　　　　　　　　一个unicode可看作一个uint32，它也存在大小端字节序

　　　　　　　　　　　　　numpy.bool  =>b

　　　　　　　　　　　注：numpy提供的是python的封装，用自定义类型方法可以完成一个元素不同类型的访问；

　　　　　　　　　　　　　或者一个元素用不同类型类组合，弥补了numpy数组元素同质的情况。

 

 切片

　　与python相似

　　数组[起始：终止：步长]

　　可以针对多维数组来切片

　　缺省起始：首元素（步长为正），尾元素（步长为负）->逆向

　　缺省终止：尾后（步长为正），首前（步长为负）

　　缺省步长：一个或者一个以上缺省值切片。

　　　　　　　　a[...]连续或者几个连续的维度使用缺省切片，用‘...’表示

　　例：

 1 import numpy as np
 2 
 3 a = np.arange(1,10)
 4 print(a)
 5 
 6 print(a[:3])
 7 print(a[3:6])
 8 print(a[6:])
 9 print(a[::-1])
10 
11 
12 print(a[:-4:-1])
13 print(a[4:7:1])
14 print(a[-7::-1])
15 print(a[::])
16 print(a[...])
17 print(a[:])
18 # print(a[])        #行不通 error
19 print(a[::3])
20 print(a[1::3])
21 print(a[2::3])
22 
23 
24 
25 b=np.arange(1,25).reshape(2,3,4)
26 print(b)
27 print("="*120)
28 print(b[:,0,0])
29 print(b[0,:,:])
30 print(b[0,...])
31 print(b[0,1,::2])
32 print(b[:,1:,1])
33 print(b[1,1,1])
34 print(b[1,1::2,1])