python之numpy

@numpy1.15.1

数据科学的基础库

0维，标量

1维，向量

2维，矩阵

3维，两个矩阵

生成数组

array，生成数组

In [43]: import numpy as np

In [44]: np.array([1,2,3,4])
Out[44]: array([1, 2, 3, 4])

shape，形状

ndim，维度

dtype，数据类型

size，数据量

In [45]: a=np.array([1,2,3,4])

In [46]: a.shape
Out[46]: (4,)

In [47]: a.ndim
Out[47]: 1

In [48]: a.dtype
Out[48]: dtype('int64')

In [49]: a.size
Out[49]: 4

ones

In [81]: np.ones((3,3))
Out[81]: 
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

zeros

In [82]: np.zeros((3,3))
Out[82]: 
array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

full

In [83]: np.full((3,3),10)
Out[83]: 
array([[10, 10, 10],
       [10, 10, 10],
       [10, 10, 10]])

empty，只分配内存，不填充(显式的都是无意义的垃圾值)

In [85]: np.empty((4,3))
Out[85]: 
array([[4.67340138e-310, 6.93503607e-310, 0.00000000e+000],
       [0.00000000e+000, 4.74303020e-322, 3.16202013e-322],
       [4.67340152e-310, 1.33360294e+241, 1.66006057e-321],
       [4.79243676e-322, 4.67340141e-310, 4.67340116e-310]])

In [86]: np.empty((4,4))
Out[86]: 
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

eye，生成一个对角矩阵,单位矩阵:N*N的方阵，

In [89]: np.eye(5)
Out[89]: 
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

随机数生成

均匀分布的随机每个数字概率相同，正态分布每个数字的概率不同，服从正态分布

np.random.rand(3,4)服从均匀分布U(0,1)，概率密度函数U

In [11]: np.random.rand(3,4)
Out[11]: 
array([[0.36699488, 0.9741204 , 0.84815739, 0.48596074],
       [0.5928032 , 0.62280041, 0.31407069, 0.95993541],
       [0.25970683, 0.40320787, 0.0971164 , 0.67055418]])

np.random.uniform(low,hight,size)生成服从均匀分布U(low,hight)的size形状的数组

In [12]: np.random.uniform(1,10,(3,4))
Out[12]: 
array([[1.17581624, 5.50209972, 6.299659  , 9.47775073],
       [3.39811157, 8.42530786, 2.44554191, 5.38029127],
       [8.8163518 , 7.76073674, 2.29126795, 4.30997287]])

np.random.random(size=(3,4))生成[0.0,1.0)随机浮点数数组，半开区间，size传入元组为数组形状，服从均匀分布

In [5]: np.random.random((3,4))
Out[5]: 
array([[0.84320125, 0.82264588, 0.28592509, 0.84245593],
       [0.40883795, 0.58067854, 0.60638238, 0.45798846],
       [0.29094517, 0.75667093, 0.23649304, 0.54981549]])

np.random.randint(low=1,hight=10,size=(3,4))生成[low,hight)随机整数数组，size表示数组形状，服从均匀分布

In [6]: np.random.randint(1,10,(3,4))
Out[6]: 
array([[6, 7, 1, 6],
       [3, 8, 9, 1],
       [3, 8, 1, 8]])

np.random.randn(2,3)生成服从标准正态分布的2×3的数组

In [10]: np.random.randn(3,4)
Out[10]: 
array([[ 0.48757842, -1.26618141, -0.45154971, -0.42444533],
       [-1.62114112, -0.13627121, -0.33674115, -2.40336541],
       [ 0.15190233, -0.59217321, -0.28116279,  0.4059114 ]])

seed,随机种子，使随机可复现，传入整数参数作为一个标签tag，只要不是None则seed生效

In [39]: np.random.seed(10)#其后的随机生成数是一个固定的随机数

np.random.shuffle()随机打乱行，不能打乱列

In [21]: arr=np.arange(0,10,0.5).reshape(4,5)

In [22]: arr
Out[22]: 
array([[0. , 0.5, 1. , 1.5, 2. ],
       [2.5, 3. , 3.5, 4. , 4.5],
       [5. , 5.5, 6. , 6.5, 7. ],
       [7.5, 8. , 8.5, 9. , 9.5]])

In [23]: np.random.shuffle(arr)

In [24]: arr
Out[24]: 
array([[0. , 0.5, 1. , 1.5, 2. ],
       [7.5, 8. , 8.5, 9. , 9.5],
       [5. , 5.5, 6. , 6.5, 7. ],
       [2.5, 3. , 3.5, 4. , 4.5]])

 

数据类型

dtype可以直接传入np.array函数中改变数据类型，产生一个新的数组，非视图

In [47]: arr
Out[47]: array([1, 2, 3, 4, 5, 6, 7, 8, 9])

In [48]: arr1=np.array(arr,dtype=np.float64)

In [49]: arr1
Out[49]: array([1., 2., 3., 4., 5., 6., 7., 8., 9.])

astype，改变数组的数据类型，产生一个新的数组，不是视图

In [29]: arr.dtype
Out[29]: dtype('int64')


In [31]: arr1=arr.astype(np.float32)
Out[31]: 
array([[0., 1., 2., 3., 4.],
       [5., 6., 7., 8., 9.]], dtype=float32)

