numpy

Array

属性

• a.dtype 数组的数据类型
• a.flags 返回内存布局的信息
• a.itemsize 每个元素的字节长度
• a.ndim 数组的维度数
• a.size 数组的元素数
• a.shape 各维度的长度组成的元组
• a.strides 各维度前进一步所需跨越的字节数组成的元组

• a.data 返回指向数据块的 buffer 对象
• a.flat 返回数组的 flatitier 对象
• a.base 若使用的内存来自别的对象，则返回原对象，否则返回 None

• a.__array_interface__ 返回 (数据块地址, 是否只读)

生成数组

• np.array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, like=None)
  • dtype 数据类型
    • 'u1' 等效于 'uint8' 和 np.uint8
    • 'i' 'i4' 等效于 'int32' 和 np.int32
    • 'f' 'f4' 等效于 'float32' 和 np.float32
  • copy 若为 True 则深拷贝 object，否则视情况而决定是否拷贝
  • order 内存布局，若 object 非数组则默认为 C 顺序
  • subok 若为 True 则 array 的子类的类别会被保留，否则会强制转换
  • ndmin 最小的维度数，1 会被用来填充空白

• np.empty(shape, dtype=float, order='C', *, like=None) 返回未初始化的数组
• np.zeros(shape, dtype=float, order='C', *, like=None) 返回初始化为 0 的数组
• np.ones(shape, dtype=float, order='C', *, like=None) 返回初始化为 1 的数组
• np.full(shape, fill_value, dtype=None, order='C', *, like=None) 返回初始化为指定值的数组
  • dtype 默认为 np.array(fill_value).dtype

• np.arange([start,] stop[, step,], dtype=None, *, like=None)
  • start, stop 和 step 支持使用浮点数
  • dtype 若为 None 则从其他参数中推断
• np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
  • num 生成的样本数，默认为 50
  • endpoint 若为 True 则会包含 stop
  • retstep 若为 True 则返回的是 (样本, 步长)
  • dtype 若为 None 则从其他参数中推断，但绝不会是整数

• np.meshgrid(*xi, copy=True, sparse=False, indexing='xy') 生成网格点坐标矩阵，返回的坐标矩阵数等于输入的坐标向量数
  • copy 若为 False，则只会返回原有数组的视图
  • indexing 坐标矩阵的索引方式，假设坐标向量的长度依次为 M, N, P
    • 'xy' 网格点先沿横轴展开，坐标矩阵的形状为 (M, N) 或 (M, N, P)
    • 'ij' 网格点先沿纵轴展开，坐标矩阵的形状为 (N, M) 或 (N, M, P)

转换类型

• np.asarray(a, dtype=None, order=None, *, like=None) 将输入数据转换为数组
  • 已存在的数组不会被拷贝
  • 若设置了 dtype，则只有当数据类型不匹配时会拷贝
• np.asfarray(a, dtype=<class 'numpy.float64'>) 强制转换为数据类型为 float64 的数组
  • 只有当数据类型不匹配时会拷贝

• a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True) 返回数组的副本，已被转换为指定数据类型

合并拆分

• np.concatenate((a1, a2, ...), axis=0, out=None, dtype=None, casting="same_kind") 沿指定维度连接多个数组，返回副本
  • a1, a2, ... 除了 axis 指定的维度，其他维度必须相同
  • axis 用于连接的维度的索引，若为 None 则会先展平数组
  • out 结果输出的数组，形状需与输出相同，此时返回的也是该数组

• np.stack(arrays, axis=0, out=None, *, dtype=None, casting='same_kind') 沿新的维度连接多个数组，返回副本
  • arrays 所有数组应有相同的形状
  • axis 新的维度的索引
• np.vstack(tup, *, dtype=None, casting='same_kind') 沿第一个维度连接多个数组，返回副本，一维数组的形状会转换为 (1, N)
  • tup 除了第一个维度，其他维度必须相同，若为一维数组则必须长度相同
• np.hstack(tup, *, dtype=None, casting='same_kind') 沿第二个维度连接多个数组，返回副本，一维数组会直接拼接
  • tup 除了第二个维度，其他维度必须相同

• np.split(ary, indices_or_sections, axis=0) 沿指定维度切割数组，返回视图
  • indices_or_sections 整数或一维数组
    • 若为整数 N，则会平分为 N 份，无法平分则报错
    • 若为一维数组，例如 (M, N, P)，则会取索引 [0: M], [M: N], [N: P], [P, len(ary.shape[axis])]，若不存在则会返回空数组
• np.vsplit(ary, indices_or_sections) 沿第一个维度切割数组，返回视图
• np.hsplit(ary, indices_or_sections) 沿第二个维度切割数组，返回视图，一维数组会沿第一个维度切割

改变形状

• np.reshape(a, newshape, order='C') 改变数组形状，返回视图，仅在必要时返回副本
  • newshape 若为整数，则会转换为一维数组；若为数组，其中一个维度可以使用 -1，其具体值由其他值推断出
• a.reshape(shape, order='C') 改变数组形状，返回视图，仅在必要时返回副本
  • shape 若为数组，其元素可直接分开传入

• a.flatten(order='C') 展平数组，返回副本
• a/np.ravel(a, order='C') 展平数组，返回视图，仅在必要时返回副本

• a/np.squeeze(axis=None) 除去数组中长度为一的维度
  • axis None 或整数或整数元组，若指定的维度长度不为一则报错

• np.expand_dims(a, axis) 扩展维度，返回视图
  • axis 整数或整数元组，指定的索引会插入新的维度
