Cheat Sheet速查表
跳转到主要内容

NumPy 常用操作与多维数组计算速查表

NumPy(Numerical Python)是 Python 数据科学与科学计算生态的核心基石库。其核心对象为同质多维数组(ndarray),由连续内存块与描述数据类型(dtype)、形状(shape)和内存步长(strides)的元数据构成,支持极高吞吐的向量化与广播运算。

🔗 关联矩阵速查:Pandas 速查表 · Scikit-Learn 速查表 · 数据分析方法速查表 · Python 速查表 · 微积分核心定理速查表


1. 数组维度(Axes)与内存模型速览

理解 NumPy 的关键在于**轴(Axis)**的方向与降维逻辑:

一维数组 (ndim=1, shape=(3,))
[ 1,  2,  3 ]  ──> axis 0

二维矩阵 (ndim=2, shape=(2, 3))
         axis 1 (跨列方向 ──>)
         col 0   col 1   col 2
axis 0 ┌───────┬───────┬───────┐
(跨行) │  1.5  │  2.0  │  3.0  │ row 0
  │    ├───────┼───────┼───────┤
  ▼    │  4.0  │  5.0  │  6.0  │ row 1
       └───────┴───────┴───────┘
* 注:沿 axis=0 聚合(如 a.mean(axis=0))会沿行方向压缩,返回各列的统计值 (shape=(3,));
      沿 axis=1 聚合会沿列方向压缩,返回各行的统计值 (shape=(2,))。

三维张量 (ndim=3, shape=(2, 2, 3))
axis 0: 深度/通道/批次 (Batch/Depth)
axis 1: 行方向 (Row)
axis 2: 列方向 (Column)

2. 导入与磁盘输入输出(I/O)

import numpy as np

# 1. 高效二进制存储 (推荐:保持类型与形状,速度最快)
np.save('arr.npy', arr)                  # 保存单数组为 .npy
arr = np.load('arr.npy')                # 读取 .npy 文件
np.savez('data.npz', a=arr1, b=arr2)    # 打包多数组为未压缩 .npz
np.savez_compressed('data_c.npz', a=arr1) # 打包为压缩 .npz
data = np.load('data.npz')              # 延迟加载,按键访问:data['a']

# 2. 文本文件 I/O (适用于 CSV 或 TSV 交互)
arr = np.loadtxt('file.txt', delimiter=',')            # 纯数值文本快速加载
arr = np.genfromtxt('file.csv', delimiter=',', filling_values=0.0) # 支持缺失值与非数值
np.savetxt('out.csv', arr, delimiter=',', fmt='%.4f') # 格式化导出为 CSV

3. 数组创建与占位符生成

创建方式语法示例说明
序列转换np.array([1, 2, 3])由 Python 列表或元组创建 1D 数组
多维构建np.array([(1, 2, 3), (4, 5, 6)], dtype=float)创建 2D 浮点矩阵 (2x3)
全 0 填充np.zeros((3, 4))创建 3 行 4 列全 0 浮点数组
全 1 填充np.ones((2, 3, 4), dtype=np.int32)创建 3D 全 1 整型数组
常数填充np.full((2, 2), 7)创建 2x2 全为 7 的数组
单位矩阵np.eye(4) / np.identity(4)创建 4 阶单位方阵(对角线为 1)
未初始化np.empty((3, 2))仅分配内存,不初始化内容(运行极快,值为内存残留)
步长区间np.arange(10, 25, 5)生成 [10, 25),步长为 5:array([10, 15, 20])
等分样本np.linspace(0, 2, 9)在 [0, 2] 区间生成 9 个等间隔数值(包含端点 2)
对数等分np.logspace(0, 3, 4)生成 $10^0$ 到 $10^3$ 的 4 个对数间距值:[1, 10, 100, 1000]

现代随机数生成(推荐 default_rng)

# NumPy 1.17+ 官方推荐基于 Generator 的高质量随机数接口
rng = np.random.default_rng(seed=42)