In [32]: arr.dtype
Out[32]: dtype('int64')

In [32]: arr.dtype
Out[32]: dtype('int64')

reshape，重构

In [51]: arr.reshape((3,3))
Out[51]: 
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

切片索引

arr[列][行]，此处的列指的是列表，行指列表的第几个元素，跟表示形状shape的行列意义不同

In [54]: arr1
Out[54]: 
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])


In [56]: arr1[1]
Out[56]: array([4, 5, 6])

In [57]: arr1[1][1]
Out[57]: 5

In [58]: arr1[:][1]
Out[58]: array([4, 5, 6])

In [59]: arr1[1][:]
Out[59]: array([4, 5, 6])

花式索引

arr[[列]，[行]] 此处的列指的是列表，行指列表的第几个元素，跟表示形状shape的行列意义不同

In [60]: arr1[[1]]
Out[60]: array([[4, 5, 6]])

In [61]: arr1[[1,2]]
Out[61]: 
array([[4, 5, 6],
       [7, 8, 9]])

In [62]: arr1[[1,2],[1]]
Out[62]: array([5, 8])

In [63]: arr1[[1,2],[1,2]]
Out[63]: array([5, 9])

布尔型索引

用条件判定去取（但是很好用），布尔型索引选取数组中数据，总是创建数据的副本，而非视图

arr[arr>0]，返回一个符合条件元素的一维数组

非0为Ttue

0为False

In [65]: arr1
Out[65]: 
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

In [66]: arr1[arr1>5]#返回一个一维数组
Out[66]: array([6, 7, 8, 9])

In [68]: arr1
Out[68]: 
array([[1, 2, 3],
       [4, 5, 0],
       [0, 0, 0]])

data2 = data[names ==  'c',2:] #布尔型数组可以跟切片、数组混合使用
data3 = data[names == 'c'][:,2:]

深复制，浅复制

深复制，重新开辟内存，修改深复制，不会改变源数据

浅复制，共用原内存，获取到视图，修改浅复制会改变源数据

np.ix_

In [72]: a=np.arange(10).reshape(2,5)

In [73]: a
Out[73]: 
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])

In [74]: ix=np.ix_([0,1],[2,4])

In [75]: ix
Out[75]: 
(array([[0],
        [1]]), array([[2, 4]]))

In [76]: ix[0]
Out[76]: 
array([[0],
       [1]])

In [77]: ix[1]
Out[77]: array([[2, 4]])

In [78]: ix[0].shape
Out[78]: (2, 1)

In [79]: ix[1].shape
Out[79]: (1, 2)

In [80]: a[ix]
Out[80]: 
array([[2, 4],
       [7, 9]])

 

数学运算

相同shape的运算

0轴，0方向，行方向，形状的行列和求值的行列相反

1轴，1方向，列方向

In [90]: a
Out[90]: 
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7],
       [8, 9]])

In [91]: b
Out[91]: 
array([[10, 11],
       [12, 13],
       [14, 15],
       [16, 17],
       [18, 19]])

In [92]: a+b
Out[92]: 
array([[10, 12],
       [14, 16],
       [18, 20],
       [22, 24],
       [26, 28]])

In [93]: a-b
Out[93]: 
array([[-10, -10],
       [-10, -10],
       [-10, -10],
       [-10, -10],
       [-10, -10]])

In [94]: a*b
Out[94]: 
array([[  0,  11],
       [ 24,  39],
       [ 56,  75],
       [ 96, 119],
       [144, 171]])

In [95]: a/b
Out[95]: 
array([[0.        , 0.09090909],
       [0.16666667, 0.23076923],
       [0.28571429, 0.33333333],
       [0.375     , 0.41176471],
       [0.44444444, 0.47368421]])

广播

array([[1,2,3]])===>广播array([[1,2,3],[1,2,3],[1,2,3]])

 

通用函数(元算函数)

一元函数

 

二元函数

 

取反

转置：第一行变第一列

向量的乘法：对应位置相乘再累加，即向量的内积

矩阵的乘法：3×2的的矩阵必须乘以2行的矩阵

迹：对角线元素的和，非方阵的对角线是从（0,0）起

行列式：只有方阵才有行列式，不是满秩，行列式就是0

矩阵的秩，阶梯矩阵，第三行可以用前两行表示，x3可以通过线性组合x1,x2得到

满秩：不能通过线性组合表示，

特征值和特征向量：

单位向量：

两个向量相乘等于则表示，两个向量方向垂直

复数：-1=j**2

 

方阵的逆：A×B=E(单位矩阵)，A和B互为逆，满秩的时候才有逆

 

zip打包成元组

In [93]: a=[1,2,3]

In [94]: b=[4,5,6]

In [95]: c=[11,22,33,44]

In [96]: d=[111,222,333,444,555]

In [97]: zip(a,b,c,d)
Out[97]: <zip at 0x7fa97dc64448>

In [98]: list(zip(a,b,c,d))
Out[98]: [(1, 4, 11, 111), (2, 5, 22, 222), (3, 6, 33, 333)]

np.where(cond,ar1,ar2)判断，嵌套判断

 

 

标准差：方差的开根号

方差：数据的变异程度，方差越小，表示数据集中在平均值附近(即期望附近)

期望：平均数，表示的数据的集中程度

分位数：中位数是50%的分位数

唯一化：重复项只返回一个