【numpy】numpy用法总结

ndarray

a = np.array([1,2,3])  
[1 2 3]

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

a = np.array([1, 2, 3, 4, 5], ndmin =  2)  
[[1 2 3 4 5]]

a = np.array([1,  2,  3], dtype = complex)  
[1.+0.j 2.+0.j 3.+0.j]

student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')]) 
a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student) 
[('abc', 21, 50.0), ('xyz', 18, 75.0)]

数组属性

a = np.arange(24)  
print (a.ndim)             # a 现只有一个维度
# 现在调整其大小
b = a.reshape(2,4,3)  # b 现在拥有三个维度
print (b.ndim)

a = np.array([[1,2,3],[4,5,6]])  
print (a.shape)
(2, 3)

a = np.array([[1,2,3],[4,5,6]]) 
a.shape =  (3,2)  
或者
a = np.array([[1,2,3],[4,5,6]]) 
b = a.reshape(3,2)  
[[1 2]
 [3 4]
 [5 6]]
 

创建数组

x = np.empty([3,2], dtype = int) 
[[ 6917529027641081856  5764616291768666155]
 [ 6917529027641081859 -5764598754299804209]
 [          4497473538      844429428932120]]
 
x = np.zeros(5) 
[0. 0. 0. 0. 0.]

y = np.zeros((5,), dtype = np.int) 
[0 0 0 0 0]

x = np.ones(5) 
[1. 1. 1. 1. 1.]

x = np.ones([2,2], dtype = int)
[[1 1]
 [1 1]]

从已有的数组创建数组

x =  [1,2,3] 
a = np.asarray(x)  
[1  2  3]

x =  (1,2,3) 
a = np.asarray(x)  
[1  2  3]

x =  [(1,2,3),(4,5)] 
a = np.asarray(x)  
[(1, 2, 3) (4, 5)]

x =  [1,2,3] 
a = np.asarray(x, dtype =  float)  
[ 1.  2.  3.]

从数值范围创建数组

x = np.arange(5)  
[0  1  2  3  4]

x = np.arange(5, dtype =  float)  
[0.  1.  2.  3.  4.]

x = np.arange(10,20,2)  
[10  12  14  16  18]

切片和索引

a = np.arange(10)
s = slice(2,7,2)   # 从索引 2 开始到索引 7 停止，间隔为2
print (a[s])
[2  4  6]

a = np.arange(10)  
b = a[2:7:2]   # 从索引 2 开始到索引 7 停止，间隔为 2
[2  4  6]
# 如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。
# 如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。

a = np.arange(10)  # [0 1 2 3 4 5 6 7 8 9]
b = a[5] 
5

a = np.arange(10)
print(a[2:])
[2  3  4  5  6  7  8  9]

a = np.arange(10)  # [0 1 2 3 4 5 6 7 8 9]
print(a[2:5])
[2  3  4]

a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a[1:])
[[3 4 5]
 [4 5 6]]

a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print (a[...,1])   # 第2列元素
print (a[1,...])   # 第2行元素
print (a[...,1:])  # 第2列及剩下的所有元素
[2 4 5]
[3 4 5]
[[2 3]
 [4 5]
 [5 6]]

高级索引

x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
y = x[[0,1,2],  [0,1,0]]  

x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])
rows = np.array([[0,0],[3,3]]) 
cols = np.array([[0,2],[0,2]]) 
y = x[rows,cols]  

a = np.array([[1,2,3], [4,5,6],[7,8,9]])
b = a[1:3, 1:3]
c = a[1:3,[1,2]]
d = a[...,1:]
[[5 6]
 [8 9]]
[[5 6]
 [8 9]]
[[2 3]
 [5 6]
 [8 9]]

x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print (x[x >  5])
[ 6  7  8  9 10 11]

a = np.array([np.nan,  1,2,np.nan,3,4,5])  
print (a[~np.isnan(a)])
[ 1.   2.   3.   4.   5.]

