Python闭包变量作用域常见误区解析

一个让人加班的Bug

先讲一个真实的场景。

某个周三晚上，程序员还在工位上对着屏幕发愁。一个跑了几天都没问题的Python脚本，突然出现了一个诡异的bug。代码逻辑其实很简单：用循环创建几个函数，每个函数记住自己对应的数字。

代码的逻辑大概是这样：

funcs = []
for i in range(3):
    def f():
        print(i)
    funcs.append(f)

for f in funcs:
    f()

预期输出是什么？大多数人的第一反应是：0, 1, 2。

结果呢？

2
2
2

三个2。

当时的第一反应是：“这不可能”。Python这么简单的循环闭包怎么可能出错？一定哪里写错了。检查了三遍代码，没错。又检查了三遍，还是没错。那一刻的感觉，就像是刚学Python的新手，遇到了一个完全无法理解的状况。

后来查了半小时资料，才发现——原来对闭包的理解一直有问题。

今天就把这个坑彻底讲清楚。

先搞明白：什么是闭包？

先说定义。闭包就是一个函数，它记住了外部作用域的变量。

举个例子：

def outer():
    msg = "hello"
    def inner():
        print(msg)
    return inner

my_func = outer()
my_func()  # 输出 hello

这里的 inner 就是一个闭包。它记住了 outer 函数里的 msg 变量，即使 outer 已经执行完了。

看起来很简单对吧？那为什么开头的例子会出问题？

问题核心：变量什么时候被“记住”？

很多人（包括以前的我）以为：定义函数的时候，它就会记住当前变量的值。

错。

实际上：函数被调用的时候，才会去查找变量的值。

这就是关键。

看回开头那个例子：

funcs = []
for i in range(3):
    def f():
        print(i)
    funcs.append(f)

循环创建了三个函数，每个函数都在说“我要打印变量 i 的值”。但这个 i 是谁？不是每个函数的私有拷贝，而是同一个变量 i。

循环结束后，i 的值变成了 2。然后你调用这些函数时，每个函数都去查找当前环境里变量 i 的值——找到了，是 2。于是三个函数都打印 2。

这就是真相：闭包捕获的是变量本身，不是变量的值。

用比喻理解这个问题

想象你在一栋写字楼里。第1层、第2层、第3层各有一家公司。每家公司都装了一个显示屏，显示“当前楼层号”。本来每层的显示屏应该显示不同的数字：1、2、3。但现在有个问题——这三块显示屏都连着同一个传感器，这个传感器告诉你“当前电梯停在哪一层”。

你一开始把电梯停到1楼，传感器显示1。但突然有人按了电梯，电梯跑到2楼了。传感器现在显示2，三块显示屏同时更新成2。电梯再跑到3楼，三块屏又同时变成3。最后电梯停在2楼不动了，三块屏就都显示2。

你是不是觉得这样设计很蠢？每个楼层明明应该有自己的数字。对，Python这个行为就有点像那个“共用传感器”的设计。

常见的错误写法

这种错误不只出现在循环里。来看另一个场景：

def create_multipliers():
    multipliers = []
    for n in [1, 2, 3]:
        multipliers.append(lambda x: x * n)
    return multipliers

for m in create_multipliers():
    print(m(5))

你可能会以为输出：5, 10, 15。实际输出：15, 15, 15。

因为 n 最终变成了 3，三个 lambda 用的都是最后那个 n。

解决方案一：默认参数

最常见的修复方法：给函数加一个默认参数。

funcs = []
for i in range(3):
    def f(i=i):  # 注意这里
        print(i)
    funcs.append(f)

for f in funcs:
    f()  # 输出 0 1 2

为什么这样就可以了？因为 Python 的默认参数在函数定义时就会被求值。也就是说，当循环执行到 i=0 时，f(i=i) 里面的第二个 i 被立即计算成数字 0，然后作为默认值绑定到这个函数上。每个函数有了自己独立的默认值，不再依赖外部的变量 i。

解决方案二：functools.partial

如果你觉得默认参数写法有点“取巧”，可以用更明确的 partial：

from functools import partial

