NumPy手册
文章目录
获取属性
秩
ndarray.ndim # 即轴的数量或维度的数量
形状
ndarray.shape # 数组的维度，对于矩阵，n 行 m 列
大小
ndarray.size # 数组元素的总个数，相当于 .shape 中 n*m 的值
元素数据类型
ndarray.dtype # ndarray 对象的元素类型
元素占用空间大小
ndarray.itemsize # ndarray 对象中每个元素的大小，以字节为单位
####对象内存布局
ndarray.flags # ndarray 对象的内存信息
####实部
ndarray.real # ndarray元素的实部
####虚部
ndarray.imag # ndarray 元素的虚部
内存地址
ndarray.data #包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。
创建数组
创建空数组
numpy.empty(shape, dtype = float, order = 'C')
# np.empty([3,2]) or np.empty((3,2)) 创建3行2列矩阵,不初始化
创建零数组
numpy.zeros(shape, dtype = float, order = 'C')
# np.zeros(5) 创建长度5的0数组
创建1数组
numpy.ones(shape, dtype = None, order = 'C') # 创建指定形状的数组，数组元素以 1 来填充
创建对角矩阵
numpy.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
# np.eye(5) 创建5行5列的二维对角阵
创建序列数组
# 根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray
numpy.arange(start, stop, step, dtype)
# 创建一个一维等差数列数组，范围是[start,stop],元素个数num。linspace翻译成线性空间？
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
# 创建一个一维等比数列数组
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
np.arange(0,12).reshape(3,4) # 创建序列数组并转换成3行4列矩阵
创建概率分布的数组
#创建shape形状的高斯（正态）分布数组
np.random.randn(shape)
#a = np.random.randn(10)
#创建均值为loc，标准差为scale，形状为size的高斯（正态）分布
np.random.normal(loc, scale, size)
#b = np.random.normal(0, 1, (2,4)) 均值为0，标准差为1，形状为（2，4）的二维数组
#创建shape形状的均匀分布数组
np.random.rand(shape)
#c = np.random.rand(2,3) 生成一个形状为（2，3）的均匀分布二维数组
#创建一个从[low, high)中随即采样的，样本数量为size的均匀分布
np.random.uniform(low, high, size)
#d = np.random.uniform(-1,1,10)
已有列表、元组创建
numpy.asarray(a, dtype = None, order = None)
# x = [1,2,3] or x = (1,2,3)
# a = np.asarray(x)
切片、索引
切片
a = np.arange(10)
s = slice(2,7,2) # 从索引 2 开始到索引 7 停止，间隔为2
a[s] #s为slice对象
# 与python的切片语法相同
b = a[2:] # 从索引 2 开始到结束
c = a[2:7] # [2,7)之间的元素
d = a[2:7:2] # 从索引 2 开始到索引 7 停止，间隔为 2
高维切片
...用来表示高维情况下，选中该维度的所有数据，并与其他维度选取结果取交集
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print (a[...,1]) # 第2列元素
print (a[1,...]) # 第2行元素
print (a[...,1:]) # 第2列及剩下的所有元素
# 切片 ":" 或 "..." 与索引数组组合
b = a[1:3, 1:3] # 位于第2，3行且第2,3列部分的元素
c = a[1:3,[1,2]] # 同上
索引
a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
b = a[5]
b
# 5
# 获取数组中第6个位置的元素
x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0,1,2], [0,1,0]] # 索引结果1维
y
# [1 4 5]
# 获取数组中(0,0)，(1,1)和(2,0)位置处的元素
# 获取 4X3 矩阵中的四个角的元素
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] # 索引结果2维
y
# array([[ 0, 2],
# [ 9, 11]])
布尔索引
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
x[x > 5]
# array([ 6, 7, 8, 9, 10, 11])
# 使用"~" 过滤NaN
a = np.array([np.nan, 1,2,np.nan,3,4,5])
a[~np.isnan(a)]
# array([1., 2., 3., 4., 5.])
# 筛选复数
a = np.array([1, 2+6j, 5, 3.5+5j])
a[np.iscomplex(a)]
# array([2. +6.j, 3.5+5.j])
花式索引
x=np.arange(32).reshape((8,4))
x[[4,2,1,7]] # 原矩阵的第4,2,1,7行构成的新矩阵（第0行起计）
x[[-4,-2,-1,-7]] # 原矩阵的倒数第4,2,1,7行构成的新矩阵（第1行起计）
x[np.ix_([1,5,7,2],[0,3,1,2])] # 原矩阵的第4,2,1,7行构成的新矩阵（第0行起计），并将列按0,3,1,2顺序排序
如果np.xi_ 中输入两个列表，则第一个列表存的是待提取元素的行标，第二个列表存的是待提取元素的列标，第一个列表中的每个元素都会遍历第二个列表中的每个值，构成新矩阵的一行元素。
数值计算
算术运算
对数组的算术运算通常在相应的元素上进行。
如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。
a = np.array([1,2,3,4])
b = np.array([10,20,30,40])
c = a * b
c
# array([ 10, 40, 90, 160])
d = a + b
d
# array([11, 22, 33, 44])
广播(Broadcast)
当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。
a = np.array([[ 0, 0, 0],
[10,10,10],
[20,20,20],
[30,30,30]])
b = np.array([1,2,3])
a + b
"""
array([[ 1, 2, 3],
[11, 12, 13],
[21, 22, 23],
[31, 32, 33]])
"""
统计运算
n = np.array([[1,2,3],[4,5,6],[7,8,9]])
最小值
numpy.amin(a, axis=None, ...)
np.amin(n) #1,数组的最小值
np.amin(n,0) #[1,2,3],列最小值
np.amin(n,1) #[1,4,7],按行求最小值
最大值
numpy.amax(a, axis=None, ...)
np.amax(n) #9,数组的最大值
np.amax(n,0) #[7,8,9],列最大值
np.amax(n,1) #[3,6,9],按行求最大值
数组值的范围
Numpy.ptp(array,axis=None) #返回array中最大值-最小值的结果
#np.ptp(n) 8
百分位统计
numpy.percenetile(a,q,axis=None)
#例如，第80个百分位数是这样一个值，它使得至少有80%的数据项小于或等于这个值，且至少有20%的数据项大于或等于这个值。
#np.percentile(n,40) 4.2
中位数
numpy.median(a,axis=None)
#np.median(n) 5.0
算术平均值
numpy.mean(a,axis=None)
#np.mean(n) 5.0
加权平均值
numpy.averager(a,axis=None,weights=None,returned=False)
#np.averager(n) 5.0
#weight = np.array([[1,2,3],[3,2,1],[1,2,3]]
#np.average(n,weights=weight.returned=True)
#(5.33333333,18.0) 加权均值和权重和
标准差
std = sqrt(mean(x-x.mean()**2))
numpy.std(array)
#np.std(n) 2.58198889
方差
numpy.var(array)
#np.var(n) 6.666666666
逻辑运算
生成10名同学，5门功课的数据
score = np.random.randint(40, 100, (10, 5))
# 取出最后4名同学的成绩，用于逻辑判断
test_score = score[6:, 0:5]
test_score
array([[63, 40, 91, 60, 56],
[91, 68, 94, 90, 43],
[44, 58, 99, 86, 86],
[63, 66, 78, 48, 90]])
布尔运算
#如果成绩大于60就标记为True 否则为False
test_score > 60
array([[ True, False, True, False, False],
[ True, True, True, True, False],
[False, False, True, True, True],
[ True, True, True, False, True]])
BOOL赋值
test_score[test_score > 60] = 1
test_score
array([[ 1, 40, 1, 60, 56],
[ 1, 1, 1, 1, 43],
[44, 58, 1, 1, 1],
[ 1, 1, 1, 48, 1]])
all，any 判断函数
np.all()
#判断前两名同学的成绩[0:2, :]是否全及格
np.all(score[0:2, :] > 60)
#False
np.any()
#判断前两名同学的成绩[0:2, :]是否有大于90分的
np.any(score[0:2, :] > 90)
#False
where三元运算符
np.where()
#判断前四名学生,前四门课程中，成绩中大于60的置为1，否则为0
np.where(temp > 60, 1, 0)
np.logical_and()、np.logical_or()复合逻辑
#判断前四名学生,前四门课程中，成绩中大于60且小于90的换为1，否则为0
np.where(np.logical_and(temp > 60, temp < 90), 1, 0)
#判断前四名学生,前四门课程中，成绩中大于90或小于60的换为1，否则为0
np.where(np.logical_or(temp > 90, temp < 60), 1, 0)
线性代数运算
numpy.dot() ，此函数返回两个数组的矩阵乘法（向量结果，矩阵乘法）。
numpy.vdot()， 此函数返回两个向量的点积（标量结果，相应位置元素相乘再相加）。
numpy.inner()，此函数返回一维数组的向量内积。
numpy.matmul()，函数返回两个数组的矩阵乘积。
a=np.array([[1,2],[3,4]])
b=np.array([[11,12],[13,14]])
np.dot(a,b) # array([[37, 40], [85, 92]])
np.vdot(a,b) #130 1*11+2*12+3*13+4*14=130
np.matmul(a,b) # array([[37, 40], [85, 92]])
x=np.array([1,2,3])
y=np.array([0,1,0])
np.inner(x,y) # 2 等价于 1*0+2*1+3*0
numpy.linalg.det()，计算输入矩阵的行列式。
a=np.array([[1,2],[3,4]])
np.linalg.det(a) #-2.0000000000000004
np.linalg.inv(a)，函数返回矩阵a的逆矩阵。
a = np.array([[1,1,1],[0,2,5],[2,5,-1]])
ainv = np.linalg.inv(a)
ainv
#array([[ 1.28571429, -0.28571429, -0.14285714],
# [-0.47619048, 0.14285714, 0.23809524],
# [ 0.19047619, 0.14285714, -0.0952381 ]])
numpy.linalg.solve()，该函数给出了矩阵形式的线性方程的解。
如
可表示为AX=B
即求X=A^(-1)B
b = np.array([[6],[-4],[27]])
x = np.linalg.solve(a,b)
x # array([[ 5.],
# [ 3.],
# [-2.]])
np.dot(ainv,b) #同上
迭代
nditer迭代
a = np.arange(6).reshape(2,3)
for x in np.nditer(a):
print (x, end=", " )
# 0, 1, 2, 3, 4, 5,
nditer 迭代默认顺序与数组内存布局一致，不一定是行序也不一定是列序。
对a.T使用nditer迭代输出顺序不变。
控制遍历顺序
for x in np.nditer(a, order='F'): # Fortran order，即是列序优先；
for x in np.nditer(a.T, order='C'): # C order，即是行序优先；
修改矩阵中元素的值
for x in np.nditer(a, op_flags=['readwrite']):
x[...]=2*x
默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值得修改，必须指定 read-write 或者 write-only 的模式
广播迭代
a = np.arange(0,60,5).reshape(3,4)
b = np.array([1, 2, 3, 4])
for x,y in np.nditer([a,b]):
print ("%d:%d" % (x,y), end=", " )
# 0:1, 5:2, 10:3, 15:4, 20:1, 25:2, 30:3, 35:4, 40:1, 45:2, 50:3, 55:4
# 数组a有12个元素，数组b有4个，当迭代时，b会广播到长度与a相等（b|a）
flat 迭代
a = np.arange(9).reshape(3,3)
for element in a.flat:
print (element)
数组操作
修改数组形状
numpy.reshape(arr, newshape, order='C')
a = np.arange(8).reshape(4,2)
数组展开/降维
flatten展开
a = np.arange(8).reshape(2,4)
a.flatten()
#array([0, 1, 2, 3, 4, 5, 6, 7])
ravel展开
a = np.arange(8).reshape(2,4)
a.ravel()
#array([0, 1, 2, 3, 4, 5, 6, 7])
flatten()是返回一份展开后的拷贝，对其修改不会影响原矩阵
而ravel()是返回一个原数组的展开序列（视图），对其修改会相应修改原矩阵
矩阵转置
numpy.transpose(arr)
ndarray.T # 相当于self.transpose()
坐标轴调整
# 函数向后滚动特定的轴到一个特定位置
numpy.rollaxis(arr, axis, start) # axis：要向后滚动的轴，其它轴的相对位置不会改变
# 交换矩阵的两个坐标轴
numpy.swapaxes(arr, axis1, axis2)
第二个交换坐标轴好理解，第一个是轴滚动，类似将一个选定的的轴插到其他轴中间（坐标数值好理解一些，立体空间想象不来）
可参考以下网站学习：
维度扩展，复制扩展
broadcast()
broadcast(x,y) # 模仿广播的对象,将y广播到x
x = np.array([[1], [2], [3]]) # 3行1列
y = np.array([4, 5, 6]) # 1行3列
b = np.broadcast(x,y) # b 是迭代器
for x,y in b:
print(x,y) #9行输出，每个x元素对应3个y元素
broadcast_to()
numpy.broadcast_to(array, shape, subok)
#将数组广播到新形状。它在原始数组上返回只读视图。
#对原数组的修改会影响视图的值
a = np.arange(4).reshape(1,4)
b = np.broadcast_to(a,(4,4))
b
"""
array([[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3]])
"""
tile()
b = np.arange(6).reshape(2,3)
bb = np.tile(b, (4, 2)) # 重复 b 的各个维度，纵向4倍，横向2倍
bb # 8行6列
tile是瓷砖的意思, 顾名思义,这个函数就是把矩阵像瓷砖一样铺展开来。
broadcast_to扩展需要对维度扩展，原来是1行，可以扩展成多行，原来是2维，可以扩展到3维，但是tile是同一维度的复制，复制后两者不相关，修改其中一个不影响另一个
expand_dims()
numpy.expand_dims(arr, axis)
expand_dims(a, axis) 在原有的维数上再增加1个维度，具体可以看这个：
维度压缩
numpy.squeeze(arr, axis) # 从给定数组的形状中删除一维的条目
x = np.arange(9).reshape(1,3,3)
y = np.squeeze(x)
x.shape, y.shape
((1, 3, 3), (3, 3)) # 厚度只有1的维会被删除
数组连接
concatenate() 沿指定轴连接相同形状的两个或多个数组
numpy.concatenate((a1, a2, ...), axis)
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
np.concatenate((a,b)),np.concatenate((a,b),axis = 1)
"""(array([[1, 2],
[3, 4],
[5, 6],
[7, 8]]),
array([[1, 2, 5, 6],
[3, 4, 7, 8]]))
"""
numpy.stack 沿新轴连接数组序列
numpy.stack(arrays, axis)
np.stack((a,b),0),np.stack((a,b),1)
"""
(array([[[1, 2],
[3, 4]],
[[5, 6],
[7, 8]]]),
array([[[1, 2],
[5, 6]],
[[3, 4],
[7, 8]]]))
"""
numpy.hstack,numpy.vstack
np.hstack((a,b)),np.vstack((a,b))
"""
(array([[1, 2, 5, 6],
[3, 4, 7, 8]]),
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]]))
"""
hstack和vstack效果与concatenate相同，在原数组平面的右方或者下方进行拼接，
但stack是在原数组平面上面“堆叠”，新增了一维
数组分割
numpy.split 沿特定的轴将数组分割为子数组
numpy.split(ary, indices_or_sections, axis)
参考网站
博客园-numpy库
菜鸟教程-Numpy 数组操作
个人图书馆-Python NumPy统计函数详情
简书-numpy中方法amin的参数axis取值理解
CSDN-Python中的numpy库介绍！
CSDN-Numpy的高级运算
CSDN-Python中的numpy库介绍！
2995
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
