系列 《Python 在 AI-Infra:从语言机制到生产交付》 第 2 / 15 篇 进阶
系列总览 — 为什么这样组织、读它需要什么、读完能做什么 · 幻灯片 — 整个系列的精华,一份可分享的 deck
学习地图 — AI-Infra 工程师学习地图 第 1 / 14 个系列
《执行模型》说函数对象携带 __globals__,帧里存放局部变量。那么函数体里写下一个名称时,Python 在哪里找它?答案是编译期就决定了——这是理解闭包、nonlocal 和”循环里的 lambda 全都返回同一个值”的钥匙。
本篇只回答一个问题:
函数体里写下一个名称,Python 去哪里找它;外层函数返回之后,内层函数为什么还能用它的变量?1
一、总览
本篇先讲规则,再讲实现,最后讲由实现带来的现象:名称归属哪个作用域是编译期定的(第二章);内层函数用到的外层变量存在 cell 里,这就是闭包(第三章);UnboundLocalError 和延迟绑定都是这两条的直接后果(第四、五章);最后是闭包与类的取舍(第六章)。
| 章 | 主题 | 内容 |
|---|---|---|
| 二 | LEGB 是编译期规则 | 四类作用域、名称归属在编译期决定、对应的字节码 |
| 三 | 闭包就是”函数对象 + cell” | __closure__、cell 的生命周期 |
| 四 | nonlocal 与 UnboundLocalError |
赋值让名称变成局部、global / nonlocal 声明 |
| 五 | 延迟绑定:cell 是共享的 | 循环里的 lambda、默认参数的修法 |
| 六 | 闭包还是类 | 两种保存状态方式的取舍 |
| 七 | 本文小结 | |
| 八 | 自测 | 3 道题 |
二、LEGB 是编译期规则
名称查找的四层通常叫 LEGB:Local(当前函数)→ Enclosing(外层函数)→ Global(模块)→ Builtins。这个缩写乍一看很像 LGBT,第一次见的人常常念串;它其实没有别的含义,只是四个单词的首字母,按由内到外的顺序排:先看自己这个函数,再看包着它的函数,再看模块,最后看内置。
编译器编译每个函数时,把函数体里出现的每个名字归进四类之一,记在这个函数的 code object 的四张名单上:
| code object 上的名单 | 类别 | 是什么 |
|---|---|---|
co_varnames |
局部变量 | 本函数自己的变量(含参数),只有自己用 |
co_cellvars |
cell 变量 | 本函数自己的变量,但内层函数也要用 |
co_freevars |
自由变量 | 不是本函数的,从外层函数借来的 |
co_names |
全局名称 | 既不是自己的、也不是外层函数的:运行时到模块和内置里按名字找。这张名单其实是“按名字查的字符串表”,属性名、import 的模块名也记在这里,所以它不全是作用域意义上的全局变量 |
用一个四层各放一个名字的例子把四张名单打印出来:
import builtins
limit = 100 # 模块里绑定
def outer(items):
total = 0 # 只在 outer 里用
seen = [] # outer 里绑定,inner 也要用
def inner(x):
doubled = x * 2 # 只在 inner 里用
seen.append(doubled) # 来自外层函数
return min(doubled, limit) # limit 来自模块,min 来自内置
for item in items:
total += inner(item)
return total, inner
total, inner = outer([10, 80])
for fn in (outer, inner):
code = fn.__code__
print(fn.__name__)
print(" 局部变量 co_varnames:", code.co_varnames)
print(" cell 变量 co_cellvars:", code.co_cellvars)
print(" 自由变量 co_freevars:", code.co_freevars)
print(" 按名字查的 co_names :", code.co_names)
print("inner.__closure__[0].cell_contents =", inner.__closure__[0].cell_contents)
print("limit 在模块字典里:", "limit" in globals(), " min 在 builtins 里:", hasattr(builtins, "min"))
outer
局部变量 co_varnames: ('items', 'total', 'inner', 'item')
cell 变量 co_cellvars: ('seen',)
自由变量 co_freevars: ()
按名字查的 co_names : ()
inner
局部变量 co_varnames: ('x', 'doubled')
cell 变量 co_cellvars: ()
自由变量 co_freevars: ('seen',)
按名字查的 co_names : ('append', 'min', 'limit')
inner.__closure__[0].cell_contents = [20, 160]
limit 在模块字典里: True min 在 builtins 里: True
把这些名字各自存在哪、inner 运行时怎么取到它们画出来:
%% 图:四层例子里每个名字存在哪:局部变量在各自的帧里,seen 在 cell 里被两边共同引用,limit 与 min 在两个字典里
flowchart TB
subgraph IFR["inner 的帧(L,每次调用一个)"]
IL["<b>局部变量</b><br/>x、doubled<br/>LOAD_FAST:就在本帧里"]
IG["<b>全局名称</b><br/>limit、min<br/>LOAD_GLOBAL:到字典里按名字找"]
IFV["<b>自由变量</b><br/>seen<br/>LOAD_DEREF:到 cell 里取"]
end
subgraph MOD["模块字典(G):先查这里"]
LIMIT["limit = 100"]
end
subgraph BI["内置字典(B):模块里没有,再查这里"]
MIN["min、len、print …"]
end
subgraph OF["outer 的帧(L,对 inner 来说是 E)"]
OL["<b>局部变量</b><br/>items、total、item、inner"]
OC["<b>cell 变量</b><br/>seen"]
end
subgraph FN["inner 函数对象"]
CL["__closure__#91;0#93;"]
end
CELL(["<b>cell 对象</b><br/>装着列表 #91;20, 160#93;"])
IG --> LIMIT
LIMIT -.-> MIN
IFV --> CL
CL --> CELL
OC --> CELL
classDef cell fill:#fff7e0,stroke:#c98a00,stroke-width:2px,color:#222
class CELL,OC,IFV,CL cell
- 局部变量(
x、doubled、total…):在谁的帧里就是谁的,调用结束随帧消失。 seen只有一份,放在黄色的 cell 里。outer的帧和inner函数对象各有一个箭头指向它:在outer的名单里它叫 cell 变量,在inner的名单里它叫自由变量,是同一个东西的两头。输出最后那个[20, 160]就是outer返回之后从inner手里的 cell 读出来的。limit、min不在任何帧里:inner运行时先查模块字典,没有再查内置字典。所以在模块里定义一个叫min的变量,会把内置的min挡住。
四类与 LEGB 四层不是一一对应:LEGB 说的是名字绑定在哪一层,四类说的是站在某个函数里看它存在哪、用哪条指令取。
| 名字绑定在哪一层(LEGB) | 站在使用它的函数里,编译器归为 | 值存在哪 | 取值指令 | 上例中 |
|---|---|---|---|---|
| L:本函数,没有内层函数用它 | 局部变量 | 这次调用的帧里 | LOAD_FAST |
|
| L:本函数,且有内层函数用它 | cell 变量 | 一个单独的 cell 对象里,帧只留一个指向它的引用 | LOAD_DEREF |
outer 的 seen |
| E:外层函数 | 自由变量 | 外层函数的那个 cell(同一个对象) | LOAD_DEREF |
inner 的 seen |
|
全局名称(编译器不区分 G 与 B) | 模块的字典;找不到再查内置的字典 | LOAD_GLOBAL |
|
L 这一层被拆成了两类,G 与 B 被并成了一类。
编译器怎么决定一个名字归哪一类:编译 inner 时扫描整个函数体,有赋值的是局部变量,没有赋值但在外层函数中有定义的是自由变量(free variable),其余都当作全局/内置。
Python 没有变量声明,一个名称属于哪个作用域由”这个函数体里有没有对它赋值”决定,而且是在编译期、看整个函数体一次决定的。
与 Java 对照:声明与赋值
Java 里 int count; 先声明局部变量,之后的 count++ 只是使用;Python 里一句 count = 99 本身就让编译器把 count 归为本函数的局部变量,不管它写在函数的第几行(显式 global / nonlocal 除外)。
三个函数,模块里有一个 count = 10,看各自读到什么:
import traceback
count = 10
def only_read():
return count # 整个函数没有给 count 赋值
def read_then_assign():
first = count # 第一行想读模块里的 count
count = 99 # 后面才赋值
return first
def declare_then_assign():
global count # 先声明
first = count
count = 99
return first
for fn in (only_read, read_then_assign, declare_then_assign):
names = str(fn.__code__.co_varnames)
try:
result = fn()
except UnboundLocalError as error:
failing_line = traceback.extract_tb(error.__traceback__)[-1].line.split("#")[0].strip()
result = f"UnboundLocalError,出错的行:{failing_line}"
print(f"{fn.__name__:20s} 局部变量 {names:19s} → {result}")
print("模块里的 count 现在是", count)
only_read 局部变量 () → 10
read_then_assign 局部变量 ('count', 'first') → UnboundLocalError,出错的行:first = count
declare_then_assign 局部变量 ('first',) → 10
模块里的 count 现在是 99
三个函数运行时各自去哪里找 count:
%% 图:三个函数各自去哪里找 count:没有赋值的去模块字典,有赋值的只看自己的帧,声明了 global 的读写都落在模块字典
flowchart TB
A["<b>only_read 的帧</b><br/>局部变量:无<br/>读 count:去模块字典"]
B["<b>read_then_assign 的帧</b><br/>局部变量:count、first(都还没有值)<br/>读 count:只看自己的帧,是空的,报错"]
C["<b>declare_then_assign 的帧</b><br/>局部变量:first<br/>count 声明了 global"]
MOD["<b>模块字典</b><br/>count = 10,最后被改成 99"]
A -- "读到 10" --> MOD
B ~~~ MOD
C -- "读到 10,写入 99" --> MOD
classDef bad fill:#fdecea,stroke:#c0392b,stroke-width:2px,color:#222
classDef ok fill:#eefaf0,stroke:#4d9a5c,color:#222
class B bad
class A,C,MOD ok
中间那一帧没有连到模块字典的线:模块里明明有 count = 10,它不去看。由此得到三条后果,每条都能在上面的输出里找到:
- 一个名字在一个函数里只归一类,不存在”前半段是全局、后半段是局部”。
read_then_assign第一行想读的是模块里的count,但函数后面有一句赋值,整个函数里的count就都是局部变量了。输出里出错的行是first = count——读的那一行,而不是赋值那一行。 - 局部变量可以”有位置、没有值”。
count在read_then_assign的局部变量名单里,位置已经留好,只是执行到第一行时还没放进值。所以报的是UnboundLocalError(局部变量还没绑定值),不是”找不到这个名字”的NameError。 - 要在函数里改外层的变量,必须先声明。
declare_then_assign多了一句global count,count就从局部变量名单里消失了,读到 10、写入的 99 落在模块字典里(最后一行)。要改的是外层函数的变量时,用的是nonlocal(第四章)。
编译器对函数体里的每个名称做的是同一串判断,判断的结果就是运行时用哪条取值指令:
%% 图:编译器给函数里的一个名称分类,以及对应的取值指令
flowchart TB
N["函数体里出现名称 x"] --> D{"本函数声明了<br/>global x 或 nonlocal x?"}
D -- "global x" --> GL["<b>全局名称</b><br/>LOAD_GLOBAL:运行时先查模块 __dict__,再查 builtins"]
D -- "nonlocal x" --> FV["<b>自由变量</b><br/>LOAD_DEREF:从外层函数的 cell 取值"]
D -- "都没有" --> A{"本函数里绑定了 x?<br/>(参数、=、+=、for x、import x、def x)"}
A -- "绑定了" --> IN{"内层函数引用了 x?"}
IN -- "没有" --> LO["<b>局部变量</b><br/>LOAD_FAST:帧里的局部槽位"]
IN -- "引用了" --> CV["<b>cell 变量</b><br/>LOAD_DEREF:放进 cell,与内层函数共享"]
A -- "没绑定" --> E{"外层函数里绑定了 x?"}
E -- "是" --> FV
E -- "否" --> GL
图里只有 LOAD_GLOBAL 在运行时按名字查字典(模块 __dict__ 找不到再去 builtins);局部变量和 cell 都是按编译时排好的下标取值,运行时不再”找”。判断的第二步只问”有没有绑定”,不问绑定出现在第几行——第四章的 UnboundLocalError 就落在”局部变量”这个出口上,只是读的时候槽位里还没有值。
分类结果直接体现在字节码里。接着上面的例子,把 inner 里每个名字用的取值指令列出来:
import dis
for ins in dis.get_instructions(inner):
if ins.opname.startswith("LOAD") and isinstance(ins.argval, str):
print(f"{ins.argval:8s} {ins.opname}")
x LOAD_FAST
seen LOAD_DEREF
append LOAD_ATTR
doubled LOAD_FAST
min LOAD_GLOBAL
doubled LOAD_FAST
limit LOAD_GLOBAL
x、doubled 是 LOAD_FAST,seen 是 LOAD_DEREF,min、limit 是 LOAD_GLOBAL,与上面那张表逐行对得上(append 是属性,用 LOAD_ATTR)。
LOAD_DEREF 表示”从 cell 中取值”,而不是 LOAD_FAST(局部)或 LOAD_GLOBAL(全局)。查找位置是编译期确定的,运行时只是按位置取值。这也是为什么在函数里对一个名称赋值,会让整个函数中该名称都变成局部变量,哪怕赋值语句在后面——下面第四章的 UnboundLocalError 就是这个规则的直接后果。
三、闭包就是”函数对象 + cell”
outer([10, 80]) 返回之后,它的帧已经销毁,inner 为什么还能往 seen 里追加?因为 seen 不在 outer 的帧里,而在 cell 里,inner 函数对象通过 __closure__ 拿着这个 cell。接着上面的例子:
print(outer.__code__.co_cellvars) # outer 里要与内层共享的变量
print(inner.__code__.co_freevars) # inner 里从外层借来的变量
print(inner.__closure__) # inner 函数对象手里的 cell
print(inner.__closure__[0].cell_contents)
inner(5) # outer 早已返回,inner 仍能往 seen 里追加
print(inner.__closure__[0].cell_contents)
('seen',)
('seen',)
(<cell at 0x…: list object at 0x…>,)
[20, 160]
[20, 160, 10]
%% 图:闭包里的三个对象:outer 的帧、cell、inner 函数对象,以及 outer 返回前后各自的去留
flowchart LR
FR["<b>outer 的帧</b><br/>outer 返回后销毁"] -. "指向 cell 的引用<br/>随帧一起消失" .-> CELL(["<b>cell 对象</b><br/>装着列表 seen"])
FN["<b>inner 函数对象</b><br/>模块里的名称 inner 指着它"] -- "__closure__#91;0#93;" --> CELL
CALL["<b>inner(5) 的帧</b><br/>每次调用新建一个"] -- "LOAD_DEREF<br/>从 cell 取 seen" --> CELL
classDef gone fill:#f4f4f4,stroke:#aaa,color:#777,stroke-dasharray:4 3
classDef live fill:#fff7e0,stroke:#c98a00,color:#222
class FR gone
class CELL,FN,CALL live
| 步骤 | 发生了什么 | 这时谁指着 cell |
|---|---|---|
① 调用 outer([10, 80]) |
新建 outer 的帧;seen 是 cell 变量,所以同时新建一个 cell,把列表放进去 |
outer 的帧 |
② 执行 def inner |
新建 inner 函数对象,把这个 cell 的引用放进它的 __closure__ |
outer 的帧、inner 函数对象 |
③ outer 返回 |
帧销毁;返回的 inner 函数对象绑定到模块里的名称 inner |
只剩 inner 函数对象 |
④ 调用 inner(5) |
新建 inner 的帧,LOAD_DEREF 顺着 __closure__ 从 cell 里取到列表,追加 10 |
inner 函数对象 |
所以闭包不是什么魔法:”外层帧销毁了,但 cell 对象被内层函数对象引用着,所以还活着。” 再调用一次 outer() 会新建另一个 cell 和另一个 inner 函数对象,两次得到的闭包互不影响——第四章的计数器就靠这一点让每个计数器各数各的。这就是词法作用域:名称的解析依据函数定义时的代码结构,与调用位置无关。
在 AI-Infra 中闭包常用来携带少量配置进入回调:后端名、重试次数、指标标签、模型引用。但它也是隐式依赖——读者无法从函数签名看出它依赖了什么。
四、nonlocal 与 UnboundLocalError
读外层变量不需要声明,重新绑定外层变量需要 nonlocal:
def make_counter(start=0):
count = start
def increment():
nonlocal count
count += 1
return count
return increment
counter = make_counter()
print(counter(), counter()) # 1 2
print(counter.__closure__[0].cell_contents) # 2 —— 修改的是同一个 cell
去掉 nonlocal 会得到:
UnboundLocalError: cannot access local variable 'count' where it is not associated with a value
按第二章的规则,count += 1 是赋值,编译器因此把 count 判定为 increment 的局部变量;执行时先读局部槽位,而它还没有值。这个错误经常出现在把一个模块级计数器、开关或缓存直接在函数里 += 的时候——那时需要的是 global。
与 Java 对照:修改捕获的状态
Java 的 lambda 和匿名内部类捕获的外层局部变量必须是 final 或 effectively final,不能像 Python 的 nonlocal count 那样重新绑定。要累加状态,通常捕获数组、AtomicInteger 或其他对象的引用,再修改其内容;引用不能重新赋值,不代表对象不可变。
五、延迟绑定:cell 是共享的
闭包最常见的陷阱:
def make_fns():
fns = []
for i in range(3):
fns.append(lambda: i)
return fns
print([fn() for fn in make_fns()]) # [2, 2, 2]
先看清 lambda: i 这个写法本身。lambda 参数列表: 表达式 定义一个匿名函数,冒号前是参数、冒号后是返回值;lambda: i 的参数列表是空的,所以 i 不是参数,而是一个要到外层去找的自由变量——每次调用它,都去 make_fns 的作用域里取 i 当前的值。
用第三章的知识解释结果:i 是 make_fns 的 cell 变量,三个 lambda 的 __closure__ 指向同一个 cell(可以打印 id(fn.__closure__[0]) 验证,三者相同)。lambda 体里的 i 在调用时才 LOAD_DEREF,此时循环早已结束,cell 里是最后一个值。
修法是在创建时就把值固定下来——用默认参数(默认值在 def/lambda 求值时计算一次):
fns.append(lambda i=i: i) # [0, 1, 2]
i=i 里等号左边是 lambda 自己的参数 i,右边是循环变量 i 此刻的值,被当作默认值存进函数对象(fn.__defaults__);调用 fn() 时不传参,就用这个默认值,于是 lambda 体里的 i 变成了局部变量,不再去外层找。注意不能写成 lambda i: i——那是一个必须接收一个参数的恒等函数,fn() 会直接报 TypeError: <lambda>() missing 1 required positional argument: 'i'。
两种写法的差别在于值存在哪里:
%% 图:延迟绑定:三个 lambda 共享一个 cell,默认参数版各自存一份值
flowchart LR
subgraph LATE["lambda: i"]
direction TB
F0["fns#91;0#93;"] -- "__closure__#91;0#93;" --> CELL["<b>make_fns 的 cell i</b><br/>循环结束后是 2"]
F1["fns#91;1#93;"] -- "__closure__#91;0#93;" --> CELL
F2["fns#91;2#93;"] -- "__closure__#91;0#93;" --> CELL
end
subgraph EARLY["lambda i=i: i"]
direction TB
G0["fns#91;0#93;.__defaults__ = (0,)"]
G1["fns#91;1#93;.__defaults__ = (1,)"]
G2["fns#91;2#93;.__defaults__ = (2,)"]
G0 ~~~ G1 ~~~ G2
end
LATE ~~~ EARLY
左边三个函数对象指向同一个 cell,cell 只有一个”当前值”,调用时读到的都是循环结束后的 2;右边每个函数对象在创建时把 i 的值拷进自己的 __defaults__,之后循环再怎么改 i 都与它无关。
或者用 functools.partial(handler, i),语义更明确。构造一批 Worker 回调、为每个 GPU 生成一个任务函数、在循环里注册 hook,都会遇到这个问题。
与 Java 对照:捕获值与共享变量
Java 的 lambda 捕获外层局部变量的值;如果值是引用,拷贝的也是引用。Python 闭包共享的是 cell,调用时读当前值。上面会变化的循环变量 i 在 Java 中不满足 effectively final,直接捕获会编译失败;通常在每轮声明一个新的局部变量保存当轮值,再交给 lambda。
六、闭包还是类
闭包和类都能”把状态和行为绑在一起”。取舍标准是状态的数量和生命周期:
- 一两个只读配置、一个简单计数:闭包即可,代码短;
- 状态多于两三个、需要被外部检查或重置、有清理逻辑:用类。类的状态在
__dict__里可见可调试,闭包的状态藏在cell_contents里。
《装饰器、生成器与上下文管理器》的「装饰器」一章会看到,装饰器既可以用闭包写,也可以用类写,取舍标准相同。
七、本文小结
- 名称属于哪个作用域(Local → Enclosing → Global → Builtins)在编译期按”本函数里有没有绑定”决定,运行时只是按位置取值。
- 函数体内任何位置对一个名称赋值,它在整个函数里都是局部变量;要改外层的用
global/nonlocal。 - 闭包 = 函数对象 + cell。外层帧销毁后,cell 被内层函数的
__closure__引用着,所以还活着。 - cell 是共享的、调用时才读,所以循环里创建的多个闭包读到的是同一个变量的最终值。
八、自测
-
一个函数里写了
x = x + 1,而x是全局变量,为什么读它会报UnboundLocalError而不是拿到全局值?答案
名称的归属在编译期决定:函数体内出现对
x的赋值,x就是这个函数的局部变量,整个函数里都是——不存在”前半段全局、后半段局部”。读到x + 1时局部x还没有值,于是UnboundLocalError。要改全局的x必须global x(外层函数的变量则nonlocal)。 -
循环里写
fns.append(lambda: i),三个函数各返回什么?把i改成lambda i=i: i之后呢?答案
第一种都返回 2,第二种返回 0、1、2。
lambda: i里的i是自由变量,三个函数的__closure__指向make_fns的同一个 cell,调用时才读,读到的是循环结束后的值;i=i在创建函数时把当时的值存进各自的__defaults__,函数体里的i变成局部变量,不再读 cell。 -
outer()已经返回,它的帧销毁了,返回的inner为什么还能读到outer的局部变量?再调用一次outer()得到的闭包会和前一个共享这个变量吗?答案
被
inner用到的外层变量不存在帧的普通槽位里,而是存在一个 cell 对象里;inner的__closure__引用着这个 cell,所以帧销毁后它还活着。不共享:每次调用outer()都新建一个 cell 和一个inner函数对象。
系列 《Python 在 AI-Infra:从语言机制到生产交付》 第 2 / 15 篇 进阶
系列总览 — 为什么这样组织、读它需要什么、读完能做什么 · 幻灯片 — 整个系列的精华,一份可分享的 deck
学习地图 — AI-Infra 工程师学习地图 第 1 / 14 个系列
上一篇:代码如何被执行——code object、函数对象与执行帧下一篇:代码如何被加载——模块与导入系统
下一个系列:C++ 在 AI-Infra:从对象模型到算子扩展 进阶 · 10 篇,约 9.5 小时
本文由 arganzheng 创作,采用 CC BY 4.0 许可协议。在保留原文作者、署名以及完整原文链接(https://arganzheng.life/python-scopes-and-closures.html)的前提下,欢迎各种形式的转载、翻译或商业引用。
COMMENTS
评论存放在 GitHub Discussions, 用 GitHub 账号登录即可发表,支持 Markdown。 想针对正文某句话说?选中那段文字,点浮出的「评论」即可划线评论;觉得哪里写错了,发表时勾上「同时提交 Issue」。 有人回复你时 GitHub 会按你的通知设置发邮件,不用守在这里。