r_float = rng.random((2, 3))            # [0.0, 1.0) 均匀分布浮点数
r_int   = rng.integers(1, 10, size=(3, 3)) # [1, 10) 离散随机整数
r_norm  = rng.standard_normal((3, 3))    # 标准正态分布 N(0, 1)
rng.shuffle(arr)                         # 原地打乱数组沿第 0 轴的顺序

4. 数组属性与现代数据类型(Dtype)

4.1 核心状态属性

arr = np.array([[1.5, 2.0, 3.0], [4.0, 5.0, 6.0]])

arr.shape        # (2, 3) 形状元组
arr.ndim         # 2 维度数量 (len(arr.shape))
arr.size         # 6 元素总数
arr.dtype        # dtype('float64') 数据类型
arr.itemsize     # 8 单个元素所占字节数
arr.nbytes       # 48 数组总字节数 (arr.size * arr.itemsize)
arr.astype(int)  # 显式转换数据类型并返回新数组副本
np.info(arr)     # 查看数组对象综合信息与内存分布

4.2 现代数据类型规范对照

⚠️ 规范提示:NumPy 2.x 与 1.24+ 已彻底移除 np.bool、np.object、np.complex 等直接类型别名,请使用标准原生类型或下划线后缀类型。

规范类型常见别名 / 构造字节大小典型应用
np.int32 / np.int64'int32', np.int_4 / 8 字节有符号整数(索引、ID、计数值)
np.uint8'uint8'1 字节无符号 8 位整数(图像像素值 0~255)
np.float32'float32'4 字节单精度浮点数(深度学习模型参数常用,省显存)
np.float64'float64', float8 字节标准双精度浮点数(科学计算默认标准精度)
np.complex128'complex128', complex16 字节复数(实部和虚部各为 64 位浮点数)
np.bool_bool, 'bool'1 字节布尔值(True / False,掩码条件过滤)
np.bytes_'S', bytes定长定长 ASCII 字节串
np.str_'U', str定长定长 Unicode 字符串

5. 索引、切片与高级筛选

5.1 基本切片与索引(返回视图 View,共享内存)

切片格式为 [start:stop:step],若修改切片内容,原数组同步被修改:

a = np.array([1, 2, 3, 4, 5])
b = np.array([[1.5, 2, 3], [4, 5, 6]])
c = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

a[2]             # 3 (取标量)
b[1, 2]          # 6.0 (第 1 行第 2 列,推荐语法,优于 b[1][2])
b[0:2, 1]        # array([2., 5.]) (取第 0~1 行的第 1 列)
b[:1]            # array([[1.5, 2., 3.]]) (取第 0 行,保持 2D 形状)
c[1, ...]        # 等价于 c[1, :, :] (省略号 Ellipsis 自动展开未指定轴)
a[::-1]          # array([5, 4, 3, 2, 1]) (逆序反转一维数组)

5.2 条件布尔索引(返回副本 Copy)

mask = a > 2                 # array([False, False,  True,  True,  True])
filtered = a[a > 2]          # array([3, 4, 5])

# 复合条件必须使用位运算符 & (且)、| (或)、~ (非),每个条件必须加圆括号:
combined = a[(a > 1) & (a < 5)]  # array([2, 3, 4])
a[a < 3] = 0                 # 原地条件赋值:小于 3 的元素全部置 0

5.3 花式索引 Fancy Indexing(返回副本 Copy)

使用整数数组或列表进行非连续取数:

matrix = np.arange(12).reshape(3, 4)
# [[ 0,  1,  2,  3],
#  [ 4,  5,  6,  7],
#  [ 8,  9, 10, 11]]

# 1. 离散坐标对提取 (对应坐标 (0,1) 与 (2,3))
matrix[[0, 2], [1, 3]]       # array([1, 11])

# 2. 矩形子网格提取 (提取第 0、2 行,并按第 3、1 列排列)
matrix[[0, 2]][:, [3, 1]]    # array([[ 3,  1], [11,  9]])
# 或使用 np.ix_ 构造网格:
matrix[np.ix_([0, 2], [3, 1])]

5.4 内存核心法则:视图(View)vs 副本(Copy)