funcs = []
for i in range(3):
    def f(x):
        print(x)
    funcs.append(partial(f, i))

for f in funcs:
    f()

partial 就是提前把参数固定住，生成一个新函数。

解决方案三：再包一层函数

也可以再包一层函数来“冻结”当前的值：

funcs = []
for i in range(3):
    def outer(i):
        def inner():
            print(i)
        return inner
    funcs.append(outer(i))

for f in funcs:
    f()

当 outer(i) 被调用时，参数 i 的值被固定在这个局部作用域里。后面的闭包 inner 记住的是这个局部变量，不是循环里的那个 i。

为什么初学者特别容易踩这个坑？

因为很多其他语言在类似的场景下行为不同。比如 JavaScript（ES6 之前）也有类似问题，但如果你用 let 声明循环变量，每次迭代会创建一个新的绑定。

Python 的 for 循环不会为每次迭代创建新的作用域。循环里的变量就是同一个变量，反复被赋新值。而且 Python 的 lambda 和嵌套函数语法很简洁，让人觉得好像“随手一写就行”，结果正好踩坑。

更隐蔽的坑：修改外部变量

闭包默认只能读取外部变量。如果想修改，需要 nonlocal 关键字。

看这个例子：

def counter():
    count = 0
    def increment():
        count += 1  # 报错！
        return count
    return increment

c = counter()
c()

运行会报错：

UnboundLocalError: local variable 'count' referenced before assignment

因为 count += 1 相当于 count = count + 1，Python 在函数内部看到 count = 就会认为 count 是一个局部变量。但局部变量 count 还没来得及赋值就被引用了。

修复方法：

def counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

nonlocal 告诉 Python：“这个 count 不是我的局部变量，去外一层作用域找”。

闭包的内存陷阱

还有一个容易被忽略的点：闭包会一直持有外部变量，即使外部函数已经返回了。

看这个例子：

def outer():
    large_data = [0] * 10000000  # 一个大列表
    def inner():
        return len(large_data)
    return inner

func = outer()
# 此时 large_data 应该被销毁吗？并不会
# 因为 inner 还在引用它

large_data 不会被垃圾回收，只要 func 还存在。如果你不小心在循环里创建了一堆闭包，每个都引用了大对象，内存可能会暴涨。

实用的调试技巧

当你怀疑闭包变量出问题时，可以用 __closure__ 属性检查：

funcs = []
for i in range(3):
    def f():
        print(i)
    funcs.append(f)

for f in funcs:
    print(f.__closure__)

输出类似：

(,)
(,)
(,)

你可以进一步查看闭包里的值：

for f in funcs:
    print(f.__closure__[0].cell_contents)

输出：

2
2
2

果然，三个闭包引用的都是同一个 cell 对象，里面存着 2。这个工具在排查复杂闭包问题时非常有用。

再看一个经典面试题

很多 Python 面试会考这个：

def create_funcs():
    return [lambda x: x * i for i in range(5)]

for f in create_funcs():
    print(f(2))

输出是什么？

如果你读到这里，应该能立刻说出答案：

8
8
8
8
8

因为 i 最终是 4，2*4=8。

修复方法：

def create_funcs():
    return [lambda x, i=i: x * i for i in range(5)]

或者：

def create_funcs():
    return [lambda x, n=i: x * n for i in range(5)]

总结：记住这三句话就够了

1. 闭包捕获的是变量本身，不是变量的值。 变量变了，闭包看到的值也跟着变。
2. 默认参数在定义时求值。 想“冻结”当前值，就用默认参数。
3. 修改外部变量要加 nonlocal。 否则 Python 会当成本地变量处理。

这三点说起来简单，但每一条背后都有实际踩坑的故事。

回到开头那个让人加班的Bug。最后怎么解决的？用了默认参数，三行代码，一分钟改完。但为了搞清楚“为什么”，花了两小时。很多时候就是这样——改代码很快，真正花时间的是理解“原来我一直想错了”。

希望这篇文章能帮你省下那两小时。下次写闭包的时候，多问自己一句：“我捕获的是变量，还是变量的值？”想清楚这个问题，这个坑就再也坑不到你了。