python numpy学习笔记
numpy 的主要数据对象是 ndarray 多维数组，数组中包含相同类型的元素，通常是数值类型，每个元素都有一个索引。使用 numpy 前要导入包。
import numpy as np
目录
- 类型
- 维度
- 创建
- 增、删
- 随机数
- 运算
- 数学函数
- 索引、切片、迭代
- 形状操作
- 反转
- 拼接
- 拆分
- 复制
- 排序
- 搜索
- 概率分布
- 读写
类型
numpy 的数组被称为 ndarray （n维数组对象），它是一个数据容器，可以处理多维数组。
a = np.array([[1, 2, 3], [4, 5, 6]])
type(a) # dtype 属性可以获得元素的数据类型，也可以在创建时指定数据类型。
a.dtype # dtype('int32')
a = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int32)
astype() 可以用于类型转化。
a.astype(np.float64) # array([1., 2., 3., 4., 5.], dtype=float32)
如果把小数转化为浮点数，则小数部分则会被截取。
itemsize 属性可以获得元素的字节大小。
a.itemsize
numpy 常见的数据类型有以下几种。
| 类型 | 含义 |
|---|---|
bool |
布尔类型，1 个字节，值为True或False |
int |
正数类型，一般为int32或int64 |
intc |
与C里的int相同，一般为int32或int64 |
intp |
用于索引，一般为int32或int64 |
int8 |
字节，范围 -128 ~ 127 |
int16 |
整数，范围 -32768 ~ 32767 |
int32 |
整数 |
int64 |
整数 |
unit8 |
无符号整数，范围 0 ~ 255 |
unit16 |
无符号整数 |
unit32 |
无符号整数 |
unit64 |
无符号整数 |
float |
float64缩写 |
float16 |
半精度浮点，5 位指数，10 位尾数 |
float32 |
单精度浮点，8 位指数，23 位尾数 |
float64 |
双精度浮点，11 位指数，52 位尾数 |
complex |
complex128缩写 |
complex64 |
复数，由两个 32 位浮点表示。 |
complex128 |
复数，由两个 64 位浮点表示。 |
维度
数据的维度称为轴（axes）。
[1, 2, 3] # 一维数据，一个轴。长度为 3
[[1, 2, 3], [4, 5, 6]] # 二维数据，二个轴。第一个维长度为 2，第二维长度为 3
ndim 属性可以获得数组的维度（轴）。
a = np.array([[1, 2, 3], [4, 5, 6]])
a.ndim # 2
shape 属性不仅可以获得数组的维度，也可以获得每个维度的大小。
a.shape # (2, 3)
size 属性获得数组元素的总个数。
a.size # 6
data 属性可以获得数组的缓冲区。
轴可以用 moveaxis() 方法实现轴的移动。
np.moveaxis(a, 0, 1)
# array([[1, 4],
# [2, 5],
# [3, 6]])
swapaxes() 方法实现轴交换。
np.swapaxes(a, 0, 1)
# array([[1, 4],
# [2, 5],
# [3, 6]])
创建
array() 方法通过列表或元组创建数组，数据类型将自动推导得出，也可以指定类型。该方法会自动地将二维列表转化为二维数组，三维列表转化为三维数组。
a = np.array([1, 2, 3])
a.dtype # dtype('int32')
b = np.array([1.1, 2.2, 3.3])
b.dtype # dtype('float64')
c = np.array([[1, 2], [3, 4]], dtype=complex)
# array([[1.+0.j, 2.+0.j],
# [3.+0.j, 4.+0.j]])
还有一些方法可以创建特殊的数组。zeros() 方法可以创建全 0 的数组。
np.zeros((2, 3))
# array([[0., 0., 0.],
# [0., 0., 0.]])
ones() 方法可以创建一个全为 1 的数组。
np.ones((2, 3))
# array([[1., 1., 1.],
# [1., 1., 1.]])
identity() 方法可以创建一个对角线上全为 1 的数组。
np.identity(3)
# array([[1., 0., 0.],
# [0., 1., 0.],
# [0., 0., 1.]])
eye() 方法具有与 identity() 方法相似的功能，它创建一个 k 对角线元素上全为 1 的数组，其余元素全为 0。
np.eye(3)
# array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
np.eye(3, 2)
# array([[1., 0.],
[0., 1.],
[0., 0.]])
np.eye(4, 3, 1)
# array([[0., 1., 0.],
[0., 0., 1.],
[0., 0., 0.],
[0., 0., 0.]])
empyt() 方法可以创建一个空数组。
np.empty((2, 3))
# array([[0., 0., 0.],
# [0., 0., 0.]])
上述三个方法创建的数据类型默认为
float64。
arange() 方法的作用与内置方法 range() 类似。
np.arange(10, 30, 5)
# array([10, 15, 20, 25])
由于浮点类型精度的限制，arange() 方法无法准确计算元素个数。因此，推荐使用 linspace() 方法，通过第三个参数指定元素个数。
np.linspace(0, 2, 9)
# array([0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])
还可以从函数中创建多维数组。
np.fromfunction(lambda a, b: a + b, (3, 2))
# array([[0., 1.],
[1., 2.],
[2., 3.]])
meshgrid() 方法返回坐标数组。
np.meshgrid([1， 2， 3], [-1， 0， 1])
where() 方法根据条件来选取，如果 cond 为 True，则选择 a，否则选择 b。
a = np.array([1, 2, 3])
b = np.array([-1, -2, -3])
cond = np.array([True, False, True])
np.where(cond, a, b)
array([ 1, -2, 3])
其它还有 zeros_like()、ones_like() 和 empty_like() 方法，它们的功能分别类似 zeros()、 ones() 和 empty() 方法，只不过前者输入的是一个数组，自动获得数组的维度从而创建新的数组；而后者是直接输入维度。
增、删
delete() 方法可以删除数组中的一行或列，第一个参数为数组对象，第二个表示第几行或列，第三个参数若为 0，表示删除行，1 表示删除列。
b = np.array([[10, 20], [30, 40]])
np.delete(b, 1, 0) # array([[10, 20]])
np.delete(b, 1, 1) # array([[10], [30]])
insert() 与 delete() 参数类似，第三个参数表示插入对象，第四个参数才表示轴。
b = np.array([[10, 20], [30, 40]])
a = np.array([5, 5])
np.insert(b, 1, a, 0) # array([[10, 20], [ 5, 5], [30, 40]])
np.insert(b, 1, a, 1) # array([[10, 5, 20], [30, 5, 40]])
如果只需要插入末尾，使用 append() 即可，这就无需设置插入的行或列号了，返回一维数组。
b = np.array([[10, 20], [30, 40]])
a = np.array([5, 5])
np.append(b, a) # array([10, 20, 30, 40, 5, 5])
随机数
numpy.random.seed() 方法可以更改随机数种子。
numpy 的随机数主要由 numpy.random 完成。rand() 方法指定用[0,1)的数据填充，这些数据均匀分布。
np.random.rand(2, 3)
# array([[0.7906314 , 0.99339873, 0.54708756],
# [0.25511629, 0.71984337, 0.08435797]])
randn() 生成的数据是标准正态分布。
np.random.randn(2, 3)
# array([[-0.83634453, 0.17884118, -0.46238577],
# [-1.03986323, -0.78035816, -0.72730889]])
randint(low, high, size) 将会生成一个 [low, hign)' 区间中的整数。
np.random.randint(2, 7, (2, 3))
# array([[2, 2, 6],
# [4, 6, 5]])
random_sample() 将随机生成 [0, 1) 区间内生成指定大小的数组。
np.random.random_sample([3]) # array([0.69819341, 0.82746765, 0.81988758])
random()、ranf() 和 sample() 方法效果都差不多。
choice() 方法表示随机抽样，第二个参数表示抽样个数。
np.random.choice(10, 4) # array([5, 2, 4, 0])
后文还有更多的概率分布。
运算
数学运算符进行的计算是按照对应位置元素进行的。
a = np.array([[1, 2], [3, 4]])
b = np.array([[10, 20], [30, 40]])
c = b - a # 对应位置元素做减法，同理加法、乘法、除法，幂运算
# array([[ 9, 18],
# [27, 36]])
d = b ** 2
# array([[ 100, 400],
# [ 900, 1600]], dtype=int32)
e = b < 25
# array([[ True, True],
# [False, False]])
+=和*=符会修改现有的数组，而不创造新的数组。
a += b
print(a) # 数组 a 被修改了
# [[11 22]
# [33 44]]
如果需要进行矩阵乘法运算，则要使用@符或者dot()方法。
c = a @ b
c = a.dot(b)
# array([[ 70, 100],
# [150, 220]])
numpy 可以使用函数的方法对每个元素进行运算，如下表。
| 函数 | 功能 |
|---|---|
reciprocal(x) |
求倒数 |
sqrt(x) |
平方根 |
cbrt(x) |
立方根 |
square(x) |
平方 |
absolute(x) |
绝对值，可求解复数 |
fabs(x) |
绝对值 |
sign(x) |
符号函数 |
nan_to_num(x) |
用 0 替换 NaN |
negative(x) |
求相反数 |
modf(x1) |
返回数组的小数和整数部分 |
interp(x, xp, fp, left, right, period) |
线性插值 |
也可以使用函数的方法进行对应元素的数学运算，如下表。
| 函数 | 功能 |
|---|---|
add(x1, x2) |
对应元素相加 |
multiply(x1, x2) |
对应元素相乘 |
divide(x1, x2) |
对应元素相除 |
subtract(x1, x2) |
对应元素相减 |
power(x1, x2) |
对应元素计算次方 x1 ^ x2 |
fmod(x1, x2) |
对应元素求模 |
mod(x1, x2) |
对应元素求模 |
remainder(x1, x2) |
返回除法余数 |
maximum(x1, x2) |
最大值 |
minimum(x1, x2) |
最小值 |
还有一些矩阵运算，如下表。
| 函数 | 功能 |
|---|---|
dot(a, b) |
求解两个数组的点积 |
vdot(a, b) |
求解两个向量的点积 |
inner(a, b) |
求解两个数组的内积 |
outer(a, b) |
求解两个向量的外积 |
matmul(a, b) |
求解两个数组的矩阵乘积 |
tensordot(a, b) |
求解张量点积 |
kron(a, b) |
计算 Kronecker 乘积 |
还可以进行复数操作，如下表。
| 函数 | 功能 |
|---|---|
angle(z, deg) |
返回复参数的角度 |
real(val) |
返回数组元素的实部 |
imag(val) |
返回数组元素的虚部 |
conj(x) |
按元素方式返回共轭复数 |
convolve(a, v, mode) |
返回线性卷积 |
还可以进行代数运算，主要在 np.linalg 当中，如下表。
| 函数 | 功能 |
|---|---|
cholesky(a) |
Cholesky 分解 |
qr(a ,mode) |
计算矩阵的 QR 因式分解 |
svd(a ,full_matrices,compute_uv) |
奇异值分解 |
eig(a) |
计算正方形数组的特征值和右特征向量 |
eigh(a, UPLO) |
返回 Hermitian 或对称矩阵的特征值和特征向量 |
eigvals(a) |
计算矩阵的特征值 |
eigvalsh(a, UPLO) |
计算 Hermitian 或真实对称矩阵的特征值 |
norm(x ,ord,axis,keepdims) |
计算矩阵或向量范数 |
cond(x ,p) |
计算矩阵的条件数 |
det(a) |
计算数组的行列式 |
matrix_rank(M ,tol) |
使用奇异值分解方法返回秩 |
slogdet(a) |
计算数组的行列式的符号和自然对数 |
trace(a ,offset,axis1,axis2,dtype,out) |
沿数组的对角线返回总和 |
tensorsolve(a, b ,axes) |
为 x 解出张量方程 a x = b |
lstsq(a, b ,rcond) |
将最小二乘解返回到线性矩阵方程 |
inv(a) |
计算逆矩阵 |
pinv(a ,rcond) |
计算矩阵的（Moore-Penrose）伪逆 |
tensorinv(a ,ind) |
计算 N 维数组的逆 |
数学函数
numpy 提供了许多三角函数计算，如下表。
| 函数 | 功能 |
|---|---|
sin(x) |
正弦 |
cos(x) |
余弦 |
tan(x) |
正切 |
arcsin(x) |
反正弦 |
arccos(x) |
反余弦 |
arctan(x) |
反正切 |
hypot(x1,x2) |
直角三角形求斜边 |
degrees(x) |
弧度转换为度 |
radians(x) |
度转换为弧度 |
deg2rad(x) |
度转换为弧度 |
rad2deg(x) |
弧度转换为度 |
sinh(x) |
双曲正弦 |
cosh(x) |
双曲余弦 |
tanh(x) |
双曲正切 |
arcsinh(x) |
反双曲正弦 |
arccosh(x) |
反双曲余弦 |
arctanh(x) |
反双曲正切 |
numpy 还提供了一些指数、对数运算，如下表。
| 函数 | 功能 |
|---|---|
exp(x) |
计算输入数组中所有元素的指数 |
log(x) |
计算自然对数 |
log10(x) |
计算常用对数 |
log2(x) |
计算二进制对数 |
numpy 还可以进行一些四舍五入之类的运算，如下表。
| 函数 | 功能 |
|---|---|
around(a) |
平均到给定的小数位数 |
round_(a) |
将数组舍入到给定的小数位数 |
rint(x) |
最接近的整数 |
fix(x, y) |
向 0 舍入到最接近的整数 |
floor(x) |
返回输入的底部（标量 x 的底部是最大的整数 i） |
ceil(x) |
返回输入的上限(标量 x的底部是最小的整数 i) |
trunc(x) |
返回输入的截断值 |
还有一些求和、求积、差分运算，如下表。
| 函数 | 功能 |
|---|---|
sum(a, axis, dtype, keepdims) |
返回指定轴上的数组元素的总和 |
mean(a, axis, dtype, keepdims) |
返回指定轴上的数组元素的平均数 |
std(a, axis, dtype, keepdims) |
返回指定轴上的数组元素的标准差 |
var(a, axis, dtype, keepdims) |
返回指定轴上的数组元素的方差 |
prod(a, axis, dtype, keepdims) |
返回指定轴上的数组元素的乘积 |
nanprod(a, axis, dtype, keepdims) |
返回指定轴上的数组元素的乘积, 将 NaN 视作 1 |
nansum(a, axis, dtype, keepdims) |
返回指定轴上的数组元素的总和, 将 NaN 视作 0 |
cumprod(a, axis, dtype) |
返回沿给定轴的元素的累积乘积 |
cumsum(a, axis, dtype) |
返回沿给定轴的元素的累积总和 |
diff(a, n, axis) |
计算沿指定轴的第 n 个离散差分 |
ediff1d(ary, to_end, to_begin) |
数组的连续元素之间的差异 |
gradient(f) |
返回 N 维数组的梯度 |
cross(a, b, axisa, axisb, axisc, axis) |
返回两个(数组）向量的叉积 |
trapz(y, x, dx, axis) |
使用复合梯形规则沿给定轴积分 |
还有一些与集合有关的运算。
| 函数 | 功能 |
|---|---|
unique(x) |
计算唯一值，并返回有序结果 |
intersect1d(x, y) |
计算公共元素，并返回有序结果 |
union1d(x, y) |
计算并集，并返回有序结果 |
in1d(x, y) |
x 的元素是否包含于 y，并返回 bool 数组 |
setdiff1d(x, y) |
计算差集 |
setor1d(x, y) |
计算对称差 |
索引、切片、迭代
一维数组的索引方式如同列表 list。
a = np.array([1, 2, 3, 4, 5])
a[1] # 2
a[1: 4] # array([2, 3, 4])
a[0: 5: 2] # array([1, 3, 5])
a[5: 0: -2] # array([5, 3])
多维数组针对每个轴都有一个索引。
b = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [2, 4, 6, 8, 9]])
b[1, 2] # 8，索引相当于元组(1, 2)
b[1, 0: 3] # array([6, 7, 8])
b[1: 3, :]
# array([[ 6, 7, 8, 9, 10],
# [ 2, 4, 6, 8, 9]])
如果提供的索引的数量数少于轴数，等同于在索引数后加若干冒号:，或者是省略号...，认为是取全部值。
b[1] # array([ 6, 7, 8, 9, 10])
# 等同于
b[1, :]
b[1, ...]
迭代是以第一个轴为单位展开的。
for r in b:
print(r)
# array([1, 2, 3, 4, 5])
# array([ 6, 7, 8, 9, 10])
# array([2, 4, 6, 8, 9])
如果想操作所有元素，则可使用 flat 属性。
for e in b.flat:
print(e)
索引也可以是一个数组，取索引数组中每个索引位置的值。
i = np.array([0, 0, 2, 4])
a[i] # array([1, 1, 3, 5])
索引还可以是二维索引，不仅会取值，还会产生与索引数据相同形状的数组。
j = np.array([[0, 1], [2, 4]])
a[j]
# array([[1, 2],
# [3, 5]])
还可以用多个索引数组还标记一个索引，多个索引数组需要具有相同的形状。
i = np.array([[0, 1], [1, 2]])
j = np.array([[0, 1], [2, 4]])
b[i, j]
# array([[1, 7],
# [8, 9]])
索引还可以是 bool 值。
i = b > 5
i
# array([[False, False, False, False, False],
# [ True, True, True, True, True],
# [False, False, True, True, True]])
b[i] # array([ 6, 7, 8, 9, 10, 6, 8, 9])
b[i] = 0
b
# array([[1, 2, 3, 4, 5],
# [0, 0, 0, 0, 0],
# [2, 4, 0, 0, 0]])
形状操作
数组的维度大小可以被修改。ravel() 方法可以把一个高维数组变为一维数组；reshape() 方法可以改变数组的形状。
b = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [2, 4, 6, 8, 9]])
c = b.ravel() # array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 4, 6, 8, 9])
d = c.reshape(5, 3)
# array([[ 1, 2, 3],
# [ 4, 5, 6],
# [ 7, 8, 9],
# [10, 2, 4],
# [ 6, 8, 9]])
ravel() 方法还可以输入 order 参数，表示变换时的读取顺序，默认为C表示按行读取，还可以为 F 表示按列读取。
c2 = b.ravel(order='F') # array([ 1, 6, 2, 2, 7, 4, 3, 8, 6, 4, 9, 8, 5, 10, 9])
flatten() 方法也可以完成该操作，与 ravel() 方法不同是的，前者返回的数据的副本，而后者不会。
T属性可以进行转置，等同于 transpose()。该方法还可以传入参数，表示要交换的轴。
e = d.T
# array([[ 1, 4, 7, 10, 6],
# [ 2, 5, 8, 2, 8],
# [ 3, 6, 9, 4, 9]])
e = d.transpose() # 同 d.T
e = d.transpose(1, 0)
reshape()方法如果给定的维数为-1，则该维度会被自动计算。
上述三个方法都将形成新的数组，而原数组不变。resize() 方法将对原数组进行修改，作用同 reshape() 方法。
b.resize(5, 3)
b
# array([[ 1, 2, 3],
# [ 4, 5, 6],
# [ 7, 8, 9],
# [10, 2, 4],
# [ 6, 8, 9]])
上文提到的 swapaxes() 方法进行的也是类似操作。
反转
fliplr() 和 flipud() 方法分别实现数组的左右翻转和上下翻转。
b = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [2, 4, 6, 8, 9]])
np.fliplr(b)
# array([[ 5, 4, 3, 2, 1],
# [10, 9, 8, 7, 6],
# [ 9, 8, 6, 4, 2]])
np.flipud(b)
# array([[ 2, 4, 6, 8, 9],
# [ 6, 7, 8, 9, 10],
# [ 1, 2, 3, 4, 5]])
拼接
两个不同的数组，可以拼接成一个。vstack() 方法从垂直方向拼接两个数组；而 hstack() 方法从水平方向拼接两个数组。
a = np.array([[1, 2], [3, 4]])
b = np.array([[10, 20], [30, 40]])
np.vstack((a, b))
# array([[ 1, 2],
# [ 3, 4],
# [10, 20],
# [30, 40]])
np.hstack((a, b))
# array([[ 1, 2, 10, 20],
# [ 3, 4, 30, 40]])
column_stack() 方法可以把一维数组拼接成二维数组
c = np.array([1, 2])
d = np.array([3, 4])
np.column_stack((c, d))
# array([[1, 3],
# [2, 4]])
np.column_stack((a, b)) # 结果同 np.hstack((a, b))
这相当于分别把 c 和 d 转化为二维数组，再进行拼接。
from numpy import newaxis
c[:, newaxis] # array([[1], [2]])
d[:, newaxis] # array([[3], [4]])
np.hstack((c[:, newaxis], d[:, newaxis]))
hstack() 方法和 column_stack() 方法不一定相同，而 vstack() 与 row_stack() 方法相同。
当维度高于二维时，hstack() 方法拼接第二维，vstack() 方法拼接第一维，而 concatenate() 方法指定需要拼接的轴。
np.concatenate((a, b), axis=0)
# array([[ 1, 2],
# [ 3, 4],
# [10, 20],
# [30, 40]])
np.concatenate((a, b), axis=1)
# array([[ 1, 2, 10, 20],
# [ 3, 4, 30, 40]])
dstack() 按深度堆叠。
np.dstack((a, b))
# array([[[ 1, 10],
# [ 2, 20]],
# [[ 3, 30],
# [ 4, 40]]])
r_ 和 c_ 可以快速地拼接。
np.r_[1:4, 0, 4] # array([1, 2, 3, 0, 4])
拆分
hsplit() 方法从水平方向拆分数组，要么均分，要么指定分隔的列。
a = np.array([[1, 2, 3, 4, 5, 6], [6, 7, 8, 9, 10, 11], [2, 4, 6, 8, 9, 11]])
np.hsplit(a, 3)
# [array([[1, 2], [6, 7], [2, 4]]),
# array([[3, 4], [8, 9], [6, 8]]),
# array([[ 5, 6], [10, 11], [ 9, 11]])]
np.hsplit(a, (2, 5))
# [array([[1, 2], [6, 7], [2, 4]]),
# array([[ 3, 4, 5], [ 8, 9, 10], [ 6, 8, 9]]),
# array([[ 6], [11], [11]])]
vsplit() 方法则从垂直方向拆分，dsplit() 按深度拆分。
复制
赋值方法并不能复制数组。
a = np.array([1, 2, 3])
b = a
a 和 b 虽然具有不同的名称，但指向同一个数组。当改变a的时候，b会同时改变。为了防止这个问题，可以把数组复制一遍。view() 方法可以创建一个与原数组相同的新对象，但本身也不拥有数据。切片的原理与 view() 相同。
c = a.view()
c is a # False
c.base is a # True
深拷贝的方法可以完全复制一份数组。
d = a.copy()
d is a # False
d.base is a # False
深拷贝通常在切片之后使用。
排序
sort() 方法可以对多维数组进行排序。在默认情况下，sort() 可以传入第二个参数 axis，表示按哪个轴排序。输入 0 表示对每列排序，输入 1 表示对每行排序，默认为 -1，表示对最后一个轴进行排序，在此例二维数组中表示对每行进行排序。
c = np.random.rand(15).reshape(3, 5)
np.sort(c) # 对每行进行排序
# array([[0.25861013, 0.33057678, 0.34401767, 0.49997957, 0.5870218 ],
# [0.18214488, 0.20998969, 0.47754708, 0.57419159, 0.86377788],
# [0.47732562, 0.48471862, 0.56350148, 0.72815936, 0.89073706]])
#
np.sort(c, 0) # 对每列进行排序
# array([[0.48471862, 0.47732562, 0.20998969, 0.25861013, 0.18214488],
# [0.49997957, 0.57419159, 0.34401767, 0.47754708, 0.33057678],
# [0.86377788, 0.5870218 , 0.89073706, 0.56350148, 0.72815936]])
sort() 还可以传入第三个参数，表示排序算法，可选 quicksort （默认）、mergesort 和 heapsort。
另外还有 lexsort() 、argsort() 、 msort() 和 sort_complex() 算法。
搜索
numpy 中有一些方法可以对数组中的数进行搜索，如下表。
| 方法 | 含义 |
|---|---|
argmax(a ,axis,out) |
数组中指定轴的最大值的索引 |
nanargmax(a ,axis) |
数组中指定轴的最大值的索引，忽略 NaN |
argmin(a ,axis,out) |
数组中指定轴的最小值的索引 |
nanargmin(a ,axis) |
数组中指定轴的最小值的索引，忽略 NaN |
argwhere(a) |
数组中非 0 元素的索引，按元素分组 |
nonzero(a) |
数组中非 0 元素的索引 |
flatnonzero(a) |
数组中非 0 元素的索引，并铺平 |
where(condition, x, y) |
根据指定条件，从指定行、列返回元素 |
searchsorted(a,v ,side,sorter) |
查找要插入元素以维持顺序的索引 |
extract(condition,arr) |
满足某些条件的数组的元素 |
count_nonzero(a) |
计算数组中非 0 元素的数量 |
概率分布
上文介绍了几种产生随机数的方法，numpy 还提供了各种满足特定概率密度分布的样本生成方法，如下表。
| 方法 | 含义 |
|---|---|
beta(a，b，size) |
从 Beta 分布中生成随机数 |
binomial(n, p, size) |
从二项分布中生成随机数 |
chisquare(df，size) |
从卡方分布中生成随机数 |
dirichlet(alpha，size) |
从 Dirichlet 分布中生成随机数 |
exponential(scale，size) |
从指数分布中生成随机数 |
f(dfnum，dfden，size) |
从 F 分布中生成随机数 |
gamma(shape，scale，size) |
从 Gamma 分布中生成随机数 |
geometric(p，size) |
从几何分布中生成随机数 |
gumbel(loc，scale，size) |
从 Gumbel 分布中生成随机数 |
hypergeometric(ngood, nbad, nsample, size) |
从超几何分布中生成随机数 |
laplace(loc，scale，size) |
从拉普拉斯双指数分布中生成随机数 |
logistic(loc，scale，size) |
从逻辑分布中生成随机数 |
lognormal(mean，sigma，size) |
从对数正态分布中生成随机数 |
logseries(p，size) |
从对数系列分布中生成随机数 |
multinomial(n，pvals，size) |
从多项分布中生成随机数 |
multivariate_normal(mean, cov, size) |
从多变量正态分布绘制随机样本 |
negative_binomial(n, p, size) |
从负二项分布中生成随机数 |
noncentral_chisquare(df，nonc，size) |
从非中心卡方分布中生成随机数 |
noncentral_f(dfnum, dfden, nonc, size) |
从非中心 F 分布中抽取样本 |
normal(loc，scale，size) |
从正态分布绘制随机样本 |
pareto(a，size) |
从具有指定形状的 Pareto II 或 Lomax 分布中生成随机数 |
poisson(lam，size) |
从泊松分布中生成随机数 |
power(a，size) |
从具有正指数 a-1 的功率分布中在 0，1 中生成随机数 |
rayleigh(scale，size) |
从瑞利分布中生成随机数 |
standard_cauchy(size) |
从标准 Cauchy 分布中生成随机数 |
standard_exponential(size) |
从标准指数分布中生成随机数 |
standard_gamma(shape，size) |
从标准 Gamma 分布中生成随机数 |
standard_normal(size) |
从标准正态分布中生成随机数 |
standard_t(df，size) |
从具有 df 自由度的标准学生 t 分布中生成随机数 |
triangular(left，mode，right，size) |
从三角分布中生成随机数 |
uniform(low，high，size) |
从均匀分布中生成随机数 |
vonmises(mu，kappa，size) |
从 von Mises 分布中生成随机数 |
wald(mean，scale，size) |
从 Wald 或反高斯分布中生成随机数 |
weibull(a，size) |
从威布尔分布中生成随机数 |
zipf(a，size) |
从 Zipf 分布中生成随机数 |
读写
save() 和 load() 方法是读写磁盘数据的两个主要函数，默认情况下，是以未压缩的原始二进制格式保存在扩展名 .npy 文件中。
np.save('a', a) # 自动加上 .npy 后缀
np.load('a')
savez() 保存多个数组，读取时会得到一个类似字典的对象。
np.savez('ab.npz', a, b) # 保存多个数组
ab = np.load('ab.npz')
ab[a]
要将数据压缩可以使用 np.savez_compressed() 方法。
np.savez_compressed('ab.npz', a, b)
上文总结了一些 numpy 操作，更加权威准确的内容应当参考 numpy文档。