阅读范围、用时与原有实验记录
实验记录怎么读
本页原有耗时、内存、报错和环境值保留为原文记录;本轮内容审校未逐项复跑这些实验。版本、硬件、数据和测量方法都会影响结果,示例中的倍数也不是保证。需要复现时先核对依赖版本,再在同一输入下比较。
⏱ 42 分钟 | ⭐ 同一件事,纯 Python 68 毫秒、NumPy 3.5 毫秒 —— 差的是一个量级,而差距的来源不是「C 比 Python 快」
01 / 完整解释
先比较同一件任务。
🎯 一句话
同样乘一遍,逐个处理 Python 对象会多做什么工作?
循环写法让解释器逐次取值、相乘、保存。把一组同类型的数交给 NumPy,可以为整批数据选择一套运算方式,在底层完成乘法。这里先把结果算对,再比较成本。
⚠️ 先消歧:这一套教程里的「向量化」指把 Python 循环改写成整块数组运算。 站内别处出现的「向量化」(
智能体工程教程/11、大模型全景导论/08等 10 处) 说的是把文本变成 embedding 向量,是另一回事。
📏 一、先看差距有多大
先手算三笔销售额
三笔订单的数量是 [2, 4, 3] 件,对应单价是 [5, 2, 6] 元/件。每笔销售额等于该笔的数量乘单价,结果保留原订单顺序。可以先遮住结果一列,自己算出三个值。
| 订单 | 数量 × 单价 | 销售额(元) |
|---|---|---|
| 第 1 笔 | 2 × 5 | 10 |
| 第 2 笔 | 4 × 2 | 8 |
| 第 3 笔 | 3 × 6 | 18 |
循环中的 i 是从 0 数起的位置。每轮取同一位置的数量和单价,把结果追加到列表。数组写法先把两列数据各转成一个 NumPy 数组(ndarray),再用 q * p 一次交给 NumPy 处理。两个输入的形状都是 (3,),也就是各有三个元素。
import numpy as np
quantity = [2, 4, 3]
unit_price = [5, 2, 6]
loop_result = []
for i in range(len(quantity)):
loop_result.append(quantity[i] * unit_price[i])
q = np.array(quantity, dtype=np.int64)
p = np.array(unit_price, dtype=np.int64)
array_result = q * p
print(loop_result)
print(array_result.tolist())
assert loop_result == array_result.tolist() == [10, 8, 18]两行都输出 [10, 8, 18]。tolist() 把结果转成普通列表,方便逐项对照。dtype=np.int64 指定每项用 64 位有符号整数存储;这个例子的数都在它的范围内。改用别的数据时,还要核对形状和结果的取值范围,详见第 02 章和第 08 章。
自查:若第二笔单价从 2 变成 3,哪笔结果会变?
第二笔变成 4 × 3 = 12,结果是 [10, 12, 18]。循环中只有 i=1 的乘法换了一个输入;数组运算同样按位置相乘。
再比较百万项的记录
下面沿用逐项相乘的规则,把输入换成两个各有 100 万项的浮点数列,比较三种写法。计时代码在准备阶段建好列表和数组,表里的耗时只比较乘法过程,包含各自创建结果的开销。
import numpy as np
import timeit
N = 1_000_000
setup = """
import numpy as np
N = 1_000_000
rng = np.random.default_rng(0)
a = rng.random(N)
b = rng.random(N)
la = a.tolist()
lb = b.tolist()
"""
cases = [
("列表推导 [x*y for x,y in zip(la,lb)]", "[x*y for x,y in zip(la,lb)]"),
("for + append", "r = []\nfor i in range(N):\n r.append(la[i]*lb[i])"),
("numpy a * b", "a * b"),
]
for name, stmt in cases:
t = timeit.repeat(stmt, setup=setup, repeat=15, number=1)
t = sorted(t)
print(f"{name:38s} min {t[0]*1e3:8.2f} ms median {t[7]*1e3:8.2f} ms max {t[-1]*1e3:8.2f} ms")
实跑输出:
对照
列表推导 [x*y for x,y in zip(la,lb)] min 68.17 ms median 81.21 ms max 104.56 ms
for + append min 81.23 ms median 87.83 ms max 97.64 ms
numpy a * b min 3.51 ms median 3.97 ms max 5.33 ms
这组记录里,两行最短耗时之比约为 68.17 ÷ 3.51 ≈ 19.4。 分子是列表推导,分母是数组运算。
同一脚本在同一台机器上四次运行,记录的比值为 19x / 29x / 35x / 37x。其中 NumPy 的最短耗时由 3.51 ms 变为 2.17 ms,列表推导则由约 68 ms 变为约 79 ms。
⭐ 这些比值只描述这组测量。换成刚才的三笔订单,或把列表转数组的时间也计入,结论可能不同。要优化自己的代码时,先核对两边结果,再按真实输入和相同计时口径比较。
📌 本章不讲怎么测。 「为什么取 min 不取 mean」「怎么预热」 「
perf_counter和time.time差在哪」「cProfile怎么读」 这些是 Python 工程题,不是 NumPy 题,归《Python》板块的性能剖析章。 上面那六行timeit.repeat是本章唯一一处计时代码,之后不再出现。
🧩 二、慢在哪:解释器每转一圈要做的事
for i in range(N): r.append(la[i]*lb[i]) 逐次读取两个列表中的 Python 浮点对象、相乘并保存。下表用 CPython 的对象模型拆开这些工作,具体指令和对象管理会随解释器版本与优化路径变化。
| 步骤 | 做了什么 | 每圈都要重做吗 |
|---|---|---|
| ① 字节码分派 | 解释器主循环取下一条字节码,跳进对应的处理分支 | ✅ 每圈 |
| ② 下标取值 | 按 la[i] 定位列表中存放的对象引用。 |
✅ 每圈 |
| ③ 解引用 | 顺着指针跳到堆上那个 PyObject,读它的类型标签 |
✅ 每圈 |
| ④ 类型判断 | 「左边是 float、右边是 float,那该调哪个乘法」——⭐ 每圈重问一遍 | ✅ 每圈 |
| ⑤ 拆箱 | 从 PyObject 里把真正的 8 字节 double 掏出来 |
✅ 每圈 |
| ⑥ 真正的乘法 | 把取到的两个浮点数相乘。 | ✅ 每圈 |
| ⑦ 装箱 | 结果要包成一个新的 PyObject,堆上分配、写类型标签、引用计数置 1 |
✅ 每圈 |
| ⑧ 引用计数 | 解释器需要管理结果对象和列表持有的引用。 | ✅ 每圈 |
⭐ 第 ⑥ 步产生所需数值。其他步骤负责驱动循环、读写对象和保存结果。 上面的计时只测了整段计算,无法从耗时表拆出单步占比。
💾 装箱的代价能直接量出来
import sys
import numpy as np
N = 1_000_000
lst = list(range(N))
arr = np.arange(N, dtype=np.int64)
print("一个 Python int 对象自己占", sys.getsizeof(lst[0]), "字节")
print("list 的指针表 ", sys.getsizeof(lst) / 1e6, "MB")
print("list 连同 100 万个 int ", (sys.getsizeof(lst) + sum(sys.getsizeof(x) for x in lst)) / 1e6, "MB")
print("ndarray int64 ", arr.nbytes / 1e6, "MB")
实跑输出:
对照
一个 Python int 对象自己占 28 字节
list 的指针表 8.000056 MB
list 连同 100 万个 int 36.000056 MB
ndarray int64 8.0 MB
在这次测量里,sys.getsizeof(lst[0]) 返回 28 字节。Python 整数对象大小随数值和解释器而变。按脚本的口径,把这个列表的引用表和每项的对象大小相加约为 36 MB。对照数组采用 int64,元素缓冲区为 1,000,000 × 8 = 8,000,000 字节。nbytes 只统计元素数据,数组对象本身还有元数据。
列表读出引用后还要找到对应的对象。这次 arange 创建的数值数组把元素连续存放,有利于顺序读取。
(这一层往下就是 CPU cache 的事了,AI 基础设施 02 章
在 GPU 的尺度上讲过同一个道理。)
02 / 完整解释
数组操作也有适用边界。
🚦 三、反例:同样是 NumPy,慢 8 倍
两边都对 ndarray 写 * 2,但一种数组直接存 64 位整数,另一种存 Python 对象的引用。改变数据类型(data type,dtype)会改变实际执行乘法的方式。
import numpy as np
import timeit
setup = """
import numpy as np
N = 1_000_000
a_int = np.arange(N, dtype=np.int64)
a_obj = np.arange(N, dtype=object)
"""
for name, stmt in [("dtype=int64 ", "a_int * 2"), ("dtype=object", "a_obj * 2")]:
t = min(timeit.repeat(stmt, setup=setup, repeat=7, number=1))
print(f"{name} a * 2 -> {t*1e3:8.2f} ms")
a = np.arange(5, dtype=object)
print("dtype=object 的数组也是 numpy:", type(a), a.dtype)
实跑输出:
算一算
dtype=int64 a * 2 -> 3.23 ms
dtype=object a * 2 -> 25.41 ms
dtype=object 的数组也是 numpy: <class 'numpy.ndarray'> object
这次记录中,25.41 ÷ 3.23 ≈ 7.9。虽然两次都写了 *,NumPy 会根据输入的 dtype 选择内部循环。int64 路径直接读写固定宽度整数,object 路径逐个调用 Python 对象的乘法。两者都有循环,循环里做的工作不同。NumPy 对通用函数内部循环的说明
⚠️ 先区分 dtype 推断与运算开销:在 NumPy 2.x 中,纯字符串通常得到字符串 dtype;含 None 的混合数据或显式 dtype=object 可得到 object 数组;长度不齐的嵌套列表通常直接报 ValueError,除非明确请求 object,不能都说成“悄悄变 object 且不报错”。当 dtype 确实是 object 时,本节的逐元素 Python 对象运算开销才适用。拿不准就检查 print(a.dtype),并验证输入是否规则。
⚡ 四、快在哪:三层,一层比一层浅
可以从下面三方面检查一次数组运算的成本。上面的计时没有分别测出三项各自贡献多少。
| 层 | 省掉了什么 | 什么时候有帮助 |
|---|---|---|
| ① 按类型选择内部循环 | 数值路径直接处理数据,减少逐个 Python 对象乘法的开销。 | 输入适合固定宽度的数值类型。 |
| ② 内存访问布局 | 邻近元素一起读时更容易利用缓存。以 64 字节缓存行为例,一行可放 8 个 8 字节的 float64。 |
访问顺序能有效利用已读入的数据。 |
| ③ 单指令多数据(SIMD) | 用同一条指令处理多个数值元素。 | 依赖运算、类型、内存布局及 CPU 和 NumPy 构建支持。 |
数值数组的底层循环可以按步长取值。步长就是沿某个方向走一格时在内存里跨过的字节数,详见第 05 章。例如 a[::2] * 2 能直接对隔一个元素取到的数据做数组运算。单看数组是否连续,无法确定这次调用走哪条 SIMD 路径。NumPy 的 CPU 与 SIMD 说明
⭐ 本章说的向量化,是把一批元素交给数组操作。
a * b仍要完成每项乘法,但可以避开外层 Python 的逐项调用。np.vectorize(某个 Python 函数)则为原函数提供数组输入的写法,默认逐元素调用它,仍有 Python 函数调用成本。NumPy 的 vectorize 说明
🧯 那什么时候循环反而是对的?
⚠️ 别把「不许写循环」当教条。这三种情况循环是正确选择:
| 情况 | 为什么 |
|---|---|
| 迭代次数很少、每次的数组很大 | 比如训练循环跑 100 个 epoch,每个 epoch 内部都是大数组运算 —— 外层那 100 圈的解释器开销可以忽略 |
| 本质是串行的 | 后一步依赖前一步的结果(某些递推、某些自适应算法)。⚠️ 但先确认一下:前缀和、累乘、累计最值都有现成的 cumsum / cumprod / maximum.accumulate,见第 07 章 |
| 向量化版本的中间体撑爆内存 | 第 03 章会看到一个具体例子:400 个样本算两两距离,广播版的中间体是 2.4 MB;样本涨到 4000,中间体就是 244.1 MB |
⭐ 先确定循环中哪些步骤耗时,再比较改写的总成本。 保留少量外层循环、每次处理一块数据,有时可以兼顾内存和速度。转换输入或创建中间数组的成本也要计入。
03 / 完整解释
把测量带回自己的代码。
🔗 这一章连到哪里
| 相关的地方 | 为什么 |
|---|---|
| 07 · 把循环改写成数组运算 | 这一章讲为什么要改,那一章讲具体怎么改 —— 累积 / 分组 / Top-K / 滑窗 / 分桶 / 游程六个套路,各带一次实跑倍数 |
| 03 · 广播的三条规则 | 消掉循环最常用的工具就是广播。⚠️ 也是「中间体撑爆内存」这个反例的出处 |
| 05 · 内存布局、stride 与 C/F order | 第 05 章解释步长怎样改变访问顺序,并用具体输入对比连续性和计算耗时。 |
| 08 · 整数 dtype 的真相 | 本章说「拿不准就 print(a.dtype)」。dtype 除了影响速度,还会让你的数字静默变成负数 |
| AI 基础设施 02 · GPU 到底是什么 | 「连续内存为什么快」在 GPU 上是同一个道理的另一个尺度(合并访存 vs CPU cache line)。那边讲 GPU 显存,这边讲 CPU 内存,别混着读 |
| ML 基础 附录 C · 手撕代码速查 | 那份附录里十道题全用 NumPy 写成,默认你已经会向量化。这一章是它的前置 |
✅ 检查点
- 纯 Python 循环和
a * b差多少倍?为什么这一章不给一个确定的数字? - 解释器每转一圈要做八件事,其中哪一件是你真正想做的?其余七件为什么存在?
- 按本页脚本的统计口径,100 万个整数用 Python 列表和
int64数组各占多少空间? - ⭐ 那个「同样是 NumPy 却慢 8 倍」的反例是怎么构造的?它推翻了哪个说法?
- 除了数值类型,数组运算的内存访问布局和 CPU 指令支持怎样影响速度?
- 「向量化」的准确含义是什么?(提示:省下的不是算术)
- 什么时候写循环反而是对的?举三种情况。
- 判断「这个循环该不该改」的判据是什么?
👀 答案
- 这组记录用两行最短耗时相除,
68.17 ÷ 3.51 ≈ 19.4。四次运行的记录分别为 19x、29x、35x、37x,其他输入大小、布局或计时口径会得到自己的结果。 - 第 ⑥ 步算出数值。其他步骤负责执行循环、取得输入对象、选择运算、保存结果及管理引用。
- 这份列表的引用表约 8 MB,连同脚本逐项统计的整数对象约 36 MB。
int64数组的元素缓冲区为1,000,000 × 8 = 8,000,000字节。 np.arange(N, dtype=object)与dtype=np.int64都执行* 2,这次记录分别为 25.41 ms 和 3.23 ms。相同的运算入口按类型选用不同循环,前者仍逐个调用 Python 对象乘法。- 相邻的数据更容易一起读入缓存。SIMD 可以让一条指令处理多个值,实际能否启用依赖运算、类型、布局、CPU 和构建选项。
- 把一批元素交给数组操作,NumPy 按输入的类型与布局组织循环。以
a * b为例,每项仍要相乘,但普通数值路径省掉了逐项调用 Python 乘法的工作。 - ① 迭代次数少、每次的数组很大(训练循环跑 100 个 epoch,外层 100 圈的开销可忽略);② 本质串行(后一步依赖前一步,⚠️ 但先确认不是
cumsum/cumprod/maximum.accumulate能干的);③ 向量化版本的中间体撑爆内存(03 章那个例子:400 个样本算两两距离,广播版中间体 2.4 MB;样本涨到 4000 就是 244.1 MB)。 - 核对两种写法的结果,再比较真实规模下的总时间和内存。若大数组的临时结果占用太高,可以保留外层循环,每轮处理一块。
本节回顾
⚡ 走神救援
⭐ 先对结果。 三笔订单逐项相乘得到
[10, 8, 18],循环和数值数组写法都应给出这三个数。逐项处理 Python 对象需要取引用、执行运算和管理结果。
int64数组可以直接读写固定宽度的数;object数组仍逐项调用 Python 对象乘法。同样的*可以走不同路径。布局影响怎样读数据,SIMD 取决于本次运算和运行环境。遇到陌生数组先检查
a.dtype与a.shape。在自己的输入上测量耗时和内存。数据转换、大型中间结果以及必须保留的顺序依赖,都会影响改写的取舍。
下一节 👉 02-shape与axis到底怎么数.md