x=np.arange(32).reshape((8,4))
print (x[[4,2,1,7]]) # 第4,2,1,7行元素
[[16 17 18 19]
 [ 8  9 10 11]
 [ 4  5  6  7]
 [28 29 30 31]]

x=np.arange(32).reshape((8,4))
print (x[np.ix_([1,5,7,2],[0,3,1,2])]) # 第1,5,7,2行元素,第0,3,1,2列元素
[[ 4  7  5  6]
 [20 23 21 22]
 [28 31 29 30]
 [ 8 11  9 10]]

广播(Broadcast)

a = np.array([1,2,3,4]) 
b = np.array([10,20,30,40]) 
c = a * b 
[ 10  40  90 160]

a = np.array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
b = np.array([1,2,3])
print(a + b)
[[ 1  2  3]
 [11 12 13]
 [21 22 23]
 [31 32 33]]

迭代数组

a = np.arange(6).reshape(2,3)
for x in np.nditer(a):
    print (x, end=", " )
0, 1, 2, 3, 4, 5, 

print ('以 C 风格顺序排序：')
for x in np.nditer(a, order =  'C'):  
    print (x, end=", " )
print ('\n')
print ('以 F 风格顺序排序：')
for x in np.nditer(a, order =  'F'):  
    print (x, end=", " )
原始数组是：
[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]
以 C 风格顺序排序：
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 
以 F 风格顺序排序：
0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55, 

for x in np.nditer(a, op_flags=['readwrite']): 
    x[...]=2*x  
[[  0  10  20  30]
 [ 40  50  60  70]
 [ 80  90 100 110]]

数组操作

a = np.arange(8)
b = a.reshape(4,2)
[[0 1]
 [2 3]
 [4 5]
 [6 7]]

# flat 数组元素迭代器
a = np.arange(9).reshape(3,3) 
for row in a:
    print (row)
[0 1 2]
[3 4 5]
[6 7 8]
for element in a.flat:
    print (element)
0
1
2
3
4
5
6
7
8

# flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
a = np.arange(8).reshape(2,4)
[[0 1 2 3]
 [4 5 6 7]]
print (a.flatten())
[0 1 2 3 4 5 6 7]
print (a.flatten(order = 'F'))
[0 4 1 5 2 6 3 7]
# ravel 返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组 
print (a.ravel())
[0 1 2 3 4 5 6 7]
print (a.ravel(order = 'F'))
[0 4 1 5 2 6 3 7]

# transpose 函数用于对换数组的维度
a = np.arange(12).reshape(3,4)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
print (np.transpose(a))
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]
# numpy.ndarray.T 类似 numpy.transpose：
print (a.T)

# rollaxis 函数向后滚动特定的轴到一个特定位置
a = np.arange(8).reshape(2,2,2)
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
print(np.where(a==6))   
(array([1]), array([1]), array([0]))
print(a[1,1,0])  # 为 6
6

# 将轴 2 滚动到轴 0（宽度到深度）
b = np.rollaxis(a,2,0)
[[[0 2]
  [4 6]]

 [[1 3]
  [5 7]]]
# 查看元素 a[1,1,0]，即 6 的坐标，变成 [0, 1, 1]
print(np.where(b==6))   
(array([0]), array([1]), array([1]))
# 将轴 2 滚动到轴 1：（宽度到高度）
c = np.rollaxis(a,2,1)
[[[0 2]
  [1 3]]

 [[4 6]
  [5 7]]]
# 查看元素 a[1,1,0]，即 6 的坐标，变成 [1, 0, 1]
print(np.where(c==6))   
(array([1]), array([0]), array([1]))

# swapaxes 函数用于交换数组的两个轴
a = np.arange(8).reshape(2,2,2)
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
# 现在交换轴 0（深度方向）到轴 2（宽度方向）
print (np.swapaxes(a, 2, 0))
[[[0 4]
  [2 6]]

 [[1 5]
  [3 7]]]
 