• 此外，还可以使用 np.newaxis (None) 来扩展维度：

  >>> a = np.arange(6).reshape(2, 3)
  >>> a[np.newaxis, :, np.newaxis].shape
  (1, 2, 1, 3)
  >>> a[np.newaxis, :, :, np.newaxis].shape
  (1, 2, 3, 1)
  

转置翻转

• np.transpose(a, axes=None) 转置数组，返回视图
  • axes 必须为 [0,1,...,N-1] 的一个排列，默认为 a.shape[::-1]
• np.flip(m, axis=None) 沿指定轴翻转数组，返回视图
  • axis 若为 None，则沿所有轴翻转；若为整数或整数元组，则沿指定轴翻转

数值计算

• a/np.all(axis=None, out=None, keepdims=False, *, where=True) 若所有元素的计算结果均为 True，则返回 True
• a/np.any(axis=None, out=None, keepdims=False, *, where=True) 若任意元素的计算结果为 True，则返回 True
  • axis None 或整数或整数元组
    • 若为 None，则会沿所有维度移动做逻辑运算，返回一个布尔值
    • 若指定维度，则会保持其他维度不变，沿指定维度移动做逻辑运算，运算结果保存在其他维度指定的位置，返回一个维度数减少的数组
  • keepdims 若为 True，则被消去的维度会保留，其长度变为一
  • where 布尔数组，只有为 True 的元素参与逻辑运算

• a/np.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True) 返回沿指定轴的最大值
• a/np.min(axis=None, out=None, keepdims=False, initial=<no value>, where=True) 返回沿指定轴的最小值
  • axis None 或整数或整数元组
  • initial 输出值的最小/大值

• a/np.sum(axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True) 返回沿指定轴的累加值
• a/np.prod(axis=None, dtype=None, out=None, keepdims=False, initial=1, where=True) 返回沿指定轴的累乘值
  • dtype 默认使用原数组的数据类型，除非原数组的数据类型是整数类型，且精度不足平台默认整型精度，此时会使用平台默认整型
  • initial 计算累加/乘值的起始值
• a/np.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True) 返回沿指定轴的平均值
  • dtype 默认情况下，整数数组的输出类型为 float64，浮点数数组的输出类型保持不变

• a/np.cumsum(axis=None, dtype=None, out=None) 返回沿指定轴的累积和
• a/np.cumprod(axis=None, dtype=None, out=None) 返回沿指定轴的累积乘积
  • axis None 或整数
    • 若为 None，则会先展平数组，返回一个一维数组
    • 若指定维度，则会保持其他维度不变，沿指定维度移动做累加/累积，运算结果保存在原来位置，返回一个形状不变的数组

• a/np.dot(b, out=None) 返回 a 与 b 的点积，与 @ 相似
  • 若 a 与 b 均为一维数组，则作内积
  • 若 a 与 b 均为二维数组，则作矩阵乘法
  • 若 a 或 b 为标量，则作简单相乘
  • 若 a 为 N 维数组，b 为一维数组，则沿最后一个维度作点积，返回的数组的维度数减一
  • 若 a 为 N 维数组，b 为 M(M>=2) 维数组，则沿 a 的最后一个维度和 b 的倒数第二个维度作点积，返回的数组的维度数减二，如 dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])

其他方法

• np.copy(a, order='K', subok=False) 拷贝数组
• np.copyto(dst, src, casting='same_kind', where=True) 拷贝 src 到 dst，可用于选择性复制
• a.copy(order='C') 返回数组的副本，更为推荐使用
• a.view([dtype][, type]) 返回数组的视图

• a.tobytes(order='C') 将数组转换为字节序列，返回副本
• a.tolist() 将数组转换为列表，返回副本，若数组零维则返回一个标量

• a.fill(value) 用一个标量填充数组

Random

生成随机数

• np.random.rand(d0, d1, ..., dn) 生成均匀分布的随机数数组，取值范围为 [0, 1)，若无参数则返回单个浮点数
• np.random.random(size=None) 生成取值范围为 [0, 1) 的随机数
• np.random.random_sample(size=None) 生成取值范围为 [0, 1) 的随机数
• np.random.uniform(low=0.0, high=1.0, size=None) 生成均匀分布的随机数
  • size 若为 None，则返回一个数；若为整数或元组，则返回一个数组

• np.random.randn(d0, d1, ..., dn) 生成标准正态分布的随机数数组，若无参数则返回单个浮点数
• np.normal(loc=0.0, scale=1.0, size=None) 生成标准分布的随机数

• np.randint(low, high=None, size=None, dtype=int) 返回指定范围内的随机整数
  • high 若为 None，则取值范围为 [0, low)，否则为 [low, high)

随机选择

• np.random.choice(a, size=None, replace=True, p=None) 随机选择一维数组的元素
  • a 若为一维数组，则从中选择元素；若为整数，则视为使用 np.arange(a)
  • size 若为 None，则只返回一个元素，否则返回指定形状的数组
  • replace 若为 True，则同一元素可被多次选择
  • p 一维数组，表示每个元素的概率，必须和为 1

随机排序

• np.random.shuffle(x) 沿第一个轴打乱序列顺序，原序列变化，返回 None
• np.random.permutation(x) 沿第一个轴随机排列序列，原序列不变，返回副本
  • x 若为数组，则会进行拷贝；若为整数，则视为使用 np.arange(a)

Broadcasting

• 当对两个数组进行逐元素操作时，如 a * b，会从右到左比较它们的形状
• 若两个维度长度相同，或其中一个为 1，则称这两个维度兼容
• 若两个数组的维度数不同，则会在左边补全维度，长度全为 1
• 长度为 1 的维度会被拉伸复制，以匹配另一个数组对应位置的维度