操作类型典型语法内存机制修改结果
基础切片sub = arr[0:2, :]视图 (View)修改 sub,原数组 arr 会随之改变
花式索引sub = arr[[0, 1]]副本 (Copy)独立内存,修改 sub 对原数组 arr 无影响
布尔索引sub = arr[arr > 0]副本 (Copy)独立内存,对原数组无影响
显式克隆sub = arr.copy()深拷贝 (Copy)开辟全新独立内存
检查是否视图sub.base is not None内部属性若为 True 则为视图,其 base 指向母数组

6. 形状变换、重塑与展平

方法 / 操作示例机制与说明
reshapearr.reshape(3, -1)改变形状(-1 表示根据总元素数自动推断维度长度),返回视图(若内存连续)
ravelarr.ravel()将多维数组展平为 1D,优先返回视图(无额外内存开销)
flattenarr.flatten()将多维数组展平为 1D,始终返回独立副本
T / transposearr.T / np.transpose(arr)矩阵转置(交换各轴),一维数组转置无变化
expand_dimsnp.expand_dims(a, axis=0)在指定位置插入新轴(等价于 a[np.newaxis, :])
squeezenp.squeeze(arr)移除所有长度为 1 的单维度条目
resizenp.resize(arr, (2, 6))函数式重塑并返回新数组(元素不足时自动循环填充)

7. 数组拼接、堆叠与分割

7.1 数组合并

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 1. 沿已有轴拼接 (要求其他维度长度完全一致)
np.concatenate((A, B), axis=0)      # 垂直向下拼接 (4x2)
np.concatenate((A, B), axis=1)      # 水平向右拼接 (2x4)

# 2. 堆叠操作
np.vstack((A, B))                   # 垂直纵向以行堆叠 (等同于 np.r_[A, B])
np.hstack((A, B))                   # 水平横向以列堆叠 (等同于 np.c_[A, B])
np.column_stack((a, b))             # 将 1D 数组作为列向量堆叠为 2D 矩阵 (3x2)
np.stack((A, B), axis=0)            # 沿着全新维度堆叠 (产生 2x2x2 的 3D 张量)

7.2 数组分割

⚠️ 方向记忆诀窍:vsplit 沿垂直行方向切切断(横刀切出上下行);hsplit 沿水平列方向切切断(纵刀切出左右列)。

matrix = np.arange(16).reshape(4, 4)

# 水平拆分 (Horizontal Split:按列拆分为左右两半)
left, right = np.hsplit(matrix, 2)  # 各得到 (4, 2) 形状

# 垂直拆分 (Vertical Split:按行拆分为上下两半)
top, bottom = np.vsplit(matrix, 2)  # 各得到 (2, 4) 形状

# 通用切分
parts = np.split(matrix, [1, 3], axis=0) # 按行索引 1 和 3 切分为 3 份

8. 通用算术、线性代数与广播机制(Broadcasting)

8.1 逐元素数学函数

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 逐元素四则运算 (可直接使用重载运算符或对应 ufunc)
add_res = a + b                     # 等价于 np.add(a, b)
sub_res = a - b                     # 等价于 np.subtract(a, b)
mul_res = a * b                     # 等价于 np.multiply(a, b) (逐元素点乘,非矩阵乘法)
div_res = a / b                     # 等价于 np.divide(a, b)
pow_res = a ** 2                    # 等价于 np.power(a, 2)

# 数学函数
np.exp(a)                           # 自然指数 e^x
np.log(a)                           # 自然对数 ln(x) (np.log2, np.log10)
np.sqrt(a)                          # 算术平方根
np.sin(a), np.cos(a)                # 三角函数 (弧度制)
np.abs(a)                           # 绝对值
np.clip(a, a_min=1, a_max=2)        # 数值硬截断至 [1, 2] 区间

8.2 线性代数与矩阵乘法

A = np.array([[1, 2], [3, 4]])
B = np.array([[2, 0], [1, 2]])

# 矩阵乘法 (强烈推荐使用 @ 运算符,语义最清晰)
C = A @ B                           # 推荐标准矩阵乘法语法 (NumPy 1.10+ / Python 3.5+)
C_matmul = np.matmul(A, B)          # 官方标准矩阵相乘函数
C_dot = np.dot(A, B)                # 2D 下等价于矩阵乘法;高维下为特定张量缩并

