np数组的构造
最一般的方法是通过array来构造：
import numpy as np
np.array([1,2,3])
array([1, 2, 3])
下面讨论一些特殊数组的生成方式：
a）等差数列：np.linspace,np.arange
np.linspace(1,5,11) # 起始、终止（包含）、样本个数
array([1. , 1.4, 1.8, 2.2, 2.6, 3. , 3.4, 3.8, 4.2, 4.6, 5. ])
np.arange(1,5,2) # 起始、终止（不包含）、步长
array([1, 3])
b）特殊矩阵：zeros,eye,full
np.zeros((2,3)) # 传入元组表示各维度大小
array([[0., 0., 0.],
[0., 0., 0.]])
np.eye(3) # 3*3的单位矩阵
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
np.eye(3,k=1) # 偏移主对角线1个单位的伪单位矩阵
array([[0., 1., 0.],
[0., 0., 1.],
[0., 0., 0.]])
np.full((2,3),10) # 元组传入大小，10表示填充数值
array([[10, 10, 10],
[10, 10, 10]])
np.full((2,3),[1,2,3]) # 通过传入列表填充每列的值
array([[1, 2, 3],
[1, 2, 3]])
c）随机矩阵：np.random
最常用的随机生成函数为rand,randn,randint,choice,它们分别表示0-1均匀分布的随机数组、标准正态的随机数组、随机整数组和随机列表抽样：
np.random.rand(3) # 生成服从0-1均匀分布的三个随机数
array([0.46116142, 0.09351841, 0.5376369 ])
np.random.rand(3,3) # 注意这里传入的不是元组，每个维度大小分开输入
array([[0.31397779, 0.35113439, 0.74900691],
[0.87965888, 0.71818357, 0.97333232],
[0.28792291, 0.31745955, 0.77887431]])
对于服从区间a到b上的均匀分布可以如下生成：
a,b = 5,15
(b-a)*np.random.rand(3)+a
array([10.91046509, 11.53604355, 9.42202514])
randn生成了N(0,1)的标准正态分布：
np.random.randn(3)
array([ 1.62410234, 1.42934132, -0.13977737])
np.random.randn(2,2)
array([[-0.14950722, 0.2283078 ],
[ 0.26223726, 1.91237419]])
对于服从方差为$\sigma^2$均值为$\mu$的一元正态分布可以如下生成：
sigma, mu = 2.5,3
mu+np.random.randn(3)*sigma
array([-2.44517314, 1.09322821, 4.77223963])
randint可以指定生成随机整数的最小值最大值和维度大小：
low, high, size = 5, 15, (2,2)
np.random.randint(low,high,size)
array([[ 5, 9],
[ 9, 12]])
choice可以从给定的列表中，以一定概率和方式抽取结果，当不指定概率时为均匀采样，默认抽取方式为有放回采样：
my_list = ['a','b','c','d']
np.random.choice(my_list,2,replace=False,p=[0.1,0.7,0.1,0.1])
array(['b', 'a'], dtype='<U1')
np.random.choice(my_list,(3,3))
array([['b', 'd', 'd'],
['d', 'a', 'a'],
['d', 'b', 'c']], dtype='<U1')
当返回的元素个数与原列表相同时，等价于使用permutation函数，即打散原列表：
np.random.permutation(my_list)
array(['c', 'd', 'b', 'a'], dtype='<U1')
最后，需要提到的是随机种子，它能够固定随机数的输出结果：
np.random.seed(0)
np.random.rand()
0.5488135039273248
np.random.seed(0)
np.random.rand()
0.5488135039273248
当seed等于0时，rand()结果固定。
np数组的变形与合并
a）转置：T
np.zeros((2,3)).T
array([[0., 0.],
[0., 0.],
[0., 0.]])
b）合并操作：r_,c_
对于二维数组而言，r_和c_分别表示上下合并和左右合并：
np.r_[np.zeros((2,3)),np.zeros((2,3))]
array([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
np.c_[np.zeros((2,3)),np.zeros((2,3))]
array([[0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0.]])
一维数组和二维数组进行合并时，应当把其视作列向量，在长度匹配的情况下只能够使用左右合并的c_操作：
try:
np.r_[np.array([0,0]),np.zeros((2,1))]
except Exception as e:
Err_Msg = e
Err_Msg
ValueError('all the input arrays must have same number of dimensions, but the array at index 0 has 1 dimension(s) and the array at index 1 has 2 dimension(s)')
np.r_[np.array([0,0]),np.zeros(2)]
array([0., 0., 0., 0.])
np.c_[np.array([0,0]),np.zeros((2,3))]
array([[0., 0., 0., 0.],
[0., 0., 0., 0.]])
c）维度变换：reshape
reshape能够帮助用户把原数组按照新的维度重新排列。在使用时有两种模式，分别为C模式和F模式，分别以逐行和逐列的顺序进行填充读取。
target = np.arange(8).reshape(2,4)
target
array([[0, 1, 2, 3],
[4, 5, 6, 7]])
target.reshape((4,2),order='C') # 按照行读取和填充
array([[0, 1],
[2, 3],
[4, 5],
[6, 7]])
target.reshape((4,2),order='F') # 按照列读取和填充
array([[0, 2],
[4, 6],
[1, 3],
[5, 7]])
特别地，由于被调用数组的大小是确定的，reshape允许有一个维度存在空缺，此时只需填充-1即可。
target.reshape((4,-1))
array([[0, 1],
[2, 3],
[4, 5],
[6, 7]])
下面将n*1大小的数组转为1维数组的操作是经常使用的：
target = np.ones((3,1))
target
array([[1.],
[1.],
[1.]])
target.reshape(-1)
array([1., 1., 1.])
np数组的切片与索引
数组的切片模式支持使用slice类型的start:end:step切片，还可以直接传入列表指定某个维度的索引进行切片：
target = np.arange(9).reshape(3,3)
target
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
target[:-1,[0,2]] # 这是怎么得到的？
array([[0, 2],
[3, 5]])
此外，还可以利用np.ix_在对应的维度上使用布尔索引，但此时不能使用slice切片。
target[np.ix_([True,False,True],[True,False,True])] # 行，列
array([[0, 2],
[6, 8]])
target[np.ix_([1,2],[True,False,True])]
array([[3, 5],
[6, 8]])
当数组维度为1维时，可以直接进行布尔索引，而无需np.ix_:
new = target.reshape(-1)
new[new%2==0]
array([0, 2, 4, 6, 8])
常用函数
为了简单起见，这里假设下述函数输入的数组都是一维的。
where
where是一种条件函数，可以指定满足条件与不满足条件位置对应的填充值：
a = np.array([-1,1,-1,0])
np.where(a>0,a,5) # 对应位置为True时填充a对应元素，否则填充5
array([5, 1, 5, 5])
nonzero,argmax,argmin
这三个函数返回的都是索引，nonzero返回非零数的索引，argmax,argmin分别返回最大和最小数的索引：
a = np.array([-2,-5,0,1,3,-1])
print(np.nonzero(a))
print(a.argmax())
print(a.argmin())
(array([0, 1, 3, 4, 5]),)
4
1
any, all
any指当序列至少存在一个True或非零元素时返回True,否则返回False。
all指当序列元素全为True或非零元素时返回True，否则返回False。
a = np.array([0,1])
print(a.any())
print(a.all())
True
False
cumprod,cumsum,diff
cumprod,cumsum分别表示累乘和累加函数，返回同长度的数组，diff表示和前一个元素做差，由于第一个元素为缺失值，因此在默认参数情况下，返回长度是原数组减1
a = np.array([1,2,3])
print(a.cumprod())
print(a.cumsum())
print(np.diff(a))
[1 2 6]
[1 3 6]
[1 1]
统计函数
常用的统计函数包括max,min,mean,median,std,var,sum,quantile（分位数，例如中位数、四分位数等），其中分位数计算是全局方法，因此不能通过array.quantile的方法调用：
target = np.arange(5)
print(target)
print(target.max())
print(np.quantile(target,0.5)) # 0.5分位数
[0 1 2 3 4]
4
2.0
但是对于含有缺失值的数组，它们返回的结果也是缺失值，如果需要略过缺失值，必须使用nan*类型的函数，上述的几个统计函数都有对应的nan*函数。
target = np.array([1,2,np.nan])
print(target)
print(target.max())
print(np.nanmax(target))
print(np.nanquantile(target,0.5))
[ 1. 2. nan]
nan
2.0
1.5
对于协方差和相关系数分别可以利用cov,corrcoef如下计算：
target1 = np.array([1,3,5,9])
target2 = np.array([1,5,3,-9])
print(np.cov(target1,target2))
print(np.corrcoef(target1,target2))
[[ 11.66666667 -16.66666667]
[-16.66666667 38.66666667]]
[[ 1. -0.78470603]
[-0.78470603 1. ]]
最后，需要说明二维Numpy数组中统计函数的axis 参数，它能够进行某一个维度下的统计特征计算，当axis=0时结果为列的统计指标，当axis=1时结果为行的统计指标：
target = np.arange(1,10).reshape(3,-1)
print(target)
print(target.sum(0))
print(target.sum(1))
[[1 2 3]
[4 5 6]
[7 8 9]]
[12 15 18]
[ 6 15 24]
广播机制
广播机制用于处理两个不同维度数组之间的操作，这里只讨论不超过两维的数组广播机制。
标量和数组的操作
当一个标量和数组进行运算时，标量会自动把大小扩充为数组大小，之后进行逐元素操作：
res = 3*np.ones((2,2))+1
print(res)
res = 1/res
print(res)
[[4. 4.]
[4. 4.]]
[[0.25 0.25]
[0.25 0.25]]
二维数组之间的操作
当两个数组维度完全一致时，使用对应元素的操作，否则会报错，除非其中的某个数组的维度是m1或者1n，那么会扩充其具有1的维度为另一个数组对应维度的大小。例如：12数组和32数组做逐元素运算时会把第一个数组扩充为32，扩充时的对应数组进行赋值。但是，需要注意的是，如果第一个数组的维度时13，那么由于在第二维上的大小不匹配且不为1，此时报错。
res = np.ones((3,2))
print(res)
[[1. 1.]
[1. 1.]
[1. 1.]]
print(res*np.array([[2,3]])) # 扩充第一维度为3
[[2. 3.]
[2. 3.]
[2. 3.]]
print(res*np.array([[2],[3],[4]])) # 扩充第二维度为2
[[2. 2.]
[3. 3.]
[4. 4.]]
print(res*np.array([[2]])) # 等价于两次扩充
[[2. 2.]
[2. 2.]
[2. 2.]]
一维数组与二维数组的操作
当一维数组$A_k$与二维数组$B_{m,n}$操作时，等价于把一维数组视作$A_{1,k}$的二维数组，使用的广播法则与二维数组之间的一致，当$k!=n$且$k,n$都不是1时报错。
np.ones(3)+np.ones((2,3))
array([[2., 2., 2.],
[2., 2., 2.]])
np.ones(3)+np.ones((2,1))
array([[2., 2., 2.],
[2., 2., 2.]])
np.ones(1)+np.ones((2,3))
array([[2., 2., 2.],
[2., 2., 2.]])
向量与矩阵的计算
向量内积：dot
$a \cdot b = \displaystyle\sum_{i}a_ib_i$
a = np.array([1,2,3])
b = np.array([1,3,5])
a.dot(b)
22
向量范数和矩阵范数：np.linalg.norm
在矩阵范数的计算中，最重要的是ord参数，可选值如下：
| ord | norm for matrices | norm for vectors |
|---|---|---|
| None | Frobenius norm | 2-norm |
| ‘fro’ | Frobenius norm | / |
| ‘nuc’ | nuclear norm | / |
| inf | max(sum(abs(x), axis=1)) | max(abs(x)) |
| -inf | min(sum(abs(x), axis=1)) | min(abs(x)) |
| 0 | / | sum(x != 0) |
| 1 | max(sum(abs(x), axis=0)) | as below |
| -1 | min(sum(abs(x), axis=0)) | as below |
| 2 | 2-norm (largest sing. value) | as below |
| -2 | smallest singular value | as below |
| other | / | sum(abs(x)**ord)**(1./ord) |
matrix_target = np.arange(4).reshape(-1,2)
print(matrix_target)
[[0 1]
[2 3]]
np.linalg.norm(matrix_target,'fro')
3.7416573867739413
np.linalg.norm(matrix_target,np.inf) # 为什么是5？
5.0
np.linalg.norm(matrix_target,2)
3.702459173643833
vector_target = np.arange(4)
vector_target
array([0, 1, 2, 3])
np.linalg.norm(vector_target,np.inf)
3.0
np.linalg.norm(vector_target,2)
3.7416573867739413
np.linalg.norm(vector_target,3) # 这算的啥？
3.3019272488946263
矩阵乘法
\[\rm [\mathbf{A}_{m\times p}\mathbf{B}_{p\times n}]_{ij} = \sum_{k=1}^p\mathbf{A}_{ik}\mathbf{B}_{kj}\]a = np.arange(4).reshape(-1,2)
a
array([[0, 1],
[2, 3]])
b = np.arange(-4,0).reshape(-1,2)
b
array([[-4, -3],
[-2, -1]])
a@b
array([[ -2, -1],
[-14, -9]])
练习
利用列表推导式写矩阵乘法
M1 = np.random.rand(2,3)
M2 = np.random.rand(3,4)
res = [[sum(M1[i][k]*M2[k][j] for k in range(M1.shape[1])) for j in range(M2.shape[1])] for i in range(M1.shape[0])]
print(res)
[[0.7229264438143471, 1.4403274211025126, 1.6119653928271116, 1.447923561687686], [0.5147197573058611, 1.0649581022373367, 1.2882941758163713, 0.9922255946441413]]
更新矩阵
A = np.arange(1,10).reshape(3,-1)
print(A)
[[1 2 3]
[4 5 6]
[7 8 9]]
B = [[A[i][j]*(sum(1/A[i][k] for k in range(A.shape[1]))) for j in range(A.shape[1])] for i in range(A.shape[0])]
print(B)
[[6, 12, 18], [60, 75, 90], [168, 192, 216]]
文档信息
- 本文作者：weownthenight
- 本文链接：https://weownthenight.github.io/2021/05/19/Numpy%E5%9F%BA%E7%A1%80/
- 版权声明：自由转载-非商用-非衍生-保持署名（创意共享3.0许可证）