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', float | 8 字节 | 标准双精度浮点数(科学计算默认标准精度) |
np.complex128 | 'complex128', complex | 16 字节 | 复数(实部和虚部各为 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. 形状变换、重塑与展平
| 方法 / 操作 | 示例 | 机制与说明 |
|---|---|---|
reshape | arr.reshape(3, -1) | 改变形状(-1 表示根据总元素数自动推断维度长度),返回视图(若内存连续) |
ravel | arr.ravel() | 将多维数组展平为 1D,优先返回视图(无额外内存开销) |
flatten | arr.flatten() | 将多维数组展平为 1D,始终返回独立副本 |
T / transpose | arr.T / np.transpose(arr) | 矩阵转置(交换各轴),一维数组转置无变化 |
expand_dims | np.expand_dims(a, axis=0) | 在指定位置插入新轴(等价于 a[np.newaxis, :]) |
squeeze | np.squeeze(arr) | 移除所有长度为 1 的单维度条目 |
resize | np.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;
- 隐式拉伸:长度为 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 常用聚合统计函数
| 函数 / 方法 | 示例 | 核心语义 |
|---|---|---|
sum | a.sum(axis=0) | 求和(axis=0 压缩行,求每一列的和) |
mean | a.mean(axis=1) | 算术平均值(axis=1 压缩列,求每一行的均值) |
std / var | a.std(ddof=0) | 总体标准差 / 方差(样本标准差需显式指定 ddof=1) |
min / max | a.min(), a.max() | 极值计算 |
argmin / argmax | a.argmax(axis=0) | 极值出现的索引位置 |
cumsum | a.cumsum(axis=1) | 累加和(返回同形状前缀和矩阵) |
np.median | np.median(a, axis=0) | 中位数(只能用函数形式调用) |
np.percentile | np.percentile(a, 75) | 分位数(如第 75 百分位数) |
np.corrcoef | np.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 个样本的索引位置