Python循环中内部函数为何总是获取变量最终值

一、典型现象与问题复现

很多开发者在编写回调函数、动态生成过滤器或构建并发任务时，都会写出类似如下的代码：

funcs = []
for i in range(5):
    funcs.append(lambda: i)

# 依次执行所有函数
results = [f() for f in funcs]
print(results)
# 预期结果：[0, 1, 2, 3, 4]
# 实际输出：[4, 4, 4, 4, 4]

初学者通常会直觉地认为，在 i = 0 时定义的函数会“记住” 0，在 i = 1 时定义的函数会“记住” 1。然而实际执行时，所有函数都整齐划一地返回了循环终止时的最终值 4。

要理解这个结果，首先要区分 Python 中代码执行的两个不同时期：函数定义期（Definition Time）与函数调用期（Invocation Time）。

二、为什么不会自动捕获快照：底层机制剖析

很多语言（如早期的 Java 匿名内部类）强制要求引用的外部变量必须为 final，以此杜绝引用歧义；而在现代 C++ 的 lambda 中，开发者可以通过 [=] 显式指定值拷贝，或通过 [&] 指定引用捕获。但 Python 采用了截然不同的设计哲学：变量只是对对象的引用，闭包绑定的是变量名（作用域槽位），而非特定时刻的值。

1. Python 的循环没有块级作用域

在 C、C++ 或 Java 等语言中，for (int i = 0; ...) 代码块内部拥有独立的块级作用域，每一次迭代在某种意义上都可以生成局部绑定。但在 Python 中，for 循环并不会引入新的作用域。

循环变量 i 与包含该循环的函数（或模块全局作用域）处于完全相同的命名空间中。当循环推进时，并不是在销毁并重建 i，而是将同一个名字 i 一遍又一遍地重新绑定到新的数字对象上。

2. 闭包与 Cell 对象的共享机制

当 Python 编译器发现一个内部函数引用了外层函数的局部变量（或自由变量）时，会为此变量生成一个特殊的存储载体——cell 对象。

我们可以通过 Python 提供的内建反射属性 __closure__，亲自验证底层对象的地址分布：

funcs = [lambda: i for i in range(5)]

# 查看每个函数的 __closure__
for idx, f in enumerate(funcs):
    cell = f.__closure__[0]
    print(f"func[{idx}] closure cell id: {id(cell)}, value: {cell.cell_contents}")

在终端运行上述代码，示例输出如下：

func[0] closure cell id: 4382914192, value: 4
func[1] closure cell id: 4382914192, value: 4
func[2] closure cell id: 4382914192, value: 4
func[3] closure cell id: 4382914192, value: 4
func[4] closure cell id: 4382914192, value: 4

注意看这里的内存 ID：所有 5 个内部函数的闭包 cell 对象地址完全相同（4382914192）。它们共享同一个 Cell 容器，而 Cell 内部的 cell_contents 最终指向了数字对象 4。

3. 字节码层面的证据：LOAD_DEREF 指令

通过 Python 自带的 dis 模块反编译 lambda: i 的字节码，我们可以直接看到指令级别的动作：

import dis

f = funcs[0]
dis.dis(f)

输出指令如下：

  2           0 LOAD_DEREF               0 (i)
              2 RETURN_VALUE

指令 LOAD_DEREF 的含义非常明确：从当前函数的闭包单元（cell/freevars 槽位 0）中解引用并载入变量。注意，这里载入的不是任何常数常量（即不是 LOAD_CONST），而是通过闭包指针现场拉取数据。因此，只要读取发生在外层循环结束后，取得的就必然是外层变量最终保留的数值。

三、四种实用的解决方案与实现对比

为了让每个内部函数在创建时就能牢固锁定当前的循环迭代值，我们必须切断它们对同一个共享 Cell 变量的依赖。以下是 Python 生态中最常用且经过验证的四种解法：

方法一：利用函数默认参数（最简捷的内联写法）

Python 中函数的默认参数是在函数定义期（def 或 lambda 解析时）进行一次性求值并存入函数的 __defaults__ 元组中的。我们可以利用这一特性，将外部循环变量传递给默认参数：

funcs = [lambda val=i: val for i in range(5)]

# 验证结果
print([f() for f in funcs])
# 输出: [0, 1, 2, 3, 4]

此时，函数内部执行的指令变成了 LOAD_FAST 0 (val)（访问局部参数），而不是 LOAD_DEREF；每个函数对象的 __defaults__ 中分别固定存储了对应轮次的 (0,)、(1,) 等整型常量。

方法二：外层包装工厂函数（结构清晰，隔离作用域）

编写一个普通函数作为工厂，在工厂函数内返回目标函数。因为每次调用工厂函数时，Python 都会在调用栈上为该工厂分配全新的局部命名空间与独立的 Cell 容器：

def make_handler(x):
    return lambda: x

funcs = [make_handler(i) for i in range(5)]

print([f() for f in funcs])
# 输出: [0, 1, 2, 3, 4]

每个 make_handler(i) 产出的内部函数都绑定了一个专属于该次调用的 Cell 对象，彼此互不干扰。这种方式语义明确，不会向返回的函数污染额外形参。

方法三：使用标准库 functools.partial（工业级偏函数绑定）

标准库 functools.partial 专门用于参数预绑定。它在 C 层面封装目标可调用对象与固定的实参位置：

from functools import partial

def compute(x):
    return x

funcs = [partial(compute, i) for i in range(5)]

print([f() for f in funcs])
# 输出: [0, 1, 2, 3, 4]

partial 对象在创建时刻立即解构并锁定 i 的当前对象引用，同时具备出色的执行效率和显式的方法签名，是构建回调系统和事件驱动代码的首选标准方案。

方法四：自调用即时函数闭包（IIFE 模式）

类似于前端 JavaScript 中早期的立即执行函数表达式（IIFE），在 Python 中也可以使用单行 (lambda x: lambda: x)(i) 快速隔离：

funcs = [(lambda x: lambda: x)(i) for i in range(5)]

print([f() for f in funcs])
# 输出: [0, 1, 2, 3, 4]

该方法虽然避免了显式定义外部工厂函数，但在代码可读性上有明显欠缺，通常不推荐在团队合作项目或核心业务中大面积使用。

四、技术方案横向对照与工程选型建议

在实际项目维护中，选择哪种解法不仅关乎代码是否能运行，还直接影响到接口设计、团队协同与维护成本。下表汇总了四种方案的关键属性：

五、排查与选型决策指南

当在存量代码中排查“函数执行结果总是一模一样”的异常，或者在重构新建代码时，建议遵照以下决策流程进行校验：

六、总结

理解“Python 循环中内部函数为何总是获取变量最终值”，关键在于掌握以下三点：

1. 作用域与生命周期：Python 的 for 循环不创建块作用域，循环变量驻留在当前函数的局部变量空间或全局空间中。
2. 延迟绑定本质：函数定义只编译执行指令并不固化自由变量；内部函数通过唯一的 cell 对象引用外部变量名，直到调用时才去获取该变量当前的真实值。
3. 固化手段选择：解决延迟绑定核心是“将变量值提早固化到独立作用域”。若追求简洁可使用默认参数 arg=i，若追求代码规范与工程维护性，则应优先采用 functools.partial 或独立的外层工厂函数。