# squeeze 函数从给定数组的形状中删除一维的条目
x = np.arange(9).reshape(1,3,3)
[[[0 1 2]
  [3 4 5]
  [6 7 8]]]
y = np.squeeze(x)
[[0 1 2]
 [3 4 5]
 [6 7 8]]
数组 x 和 y 的形状：
(1, 3, 3) (3, 3)

# resize 函数返回指定大小的新数组
a = np.array([[1,2,3],[4,5,6]])
[[1 2 3]
 [4 5 6]]
b = np.resize(a, (3,2))
[[1 2]
 [3 4]
 [5 6]]

# append 函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中
a = np.array([[1,2,3],[4,5,6]])
[[1 2 3]
 [4 5 6]]
print (np.append(a, [7,8,9]))
[1 2 3 4 5 6 7 8 9]
print (np.append(a, [[7,8,9]],axis = 0))
[[1 2 3]
 [4 5 6]
 [7 8 9]]
print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]

# insert 函数在给定索引之前，沿给定轴在输入数组中插入值。
a = np.array([[1,2],[3,4],[5,6]])
[[1 2]
 [3 4]
 [5 6]]
print (np.insert(a,3,[11,12]))
[ 1  2  3 11 12  4  5  6]
print (np.insert(a,1,[11],axis = 0))
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]
print (np.insert(a,1,11,axis = 1))
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]

# delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开
a = np.arange(12).reshape(3,4)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
print (np.delete(a,5))
未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0  1  2  3  4  6  7  8  9 10 11]
print (np.delete(a,1,axis = 1))
[[ 0  2  3]
 [ 4  6  7]
 [ 8 10 11]]

# unique 函数用于去除数组中的重复元素
a = np.array([5,2,6,2,7,5,6,8,2,9])
u = np.unique(a)
[2 5 6 7 8 9]
u,indices = np.unique(a, return_index = True)
[1 0 2 4 7 9]

算术函数

a = np.arange(9, dtype = np.float_).reshape(3,3)  
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
b = np.array([10,10,10])  
[10 10 10]
print (np.add(a,b))
[[10. 11. 12.]
 [13. 14. 15.]
 [16. 17. 18.]]
print (np.subtract(a,b))
[[-10.  -9.  -8.]
 [ -7.  -6.  -5.]
 [ -4.  -3.  -2.]]
print (np.multiply(a,b))
[[ 0. 10. 20.]
 [30. 40. 50.]
 [60. 70. 80.]]
print (np.divide(a,b))
[[0.  0.1 0.2]
 [0.3 0.4 0.5]
 [0.6 0.7 0.8]]

# reciprocal() 函数返回参数逐元素的倒数
a = np.array([0.25,  1.33,  1,  100])  
print (np.reciprocal(a))
[4.        0.7518797 1.        0.01     ]

# mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。
a = np.array([10,20,30]) 
b = np.array([3,5,7])  
print (np.mod(a,b))
[1 0 2]
print (np.remainder(a,b))
[1 0 2]

线性代数

#numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；
#对于二维数组，计算的是两个数组的矩阵乘积；对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：
#数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和： dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。
a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(np.dot(a,b))
[[37  40] 
 [85  92]]

# numpy.vdot() 函数是两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。
# 如果参数是多维数组，它会被展开。
a = np.array([[1,2],[3,4]]) 
b = np.array([[11,12],[13,14]]) 
# vdot 将数组展开计算内积
print (np.vdot(a,b))
130

# numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积。
a = np.array([[1,2], [3,4]]) 
b = np.array([[11, 12], [13, 14]]) 
print (np.inner(a,b))
[[35 41]
 [81 95]]
1*11+2*12, 1*13+2*14 
3*11+4*12, 3*13+4*14

# numpy.matmul 函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。
# 另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。
# 对于二维数组，它就是矩阵乘法：
a = [[1,0],[0,1]] 
b = [[4,1],[2,2]] 
print (np.matmul(a,b))
[[4  1] 
 [2  2]]