# 线性代数子模块 (np.linalg)
inv_A = np.linalg.inv(A)            # 矩阵求逆
eig_val, eig_vec = np.linalg.eig(A) # 特征值与特征向量
det_A = np.linalg.det(A)            # 行列式
norm_A = np.linalg.norm(A)          # 矩阵范数 (默认 Frobenius 范数)

8.3 广播机制核心法则(Broadcasting Rules)

当对两个形状不同的数组执行逐元素运算时,NumPy 会自动应用广播规则:

  1. 维度向右对齐:比较两数组的形状元组,从尾部维度(即最右侧)向前逐一对比;
  2. 维度长度兼容条件:在每一个维度上,两者的长度必须相等,或者其中一个长度为 1;
  3. 隐式拉伸:长度为 1 的维度在计算中会被虚拟拉伸复制以匹配对方长度,且不消耗额外实体内存。
# 示例:(4, 3) 矩阵与 (3,) 向量相加
# 矩阵 A shape: (4, 3)
# 向量 b shape:    (3,) ──> 右对齐自动补足为 (1, 3) ──> 广播为 (4, 3)
A = np.ones((4, 3))
b = np.array([10, 20, 30])
result = A + b                      # 每一行分别加上 [10, 20, 30],形状仍为 (4, 3)

9. 统计聚合与比较函数

⚠️ 调用方式注意:sum()、mean()、min()、max()、std() 既是顶层函数也是数组对象方法(如 a.sum() 或 np.sum(a));但 median()、percentile()、corrcoef() 只能作为顶层函数调用(如 np.median(a),若调用 a.median() 会报 AttributeError)。

9.1 常用聚合统计函数

函数 / 方法示例核心语义
suma.sum(axis=0)求和(axis=0 压缩行,求每一列的和)
meana.mean(axis=1)算术平均值(axis=1 压缩列,求每一行的均值)
std / vara.std(ddof=0)总体标准差 / 方差(样本标准差需显式指定 ddof=1)
min / maxa.min(), a.max()极值计算
argmin / argmaxa.argmax(axis=0)极值出现的索引位置
cumsuma.cumsum(axis=1)累加和(返回同形状前缀和矩阵)
np.mediannp.median(a, axis=0)中位数(只能用函数形式调用)
np.percentilenp.percentile(a, 75)分位数(如第 75 百分位数)
np.corrcoefnp.corrcoef(matrix)相关系数矩阵(只能用函数形式调用,行代表变量)

9.2 比较与条件选取函数

a = np.array([1, 2, 3])
b = np.array([1, 2, 4])

# 1. 数组级一致性判断
a == b                              # array([ True,  True, False]) (逐元素布尔矩阵)
np.array_equal(a, b)                # False (全数组完全相等才为 True)
np.allclose(a, b, atol=1e-5)        # 允许浮点微小容差的近乎相等检查

# 2. 全量与存在性测试
np.all(a > 0)                       # True (所有元素均满足条件)
np.any(a > 2)                       # True (至少一个元素满足条件)

# 3. 三元条件选取 (类似 SQL CASE WHEN 或 Excel IF)
# np.where(condition, x, y): 满足填 x,否则填 y
cond_result = np.where(a > 1, 100, -1) # array([-1, 100, 100])

10. 原地排序与间接排序

arr = np.array([3, 1, 2])

# 1. 原地就地排序 (直接修改自身,不返回新数组)
arr.sort()                          # arr 变为 [1, 2, 3]

# 2. 沿指定轴排序
matrix = np.array([[3, 1], [2, 4]])
matrix.sort(axis=0)                 # 沿垂直行方向(对每一列排序)

# 3. 间接排序 argsort (返回排好序的元素索引,数据科学高频实用技巧)
scores = np.array([88, 95, 70, 92])
sorted_indices = np.argsort(scores) # array([2, 0, 3, 1]) (升序索引)
top2_indices = np.argsort(scores)[-2:] # 取最高分 2 个样本的索引位置