🏠 总目录📚 本教程 01 · 为什么写循环是错的 ← →

NUMPY / 01 · 01 · 为什么写循环是错的

同样算一遍,时间花在哪里了?

问题不只是有没有写 for。先分清:是在解释器里逐个处理,还是把一整块任务交给数组内核。

你能先定位开销,再决定改写是否值得;不会把“向量化”当成无条件更快。

dispatch 机制示意这是执行路径的简化示意,不按方框数量或线长表示耗时;具体倍数仍以原文实验条件为限。逐个处理Python → 取数 → 运算数组整体处理Python → 数组内核先问任务与规模不能凭名字承诺加速
这是执行路径的简化示意,不按方框数量或线长表示耗时;具体倍数仍以原文实验条件为限。
阅读范围、用时与原有实验记录
实验记录怎么读

本页原有耗时、内存、报错和环境值保留为原文记录;本轮内容审校未逐项复跑这些实验。版本、硬件、数据和测量方法都会影响结果,示例中的倍数也不是保证。需要复现时先核对依赖版本,再在同一输入下比较。

⏱ 42 分钟 | ⭐ 同一件事,纯 Python 68 毫秒、NumPy 3.5 毫秒 —— 差的是一个量级,而差距的来源不是「C 比 Python 快」

01 / 完整解释

先比较同一件任务。

🎯 一句话

同样乘一遍,逐个处理 Python 对象会多做什么工作?

循环写法让解释器逐次取值、相乘、保存。把一组同类型的数交给 NumPy,可以为整批数据选择一套运算方式,在底层完成乘法。这里先把结果算对,再比较成本。

⚠️ 先消歧:这一套教程里的「向量化」指把 Python 循环改写成整块数组运算。 站内别处出现的「向量化」(智能体工程教程/11、大模型全景导论/08 等 10 处) 说的是把文本变成 embedding 向量,是另一回事。

📏 一、先看差距有多大

先手算三笔销售额

三笔订单的数量是 [2, 4, 3] 件,对应单价是 [5, 2, 6] 元/件。每笔销售额等于该笔的数量乘单价,结果保留原订单顺序。可以先遮住结果一列,自己算出三个值。

每笔订单只乘同一位置的两个数
订单数量 × 单价销售额(元)
第 1 笔2 × 510
第 2 笔4 × 28
第 3 笔3 × 618

循环中的 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 写成,默认你已经会向量化。这一章是它的前置

✅ 检查点

  1. 纯 Python 循环和 a * b 差多少倍?为什么这一章不给一个确定的数字?
  2. 解释器每转一圈要做八件事,其中哪一件是你真正想做的?其余七件为什么存在?
  3. 按本页脚本的统计口径,100 万个整数用 Python 列表和 int64 数组各占多少空间?
  4. ⭐ 那个「同样是 NumPy 却慢 8 倍」的反例是怎么构造的?它推翻了哪个说法?
  5. 除了数值类型,数组运算的内存访问布局和 CPU 指令支持怎样影响速度?
  6. 「向量化」的准确含义是什么?(提示:省下的不是算术)
  7. 什么时候写循环反而是对的?举三种情况。
  8. 判断「这个循环该不该改」的判据是什么?
👀 答案
  1. 这组记录用两行最短耗时相除,68.17 ÷ 3.51 ≈ 19.4。四次运行的记录分别为 19x、29x、35x、37x,其他输入大小、布局或计时口径会得到自己的结果。
  2. 第 ⑥ 步算出数值。其他步骤负责执行循环、取得输入对象、选择运算、保存结果及管理引用。
  3. 这份列表的引用表约 8 MB,连同脚本逐项统计的整数对象约 36 MB。int64 数组的元素缓冲区为 1,000,000 × 8 = 8,000,000 字节。
  4. np.arange(N, dtype=object) 与 dtype=np.int64 都执行 * 2,这次记录分别为 25.41 ms 和 3.23 ms。相同的运算入口按类型选用不同循环,前者仍逐个调用 Python 对象乘法。
  5. 相邻的数据更容易一起读入缓存。SIMD 可以让一条指令处理多个值,实际能否启用依赖运算、类型、布局、CPU 和构建选项。
  6. 把一批元素交给数组操作,NumPy 按输入的类型与布局组织循环。以 a * b 为例,每项仍要相乘,但普通数值路径省掉了逐项调用 Python 乘法的工作。
  7. ① 迭代次数少、每次的数组很大(训练循环跑 100 个 epoch,外层 100 圈的开销可忽略);② 本质串行(后一步依赖前一步,⚠️ 但先确认不是 cumsum/cumprod/maximum.accumulate 能干的);③ 向量化版本的中间体撑爆内存(03 章那个例子:400 个样本算两两距离,广播版中间体 2.4 MB;样本涨到 4000 就是 244.1 MB)。
  8. 核对两种写法的结果,再比较真实规模下的总时间和内存。若大数组的临时结果占用太高,可以保留外层循环,每轮处理一块。

本节回顾

⚡ 走神救援

⭐ 先对结果。 三笔订单逐项相乘得到 [10, 8, 18],循环和数值数组写法都应给出这三个数。

逐项处理 Python 对象需要取引用、执行运算和管理结果。int64 数组可以直接读写固定宽度的数;object 数组仍逐项调用 Python 对象乘法。同样的 * 可以走不同路径。

布局影响怎样读数据,SIMD 取决于本次运算和运行环境。遇到陌生数组先检查 a.dtype 与 a.shape。

在自己的输入上测量耗时和内存。数据转换、大型中间结果以及必须保留的顺序依赖,都会影响改写的取舍。

下一节 👉 02-shape与axis到底怎么数.md

打卡记录保存在你的浏览器里,首页能看到总进度

把数据交给整块运算之前,先回答:这块数据的 shape 是什么?