这一期简单讲一讲 Python 第三方 NumPy 库的使用。如果要更加详细的教程，这里推荐 NumPy 官网上的《Guide to NumPy》，如果需要电子书请在后台回复【numpybook】。
安装 Numpy 模块
安装 NumPy 模块推荐使用 pip 工具安装：
安装完成后，进入 python 编译环境，输入下面的命令导入 NumPy 模块：
如果没有报错，证明 NumPy 模块安装成功。
ndarray 对象
在 NumPy 中，一个经常用到的就是 n 维数组对象 ndarray ，它是用于存放同类型元素的多维数组，内部由一个指向数据的指针、数据类型、表示数组形状的元组和一个跨度元组组成。
创建一个 ndarray 只需要调用 NumPy 模块的 array 函数：
numpy.array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, like=None)
参数的含义：
- object：可以是数组或者嵌套的数列
- dtype：数据类型（可选参数）
- copy：对象是否需要复制（可选参数）
- order：指定数组的内存布局（可选参数）
- subok：默认返回一个与基类类型一致的数组
- ndmin：指定生成数组的最小维度
- like：参考对象，允许创建的数组不是 NumPy 数组
关于更多内容，可以使用下面的命令进行查看：
import numpy
help(numpy.array)
下面我们通过例子讲解 numpy.array() 函数的使用。
0D张量（标量）
创建一个标量（scalar，也叫做标量张量、零维张量、0D张量）：
>>> import numpy
>>> x = numpy.array(123)
>>> x
array(123)
>>> x.ndim
0
在 NumPy 中一个 float32 或者 float64 的数字是一个标量张量，我们可以通过 ndim 属性查看一个 NumPy 张量的阶（rank）的个数，标量张量为 0 阶（也称为轴），所以上面的例子输出的结果为 0 。
1D张量（向量）
创建一个向量（vector，也叫做一维张量、1D张量）：
>>> import numpy
>>> x = numpy.array([1, 2, 3])
>>> x
array([1, 2, 3])
>>> print(x)
[1 2 3]
>>> x.ndim
1
2D张量（矩阵）
创建一个矩阵（matrix，也叫做二维张量、2D张量）：
>>> import numpy
>>> x = numpy.array([[1, 2, 3],
... [4, 5, 6],
... [7, 8, 9]])
>>> x
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> print(x)
[[1 2 3]
[4 5 6]
[7 8 9]]
>>> x.ndim
2
矩阵有 2 个轴，即行和列。第一个轴上的元素称为行，第二个轴上的元素称为列。
3D张量
创建一个3D张量：
>>> import numpy
>>> x = numpy.array([[[1, 2, 3],
... [4, 5, 6],
... [7, 8, 9]],
... [[1, 2, 3],
... [4, 5, 6],
... [7, 8, 9]],
... [[1, 2, 3],
... [4, 5, 6],
... [7, 8, 9]]])
>>> x
array([[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]],
[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]],
[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]])
>>> print(x)
[[[1 2 3]
[4 5 6]
[7 8 9]]
[[1 2 3]
[4 5 6]
[7 8 9]]
[[1 2 3]
[4 5 6]
[7 8 9]]]
>>> x.ndim
3
3D张量简单讲就是一个数字组成的立方体。通过将多个3D张量组合成一个数组，我们可以创建一个4D张量。
最小维度设定
创建一个二维张量但只给定一个维度的数据：
>>> import numpy
>>> x = numpy.array([1, 2, 3], ndmin = 2)
>>> x
array([[1, 2, 3]])
>>> print(x)
[[1 2 3]]
>>> x.ndim
2
张量数据类型设定
创建一个一维张量，但类型为复数：
>>> import numpy
>>> x = numpy.array([1, 2, 3], dtype = complex)
>>> x
array([1.+0.j, 2.+0.j, 3.+0.j])
数组属性
NumPy 数组中一些重要的属性有：
- ndim：维度的个数（轴的个数、秩）
- shape：数组的维度
- size：数组元素的总个数
- dtype：元素的数据类型
- itemsize：每个元素的大小，以字节为单位
- flags：对象的内存信息
- real：元素的实部
- imag：元素的虚部
- data：包含实际数组元素的缓冲区
ndim
返回数组维度的个数：
>>> import numpy
>>> x = numpy.array([1, 2, 3])
>>> x.ndim
1
shape
数组的维度，返回一个元组，元组长度为维度的个数，即 ndim ：
>>> import numpy
>>> x = numpy.array([[1, 2, 3], [4, 5, 6]])
>>> x.shape
(2, 3)
>>> x.ndim
2
size
数组元素的总个数，例如 n * m 的矩阵，元素个数为 n * m ：
>>> import numpy
>>> x = numpy.array([[1, 2, 3], [4, 5, 6]])
>>> x.size
6
dtype
数组元素的数据类型：
>>> import numpy
>>> x = numpy.array([[1, 2, 3], [4, 5, 6]])
>>> x.dtype
dtype('int64')
itemsize
以字节为单位返回数组中每个元素的大小：
>>> import numpy
>>> x = numpy.array([[1, 2, 3], [4, 5, 6]])
>>> x.dtype
dtype('int64')
>>> x.itemsize
8
int64 占 64 个 bits，每个字节 8 个 bits，即占 8 个字节。
flags
返回对象的内存信息：
>>> import numpy
>>> x = numpy.array([[1, 2, 3], [4, 5, 6]])
>>> x.flags
C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
可以看到，对象内存信息的属性有：
- C_CONTIGUOUS：数据是否在一个单一的C风格的连续段中
- F_CONTIGUOUS：数据是否在一个单一的Fortran风格的连续段中
- OWNDATA：数组是否拥有它所使用的内存或从另一个对象中借用它
- WRITEABLE：数据区域是否可以被写入，将该值设置为 False，则数据为只读
- ALIGNED：数据和所有元素是否都适当地对齐到硬件上
- WRITEBACKIFCOPY：这个数组是否是另一个数组的副本
- UPDATEIFCOPY：这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新
创建数组
除了上面讲到的使用 numpy.array 创建数组外，我们还可以使用下面的方法创建数组：
empty
使用此方法可以创建一个指定 shape 和 dtype 的未初始化的数组：
empty(shape, dtype=None, order='C', *args, **kwargs)
参数含义如下：
- shape：数组形状
- dtype：数据类型（可选）
- order：列优先还是行优先（可选）
>>> import numpy
>>> x = numpy.empty([2, 3])
>>> x
array([[1.96735833e-316, 0.00000000e+000, 6.90482248e-310],
[6.90482248e-310, 0.00000000e+000, 2.07507571e-322]])
因为是未初始化的数组，所以元素的值为随机值。
zeros
使用此方法可以创建一个指定 shape 和 dtype 的数组，并且元素默认都为 0 ：
zeros(shape, dtype=None, order='C', *args, **kwargs)
参数含义如下：
- shape：数组形状
- dtype：数据类型（可选）
- order：列优先还是行优先（可选）
>>> import numpy
>>> x = numpy.zeros([2, 3])
>>> x
array([[0., 0., 0.],
[0., 0., 0.]])
ones
使用此方法可以创建一个指定 shape 和 dtype 的数组，并且元素默认都为 1 ：
ones(shape, dtype=None, order='C', *, like=None)
参数含义如下：
- shape：数组形状
- dtype：数据类型（可选）
- order：列优先还是行优先（可选）
>>> import numpy
>>> x = numpy.ones([2, 3])
>>> x
array([[1., 1., 1.],
[1., 1., 1.]])
arange
使用此函数可以创建一个指定数值范围的 ndarray 对象：
arange(start, stop, step, dtype)
参数含义如下：
- start：起始值，默认是 0
- stop：终止值（不包含终止值）
- step：步长，默认是 1
- dtype：数据类型
>>> import numpy
>>> x = numpy.arange(10)
>>> x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> y = numpy.arange(2, 10, 2)
>>> y
array([2, 4, 6, 8])
linspace
使用此函数可以创建一个等差数列：
linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
参数含义如下：
- start：起始值
- stop：终止值（默认包含终止值），如果 endpoint 参数为 false 则不包含终止值
- num：要生成的等步长的样本数量，默认为 50
- endpoint：该值为 True 时，数列中包含 stop 值，默认是 True
- retstep：该值为 True 时，生成的数组中会显示间距，默认是 False 不显示
- dtype：数据类型
>>> import numpy
>>> x = numpy.linspace(3, 8, 6)
>>> x
array([3., 4., 5., 6., 7., 8.])
>>> y = numpy.linspace(4, 4, 5)
>>> y
array([4., 4., 4., 4., 4.])
logspace
使用此函数可以创建一个等比数列：
logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)
参数含义如下：
- start：起始值为 base 的 start 次方
- stop：终止值为 base 的 stop 次方（默认包含终止值），如果 endpoint 参数为 false 则不包含终止值
- num：要生成的等步长的样本数量，默认为 50
- endpoint：该值为 True 时，数列中包含 stop 值，默认是 True
- base：对数 log 的底数
- dtype：数据类型
>>> import numpy
>>> x = numpy.logspace(0, 10, num = 11, base = 2, dtype = int)
>>> x
array([ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024])
asarray
使用此函数可以将元组、列表、多维数组转换成一个 ndarray ：
asarray(a, dtype = None, order = None)
参数含义如下：
- a：任意形式的输入参数，可以是列表、元组、列表的元组、元组的元组、元组的列表、多维数组
- dtype：数据类型（可选）
- order：列优先还是行优先（可选）
>>> import numpy
>>> list = [1, 2, 3, 4]
>>> x = numpy.asarray(list)
>>> x
array([1, 2, 3, 4])
>>> tuple = (1, 2, 3, 4)
>>> y = numpy.asarray(tuple)
>>> y
array([1, 2, 3, 4])
>>> tuple_list = [(1, 2, 3), (4, 5, 6)]
>>> z = numpy.asarray(tuple_list)
>>> z
array([[1, 2, 3],
[4, 5, 6]])
frombuffer
使用此函数可以实现动态数组：
frombuffer(buffer, dtype = float, count = -1, offset = 0)
参数含义如下：
- buffer：以流的形式读入的任意对象
- dtype：数据类型（可选）
- count：读取的数据量，默认读取所有数据，值为 -1
- offset：读取的起始位置，默认是 0
>>> import numpy
>>> str = b"hello numpy"
>>> x = numpy.frombuffer(str, dtype = 'S1')
>>> print(x)
[b'h' b'e' b'l' b'l' b'o' b' ' b'n' b'u' b'm' b'p' b'y']
注意，在 Python3 中默认的 str 是 Unicode 类型，要转成 bytestring 类型，即在 str 前加上 b 。
fromiter
使用此函数可以从迭代对象中建立 ndarray 对象：
fromiter(iterable, dtype, count=-1)
参数含义如下：
- iterable：可迭代对象
- dtype：数据类型
- count：读取的数据量，默认读取所有数据，值为 -1
>>> import numpy
>>> list = range(10)
>>> it = iter(list)
>>> x = numpy.fromiter(it, dtype = float)
>>> x
array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
切片
ndarray 对象可以通过切片操作来访问。其操作与 list 的切片操作一致。下面是一个简单的例子：
>>> import numpy
>>> x = numpy.arange(10)
>>> y = x[4:8:2]
>>> y
array([4, 6])
下面是对高维张量进行切割操作的例子：
>>> import numpy
>>> x = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> x
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> y = x[1:]
>>> y
array([[4, 5, 6],
[7, 8, 9]])
我们也可以使用 ... 切割某一列或者某一行的元素：
>>> import numpy
>>> x = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> x
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> y = x[1, ...]
>>> y
array([4, 5, 6])
>>> z = x[..., 1]
>>> z
array([2, 5, 8])
我们也可以将 , 和 : 结合使用，切割某一部分元素：
>>> import numpy
>>> x = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
>>> x
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
>>> y = x[0:2, 1:4]
>>> y
array([[2, 3, 4],
[6, 7, 8]])
索引
ndarray 对象可以通过索引操作来访问或者修改。普通的索引这里就不再赘述，下面介绍几种 NumPy 提供的索引方式。
整数数组索引
我们可以通过整数数组索引访问特定位置的元素，下面的例子访问的是 (0, 2) 和 (1, 3) 位置处的元素：
>>> import numpy
>>> x = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
>>> x
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
>>> y = x[[0,1], [2,3]]
>>> y
array([3, 8])
布尔索引
我们可以通过布尔运算获取符合特定条件元素的数组：
>>> import numpy
>>> x = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
>>> x
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
>>> y = x[x > 9]
>>> y
array([10, 11, 12])
花式索引
花式索引指的是利用整数数组进行索引。
>>> import numpy
>>> x = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
>>> x
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
>>> y = x[[2, 0, 1]] # 提取第 2 行、第 0 行、第 1 行元素
>>> y
array([[ 9, 10, 11, 12],
[ 1, 2, 3, 4],
[ 5, 6, 7, 8]])
上面是按顺序提取某几行的例子，当然这里可以使用负数，下面的例子使用 numpy.ix_ 函数提取特定行和列元素：
>>> import numpy
>>> x = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
>>> x
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
>>> y = x[numpy.ix_([1, 2], [0, 1])] # 提取行坐标为 1 或 2 且列坐标为 0 或 1 的元素
>>> y
array([[ 5, 6],
[ 9, 10]])
NumPy 广播
当两个 ndarray 对象的 shape 相同时，两个进行运算的结果就是对应的各自位进行运算：
>>> import numpy
>>> x = numpy.array([[1, 2, 3], [4, 5, 6]])
>>> y = numpy.array([[10, 20, 30], [40, 50, 60]])
>>> x
array([[1, 2, 3],
[4, 5, 6]])
>>> y
array([[10, 20, 30],
[40, 50, 60]])
>>> z = x + y
>>> z
array([[11, 22, 33],
[44, 55, 66]])
但如果两个对象的 shape 不同时，就会触发广播机制，重复补充缺失的维度进行对应的位进行运算：
>>> import numpy
>>> x = numpy.array([[1, 2, 3], [4, 5, 6]])
>>> y = numpy.array([10, 20, 30])
>>> x
array([[1, 2, 3],
[4, 5, 6]])
>>> y
array([10, 20, 30])
>>> z = x + y
>>> z
array([[11, 22, 33],
[14, 25, 36]])
使用 nditer 对 ndarray 对象进行迭代
迭代 ndarray 对象可以使用 nditer 方法：
>>> import numpy
>>> x = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> x
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> for num in numpy.nditer(x):
... print(num, end="\t")
...
1 2 3 4 5 6 7 8 9
当然，这里遍历的顺序是行序优先，可以通过指定 order 参数以列序优先进行遍历。
>>> import numpy
>>> x = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> x
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> for num in numpy.nditer(x, order = 'F'):
... print(num, end="\t")
...
1 4 7 2 5 8 3 6 9
修改 ndarray 的值
使用 nditer 方法可以迭代遍历数组的同时，也能够修改 ndarray 对象的值，但必须指定 op_flags 参数为 readwrite 模式：
>>> import numpy
>>> x = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> x
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> for num in numpy.nditer(x, op_flags=['readwrite']):
... num[...] = 10 * num
...
>>> x
array([[10, 20, 30],
[40, 50, 60],
[70, 80, 90]])
数组操作
reshape
使用 reshape 函数可以修改数组形状：
reshape(a, newshape, order='C')
参数含义如下：
- a：要修改形状的数组
- newshape：新的形状，整数或整数数组
- order：排列方式，'C'是按行，'F'是按列，'A'是原顺序
>>> import numpy
>>> x = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8]])
>>> x
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
>>> y = numpy.reshape(x, [4, 2])
>>> y
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
>>> z = x.reshape(4, 2)
>>> z
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
ndarray.flat
迭代数组，我们还可以使用数组元素迭代器：
>>> import numpy
>>> x = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8]])
>>> x
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
>>> for num in x.flat:
... print(num, end="\t")
...
1 2 3 4 5 6 7 8
ndarray.flatten
我们还可以对数组进行拷贝：
>>> import numpy
>>> x = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8]])
>>> x
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
>>> y = x.flatten()
>>> y
array([1, 2, 3, 4, 5, 6, 7, 8])
>>> z = x.flatten(order = 'F')
>>> z
array([1, 5, 2, 6, 3, 7, 4, 8])
ravel
展平数组元素，返回数组视图，修改会影响原始数组：
>>> import numpy
>>> x = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8]])
>>> x
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
>>> x.ravel()
array([1, 2, 3, 4, 5, 6, 7, 8])
transpose
该函数可以对数组的维度进行对换：
>>> import numpy
>>> x = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8]])
>>> x
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
>>> y = numpy.transpose(x)
>>> y
array([[1, 5],
[2, 6],
[3, 7],
[4, 8]])
ndarray.T
与上面的 transpose 函数类似，该函数是对数组进行转置：
>>> import numpy
>>> x = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8]])
>>> x
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
>>> z = x.T
>>> z
array([[1, 5],
[2, 6],
[3, 7],
[4, 8]])
swapaxes
该函数用于交换数组的两个轴：
>>> import numpy
>>> x = numpy.arange(8).reshape(2, 2, 2)
>>> x
array([[[0, 1],
[2, 3]],
[[4, 5],
[6, 7]]])
>>> y = numpy.swapaxes(x, 2, 0)
>>> y
array([[[0, 4],
[2, 6]],
[[1, 5],
[3, 7]]])
concatenate
该函数用于连接相同形状的两个或多个数组：
>>> import numpy
>>> x = numpy.array([[1, 2], [3, 4]])
>>> y = numpy.array([[5, 6], [7, 8]])
>>> a = numpy.concatenate((x, y))
>>> a
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
>>> b = numpy.concatenate((x, y), axis = 1)
>>> b
array([[1, 2, 5, 6],
[3, 4, 7, 8]])
stack
该函数用于沿新轴连接数组序列：
>>> import numpy
>>> x = numpy.array([[1, 2], [3, 4]])
>>> y = numpy.array([[5, 6], [7, 8]])
>>> x
array([[1, 2],
[3, 4]])
>>> y
array([[5, 6],
[7, 8]])
>>> a = numpy.stack((x, y), 0)
>>> a
array([[[1, 2],
[3, 4]],
[[5, 6],
[7, 8]]])
>>> b = numpy.stack((x, y), 1)
>>> b
array([[[1, 2],
[5, 6]],
[[3, 4],
[7, 8]]])
hstack
该函数通过水平堆叠生成数组：
>>> import numpy
>>> x = numpy.array([[1, 2], [3, 4]])
>>> y = numpy.array([[5, 6], [7, 8]])
>>> x
array([[1, 2],
[3, 4]])
>>> y
array([[5, 6],
[7, 8]])
>>> a = numpy.hstack((x, y))
>>> a
array([[1, 2, 5, 6],
[3, 4, 7, 8]])
vstack
该函数通过垂直堆叠生成数组：
>>> import numpy
>>> x = numpy.array([[1, 2], [3, 4]])
>>> y = numpy.array([[5, 6], [7, 8]])
>>> x
array([[1, 2],
[3, 4]])
>>> y
array([[5, 6],
[7, 8]])
>>> b = numpy.vstack((x, y))
>>> b
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
split
该函数沿特定的轴将数组分割成子数组：
>>> import numpy
>>> x = numpy.arange(16).reshape(4, 4)
>>> x
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> a = numpy.split(x, 2)
>>> a
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
>>> b = numpy.split(x, 2, 1)
>>> b
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
hsplit
该函数用于水平分割数组：
>>> import numpy
>>> x = numpy.arange(16).reshape(4, 4)
>>> x
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> a = numpy.hsplit(x, 4)
>>> a
[array([[ 0],
[ 4],
[ 8],
[12]]), array([[ 1],
[ 5],
[ 9],
[13]]), array([[ 2],
[ 6],
[10],
[14]]), array([[ 3],
[ 7],
[11],
[15]])]
vsplit
该函数用于垂直分割数组：
>>> import numpy
>>> x = numpy.arange(16).reshape(4, 4)
>>> x
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> a = numpy.vsplit(x, 2)
>>> a
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
resize
该函数返回指定大小的新数组：
>>> import numpy
>>> x = numpy.arange(16).reshape(4, 4)
>>> x
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> a = numpy.resize(x, (2, 8))
>>> a
array([[ 0, 1, 2, 3, 4, 5, 6, 7],
[ 8, 9, 10, 11, 12, 13, 14, 15]])
>>> b = numpy.resize(x, (3, 8))
>>> b
array([[ 0, 1, 2, 3, 4, 5, 6, 7],
[ 8, 9, 10, 11, 12, 13, 14, 15],
[ 0, 1, 2, 3, 4, 5, 6, 7]])
append
该函数在数组的末尾添加值：
>>> import numpy
>>> x = numpy.arange(6).reshape(2, 3)
>>> x
array([[0, 1, 2],
[3, 4, 5]])
>>> a = numpy.append(x, [6, 7, 8])
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> b = numpy.append(x, [[6, 7, 8]], axis = 0)
>>> b
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> c = numpy.append(x, [[6, 7, 8], [9, 10, 11]], axis = 1)
>>> c
array([[ 0, 1, 2, 6, 7, 8],
[ 3, 4, 5, 9, 10, 11]])
insert
该函数在给定索引之前，沿给定轴在输入数组中插入值：
>>> import numpy
>>> x = numpy.arange(6).reshape(3, 2)
>>> x
array([[0, 1],
[2, 3],
[4, 5]])
>>> a = numpy.insert(x, 3, [88, 99])
>>> a
array([ 0, 1, 2, 88, 99, 3, 4, 5])
>>> b = numpy.insert(x, 1, [99], axis = 0)
>>> b
array([[ 0, 1],
[99, 99],
[ 2, 3],
[ 4, 5]])
>>> c = numpy.insert(x, 1, 99, axis = 1)
>>> c
array([[ 0, 99, 1],
[ 2, 99, 3],
[ 4, 99, 5]])
delete
该函数返回从输入数组中删除指定子数组的新数组：
>>> import numpy
>>> x = numpy.arange(6).reshape(3, 2)
>>> x
array([[0, 1],
[2, 3],
[4, 5]])
>>> a = numpy.delete(x, 3)
>>> a
array([0, 1, 2, 4, 5])
>>> b = numpy.delete(x, 1, axis = 1)
>>> b
array([[0],
[2],
[4]])
unique
该函数用于去除数组中的重复元素：
>>> import numpy
>>> x = numpy.array([[1, 1, 2], [3, 4, 3]])
>>> x
array([[1, 1, 2],
[3, 4, 3]])
>>> y = numpy.unique(x)
>>> y
array([1, 2, 3, 4])
位运算
bitwise_and
该函数可以对数组中的整数进行二进制与运算：
>>> import numpy
>>> x = bin(13)
>>> x
'0b1101'
>>> y = bin(17)
>>> y
'0b10001'
>>> z = numpy.bitwise_and(13, 17)
>>> z
1
>>> x = numpy.array([12, 13])
>>> y = numpy.array([17, 17])
>>> z = numpy.bitwise_and(x, y)
>>> z
array([0, 1])
bitwise_or
该函数可以对数组中的整数进行二进制或运算：
>>> import numpy
>>> x = numpy.array([12, 13])
>>> y = numpy.array([17, 17])
>>> z = numpy.bitwise_or(x, y)
>>> z
array([29, 29])
invert
该函数对数组中整数进行位取反运算，对于有符号整数，取该二进制数的补码，然后 +1 ：
>>> import numpy
>>> x = numpy.array([13])
>>> z = numpy.invert(x)
>>> z
array([-14])
>>> x = numpy.array([13], dtype = numpy.uint8)
>>> z = numpy.invert(x)
>>> z
array([242], dtype=uint8)
left_shift
该函数将数组元素的二进制形式向左移动到指定位置，右侧附加相等数量的 0：
>>> import numpy
>>> x = numpy.left_shift(5, 2)
>>> x
20
right_shift
该函数将数组元素的二进制形式向右移动到指定位置，左侧附加相等数量的 0：
>>> import numpy
>>> x = numpy.right_shift(40, 1)
>>> x
20
字符串处理
char.add
该函数依次对两个数组的元素进行字符串连接：
>>> import numpy
>>> str1 = numpy.array(["hello"])
>>> str2 = numpy.array([" numpy"])
>>> x = numpy.char.add(str1, str2)
>>> x
array(['hello numpy'], dtype='<U11')
char.multiply
该函数执行多重连接：
>>> import numpy
>>> print(numpy.char.multiply("hi ", 5))
hi hi hi hi hi
char.center
该函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充：
>>> import numpy
>>> print(numpy.char.center('NumPy', 20, fillchar = '='))
=======NumPy========
char.capitalize
该函数将字符串的第一个字母转换为大写：
>>> import numpy
>>> print(numpy.char.capitalize("numpy"))
Numpy
char.title
该函数将字符串的每个单词的第一个字母转换为大写：
>>> import numpy
>>> print(numpy.char.title("i like numpy"))
I Like Numpy
char.lower
该函数对数组的每个元素转换为小写：
>>> import numpy
>>> print(numpy.char.lower("I LIKE NUMPY"))
i like numpy
char.upper
该函数对数组的每个元素转换为大写：
>>> import numpy
>>> print(numpy.char.upper("i like numpy"))
I LIKE NUMPY
char.split
该函数通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格：
>>> import numpy
>>> print(numpy.char.split("i like numpy"))
['i', 'like', 'numpy']
>>> print(numpy.char.split("127.0.0.1", sep = "."))
['127', '0', '0', '1']
char.splitlines
该函数以换行符作为分隔符来分割字符串，并返回数组：
>>> import numpy
>>> print(numpy.char.splitlines("i\nlike\nnumpy"))
['i', 'like', 'numpy']
>>> print(numpy.char.splitlines("i\rlike\rnumpy"))
['i', 'like', 'numpy']
>>> print(numpy.char.splitlines("i\r\nlike\r\nnumpy"))
['i', 'like', 'numpy']
char.strip
该函数用于移除开头或结尾处的特定字符：
>>> import numpy
>>> print(numpy.char.strip("abbba accca", "a"))
bbba accc
>>> print(numpy.char.strip(["abbba", "accca", "adddadddda"], "a"))
['bbb' 'ccc' 'dddadddd']
char.join
该函数通过指定分隔符来连接数组中的元素或字符串：
>>> import numpy
>>> print(numpy.char.join("-", "numpy"))
n-u-m-p-y
>>> print(numpy.char.join(["-", "="], ["numpy", "python"]))
['n-u-m-p-y' 'p=y=t=h=o=n']
char.replace
该函数使用新字符串替换字符串中的所有子字符串：
>>> import numpy
>>> print(numpy.char.replace("i like numpy", "numpy", "python"))
i like python
char.encode
该函数对数组中的每个元素调用 str.encode 函数。默认编码是 utf-8，可以使用标准 Python 库中的编解码器：
>>> import numpy
>>> print(numpy.char.encode("numpy", "utf16"))
b'\xff\xfen\x00u\x00m\x00p\x00y'
char.decode
该函数对编码的元素进行 str.decode() 解码：
>>> import numpy
>>> str = numpy.char.encode("numpy", "cp500")
>>> str
array(b'\x95\xa4\x94\x97\xa8', dtype='|S5')
>>> print(numpy.char.decode(str, "cp500"))
numpy
数学函数
三角函数
三角函数包括 sin() 、 cos() 、 tan() 、 arcsin() 、 arccos() 、 arctan() ，要注意的是传入的参数单位是弧度， degrees() 函数可以将弧度转换为角度：
>>> import numpy
>>> x = numpy.array([0, 30, 45, 60, 90])
>>> x
array([ 0, 30, 45, 60, 90])
>>> a = numpy.sin(x * numpy.pi / 180)
>>> a
array([0. , 0.5 , 0.70710678, 0.8660254 , 1. ])
>>> b = numpy.cos(x * numpy.pi / 180)
>>> b
array([1.00000000e+00, 8.66025404e-01, 7.07106781e-01, 5.00000000e-01,
6.12323400e-17])
>>> c = numpy.tan(x * numpy.pi / 180)
>>> c
array([0.00000000e+00, 5.77350269e-01, 1.00000000e+00, 1.73205081e+00,
1.63312394e+16])
>>> d = numpy.arcsin(a)
>>> d
array([0. , 0.52359878, 0.78539816, 1.04719755, 1.57079633])
>>> print(numpy.degrees(d))
[ 0. 30. 45. 60. 90.]
>>> e = numpy.arccos(b)
>>> e
array([0. , 0.52359878, 0.78539816, 1.04719755, 1.57079633])
>>> print(numpy.degrees(e))
[ 0. 30. 45. 60. 90.]
>>> f = numpy.arctan(c)
>>> f
array([0. , 0.52359878, 0.78539816, 1.04719755, 1.57079633])
>>> print(numpy.degrees(f))
[ 0. 30. 45. 60. 90.]
around
该函数返回指定数字的四舍五入值：
参数含义如下：
- a：数组
- decimals：舍入的小数位数，默认值为 0，如果为负，整数将四舍五入到小数点左侧的位置
>>> import numpy
>>> x = numpy.array([1.0, 3.14, 618, 0.123, 12.123456])
>>> x
array([1.0000000e+00, 3.1400000e+00, 6.1800000e+02, 1.2300000e-01,
1.2123456e+01])
>>> print(numpy.around(x))
[ 1. 3. 618. 0. 12.]
>>> print(numpy.around(x, decimals = 1))
[1.00e+00 3.10e+00 6.18e+02 1.00e-01 1.21e+01]
>>> print(numpy.around(x, decimals = -1))
[ 0. 0. 620. 0. 10.]
向上/下取整
floor() 返回小于或者等于指定表达式的最大整数，即向下取整，ceil() 返回大于或者等于指定表达式的最小整数，即向上取整：
>>> import numpy
>>> x = numpy.array([3.14, 5.56, 6.78])
>>> x
array([3.14, 5.56, 6.78])
>>> print(numpy.floor(x))
[3. 5. 6.]
>>> print(numpy.ceil(x))
[4. 6. 7.]
算术函数
add
该函数对数组进行相加运算：
>>> import numpy
>>> x = numpy.arange(9).reshape(3, 3)
>>> y = numpy.array([10, 10, 10])
>>> x
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> y
array([10, 10, 10])
>>> numpy.add(x, y)
array([[10, 11, 12],
[13, 14, 15],
[16, 17, 18]])
subtract
该函数对数组进行相减运算：
>>> import numpy
>>> x = numpy.arange(9).reshape(3, 3)
>>> y = numpy.array([10, 10, 10])
>>> x
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> y
array([10, 10, 10])
>>> numpy.subtract(x, y)
array([[-10, -9, -8],
[ -7, -6, -5],
[ -4, -3, -2]])
multiply
该函数对数组进行相乘运算：
>>> import numpy
>>> x = numpy.arange(9).reshape(3, 3)
>>> y = numpy.array([10, 10, 10])
>>> x
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> y
array([10, 10, 10])
>>> numpy.multiply(x, y)
array([[ 0, 10, 20],
[30, 40, 50],
[60, 70, 80]])
divide
该函数对数组进行相除运算：
>>> import numpy
>>> x = numpy.arange(9).reshape(3, 3)
>>> y = numpy.array([10, 10, 10])
>>> x
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> y
array([10, 10, 10])
>>> numpy.divide(x, y)
array([[0. , 0.1, 0.2],
[0.3, 0.4, 0.5],
[0.6, 0.7, 0.8]])
reciprocal
该函数返回参数逐元素的倒数：
>>> import numpy
>>> x = numpy.array([0.25, 0.5, 10])
>>> x
array([ 0.25, 0.5 , 10. ])
>>> numpy.reciprocal(x)
array([4. , 2. , 0.1])
power
该函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂：
>>> import numpy
>>> x = numpy.array([10, 100, 100])
>>> numpy.power(x, 2)
array([ 100, 10000, 10000])
mod
计算输入数组中相应元素的相除后的余数：
>>> import numpy
>>> x = numpy.array([11, 13, 17])
>>> y = numpy.array([3, 5, 6])
>>> x
array([11, 13, 17])
>>> y
array([3, 5, 6])
>>> numpy.mod(x, y)
array([2, 3, 5])
统计函数
amin
该函数计算数组中的元素沿指定轴的最小值：
>>> import numpy
>>> x = numpy.arange(9).reshape(3, 3)
>>> x
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> numpy.amin(x, 0)
array([0, 1, 2])
>>> numpy.amin(x, 1)
array([0, 3, 6])
>>> numpy.amin(x)
0
amax
该函数计算数组中的元素沿指定轴的最大值：
>>> import numpy
>>> x = numpy.arange(9).reshape(3, 3)
>>> x
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> numpy.amax(x, 0)
array([6, 7, 8])
>>> numpy.amax(x, 1)
array([2, 5, 8])
>>> numpy.amax(x)
8
ptp
该函数计算数组中元素最大值与最小值的差，或者轴中最大值与最小值的差：
>>> import numpy
>>> x = numpy.arange(9).reshape(3, 3)
>>> x
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> numpy.ptp(x)
8
>>> numpy.ptp(x, 0)
array([6, 6, 6])
>>> numpy.ptp(x, 1)
array([2, 2, 2])
percentile
该函数计算一个多维数组的任意百分比分位数：
参数含义如下：
- a：数组
- q：要计算的百分位数，在 0 ~ 100 之间
- axis：沿着它计算百分位数的轴
>>> import numpy
>>> x = numpy.array([[10, 7, 4], [3, 2, 1]])
>>> x
array([[10, 7, 4],
[ 3, 2, 1]])
>>> numpy.percentile(x, 50)
3.5
>>> numpy.percentile(x, 50, 0)
array([6.5, 4.5, 2.5])
>>> numpy.percentile(x, 50, 1)
array([7., 2.])
median
该函数用于计算数组中元素的中位数：
>>> import numpy
>>> x = numpy.arange(16).reshape(4, 4)
>>> x
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> numpy.median(x)
7.5
>>> numpy.median(x, 0)
array([6., 7., 8., 9.])
>>> numpy.median(x, 1)
array([ 1.5, 5.5, 9.5, 13.5])
mean
该函数用于计算数组中元素的算术平均值，算术平均值是沿轴的元素的总和除以元素的数量：
>>> import numpy
>>> x = numpy.arange(16).reshape(4, 4)
>>> x
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> numpy.mean(x)
7.5
>>> numpy.mean(x, 0)
array([6., 7., 8., 9.])
>>> numpy.mean(x, 1)
array([ 1.5, 5.5, 9.5, 13.5])
average
该函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值：
>>> import numpy
>>> x = numpy.array([1, 2, 3, 4])
>>> wts = numpy.array([4, 3, 2, 1])
>>> x
array([1, 2, 3, 4])
>>> wts
array([4, 3, 2, 1])
>>> numpy.average(x)
2.5
>>> numpy.average(x, weights = wts)
2.0
std
该函数用于计算标准差：
>>> import numpy
>>> numpy.std([1, 2, 3, 4])
1.118033988749895
var
该函数用于计算方差：
>>> import numpy
>>> numpy.var([1, 2, 3, 4])
1.25
排序相关
sort
该函数返回数组的排序副本：
sort(a, axis, kind, order)
参数含义如下：
- a：要排序的数组
- axis：沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序，axis = 0 按列排序，axis = 1 按行排序
- kind：默认为 quicksort（快速排序）
- order：如果数组包含字段，则是要排序的字段
>>> import numpy
>>> x = numpy.array([[6, 9, 2], [10, 6, 9], [5, 7, 3]])
>>> x
array([[ 6, 9, 2],
[10, 6, 9],
[ 5, 7, 3]])
>>> numpy.sort(x)
array([[ 2, 6, 9],
[ 6, 9, 10],
[ 3, 5, 7]])
>>> numpy.sort(x, 0)
array([[ 5, 6, 2],
[ 6, 7, 3],
[10, 9, 9]])
>>> numpy.sort(x, 1)
array([[ 2, 6, 9],
[ 6, 9, 10],
[ 3, 5, 7]])
argsort
该函数返回的是数组值从小到大的索引值：
>>> import numpy
>>> x = numpy.array([5, 1, 3, 4, 2])
>>> x
array([5, 1, 3, 4, 2])
>>> y = numpy.argsort(x)
>>> y
array([1, 4, 2, 3, 0])
>>> print(x[y])
[1 2 3 4 5]
lexsort
该函数用于对多个序列进行排序，每一列代表一个序列，排序时优先照顾靠后的列：
>>> import numpy
>>> x = ('b', 'd', 'a', 'c', 'a')
>>> x
('b', 'd', 'a', 'c', 'a')
>>> y = ('c', 'd', 'b', 'b', 'a')
>>> y
('c', 'd', 'b', 'b', 'a')
>>> index = numpy.lexsort((y, x))
>>> index
array([4, 2, 0, 3, 1])
>>> print([x[i] + "," + y[i] for i in index])
['a,a', 'a,b', 'b,c', 'c,b', 'd,d']
msort
该函数按数组第一个轴排序，返回排序后的数组副本：
>>> import numpy
>>> x = numpy.array([[4, 9, 2], [7, 3, 9], [1, 7, 4]])
>>> x
array([[4, 9, 2],
[7, 3, 9],
[1, 7, 4]])
>>> numpy.msort(x)
array([[1, 3, 2],
[4, 7, 4],
[7, 9, 9]])
sort_complex
该函数对复数按照先实部后虚部的顺序进行排序：
>>> import numpy
>>> x = numpy.array([5 + 6j, 2 - 1j, 5 + 6j, 1 + 5j])
>>> x
array([5.+6.j, 2.-1.j, 5.+6.j, 1.+5.j])
>>> numpy.msort(x)
array([1.+5.j, 2.-1.j, 5.+6.j, 5.+6.j])
partition(a, kth[, axis, kind, order])
该函数指定一个数，对数组进行分区：
>>> import numpy
>>> x = numpy.array([26, 3, 45, 86, 70, 95, 1, 50])
>>> x
array([26, 3, 45, 86, 70, 95, 1, 50])
>>> numpy.partition(x, 7)
array([ 1, 26, 45, 3, 50, 70, 86, 95])
>>> numpy.partition(x, (2, 7))
array([ 1, 3, 26, 45, 50, 70, 86, 95])
argpartition(a, kth[, axis, kind, order])
该函数可以通过关键字 kind 指定算法沿着指定轴对数组进行分区：
>>> import numpy
>>> x = numpy.array([46, 57, 23, 39, 1, 10, 0, 120])
>>> x[numpy.argpartition(x, 2)[2]]
10
>>> x[numpy.argpartition(x, -2)[-2]]
57
argmax
该函数沿给定轴返回最大元素的索引：
>>> import numpy
>>> x = numpy.array([[4, 9, 2], [7, 3, 9], [1, 7, 4]])
>>> x
array([[4, 9, 2],
[7, 3, 9],
[1, 7, 4]])
>>> numpy.argmax(x, 0)
array([1, 0, 1])
>>> numpy.argmax(x, 1)
array([1, 2, 1])
>>> numpy.argmax(x)
1
argmin
该函数沿给定轴返回最小元素的索引：
>>> import numpy
>>> x = numpy.array([[4, 9, 2], [7, 3, 9], [1, 7, 4]])
>>> x
array([[4, 9, 2],
[7, 3, 9],
[1, 7, 4]])
>>> numpy.argmin(x, 0)
array([2, 1, 0])
>>> numpy.argmin(x, 1)
array([2, 1, 0])
>>> numpy.argmin(x)
6
nonzero
该函数返回输入数组中非零元素的索引：
>>> import numpy
>>> x = numpy.array([[0, 1, 2], [-5, 0, 0], [0, 6, -3]])
>>> x
array([[ 0, 1, 2],
[-5, 0, 0],
[ 0, 6, -3]])
>>> numpy.nonzero(x)
(array([0, 0, 1, 2, 2]), array([1, 2, 0, 1, 2]))
where
该函数返回输入数组中满足给定条件的元素的索引：
>>> import numpy
>>> x = numpy.array([[0, 1, 2], [-5, 0, 0], [0, 6, -3]])
>>> x
array([[ 0, 1, 2],
[-5, 0, 0],
[ 0, 6, -3]])
>>> numpy.where(x > 0)
(array([0, 0, 2]), array([1, 2, 1]))
extract
该函数根据某个条件从数组中抽取元素，返回满条件的元素：
>>> import numpy
>>> x = numpy.arange(16).reshape(4, 4)
>>> x
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> condition = numpy.mod(x, 2) == 0
>>> condition
array([[ True, False, True, False],
[ True, False, True, False],
[ True, False, True, False],
[ True, False, True, False]])
>>> numpy.extract(condition, x)
array([ 0, 2, 4, 6, 8, 10, 12, 14])
矩阵相关
matlib.empty
该函数返回一个新的矩阵：
matlib.empty(shape, dtype, order)
参数含义如下：
- shape：定义新矩阵形状的整数或整数元组
- dtype：数据类型（可选）
- order：C（行序优先）或者F（列序优先）
>>> import numpy
>>> import numpy.matlib
>>> numpy.matlib.empty((4, 4))
matrix([[0.e+000, 5.e-324, 0.e+000, 5.e-324],
[0.e+000, 5.e-324, 0.e+000, 5.e-324],
[0.e+000, 5.e-324, 0.e+000, 5.e-324],
[0.e+000, 5.e-324, 0.e+000, 5.e-324]])
matlib.zeros
该函数创建一个以 0 填充的矩阵：
>>> import numpy
>>> import numpy.matlib
>>> numpy.matlib.zeros((4, 4))
matrix([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])
matlib.ones
该函数创建一个以 1 填充的矩阵：
>>> import numpy
>>> import numpy.matlib
>>> numpy.matlib.ones((4, 4))
matrix([[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]])
matlib.eye
该函数返回一个矩阵，对角线元素为 1，其他位置为零：
matlib.eye(n, M,k, dtype)
参数含义如下：
- n：返回矩阵的行数
- M：返回矩阵的列数，默认为 n
- k：对角线的索引
- dtype：数据类型
>>> import numpy
>>> import numpy.matlib
>>> numpy.matlib.eye(n = 4, M = 4, k = 0)
matrix([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
matlib.identity
该函数返回给定大小的单位矩阵：
>>> import numpy
>>> import numpy.matlib
>>> numpy.matlib.identity(4)
matrix([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
matlib.rand
该函数创建一个给定大小的矩阵，数据是随机填充的：
>>> import numpy
>>> import numpy.matlib
>>> numpy.matlib.rand(4, 4)
matrix([[0.67540295, 0.77384913, 0.65223043, 0.56212687],
[0.96566746, 0.22101781, 0.31232602, 0.30517149],
[0.59098654, 0.67376424, 0.68498415, 0.86746224],
[0.58831366, 0.60457474, 0.00707835, 0.88707821]])
线性代数相关
dot
对于两个一维的数组，该函数计算的是这两个数组对应下标元素的乘积和；
对于二维数组，该函数计算的是两个数组的矩阵乘积；
对于多维数组，该函数计算公式如下
参数含义如下：
- a：ndarray 数组
- b：ndarray 数组
- out：用来保存计算结果的 ndarray（可选）
>>> import numpy
>>> a = numpy.array([[1, 2], [3, 4]])
>>> b = numpy.array([[5, 6], [7, 8]])
>>> numpy.dot(a, b)
array([[19, 22],
[43, 50]])
vdot
该函数计算的是两个向量的点积。如果第一个参数是复数，那么它的共轭复数会用于计算。如果参数是多维数组，它会被展开。
>>> import numpy
>>> a = numpy.array([[1, 2], [3, 4]])
>>> b = numpy.array([[5, 6], [7, 8]])
>>> numpy.vdot(a, b)
70
inner
该函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积：
>>> import numpy
>>> a = numpy.array([1, 2, 3])
>>> b = numpy.array([4, 5, 6])
>>> numpy.inner(a, b)
32
matmul
该函数返回两个数组的矩阵乘积。虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。对于二维数组，它就是矩阵乘法：
>>> import numpy
>>> a = [[1, 2], [3, 4]]
>>> b = [[6, 7], [8, 9]]
>>> numpy.matmul(a, b)
array([[22, 25],
[50, 57]])
linalg.det
该函数计算输入矩阵的行列式：
>>> import numpy
>>> x = numpy.array([[1, 2], [3, 4]])
>>> numpy.linalg.det(x)
-2.0000000000000004
linalg.inv
该函数用于计算矩阵的乘法逆矩阵：
>>> import numpy
>>> x = numpy.array([[1, 2], [3, 4]])
>>> x
array([[1, 2],
[3, 4]])
>>> numpy.linalg.inv(x)
array([[-2. , 1. ],
[ 1.5, -0.5]])
