python必背源代码闭包函数代码

一、闭包的三大构成要素与基本形式

在 Python 中，并不是所有嵌套函数都能被称为闭包。一个合法的闭包函数必须同时满足以下三个充要条件：

1. 必须包含嵌套函数结构：存在外层函数（Enclosing Function）和内层函数（Nested/Inner Function）。
2. 内层函数必须引用外层函数的变量：内层函数读取或修改了外层函数作用域内的局部变量，该变量既不是全局变量，也不是内层函数自己的局部变量，在规范中被称为自由变量（Free Variable）。
3. 外层函数必须将内层函数作为对象返回：返回的是函数对象本身（不带括号 return inner），而不是函数的执行结果（带有括号 return inner()）。

只有当这三个条件全部达成时，Python 解释器才会在生成字节码时为该函数绑定闭包环境（Cell 对象）。

二、三套核心必背源代码与逐行剖析

掌握闭包的核心不在于死记概念，而在于牢记能够解决具体生产问题的标准代码范式。以下三套代码覆盖了状态保持、参数固化和行为拦截三类最高频场景。

1. 必背代码一：私有状态累加计数器（状态持久化）

传统做法若要跨调用保持一个累加状态，往往必须使用全局变量（污染命名空间）或定义一个完整的类（语法冗长）。利用闭包，可以通过极轻量的代码实现状态私有化与持久化。

def make_counter(start=0):
    # count 是外层函数的局部变量，对 inner 而言是自由变量
    count = start

    def inner(step=1):
        # 必须显式声明 nonlocal，否则无法直接对不可变类型的自由变量执行重新赋值
        nonlocal count
        count += step
        return count

    # 返回函数对象本身，不执行
    return inner

# 使用示例
counter_a = make_counter(start=0)
counter_b = make_counter(start=100)

print(counter_a())       # 示例输出: 1
print(counter_a(step=2)) # 示例输出: 3
print(counter_b())       # 示例输出: 101 (独立维护自身状态，与 counter_a 互不干扰)

2. 必背代码二：函数配置生成器（参数偏特化与柯里化）

当某个多参数计算过程在特定业务场景下频繁复用相同基准值时，可以通过闭包提前将基准参数“固化”在函数体内，派生出更专业、更简短的专用工具函数。

def make_power(exponent):
    """根据传入的指数，生成专门计算该指数幂的单参数函数"""
    def power(base):
        return base ** exponent
    return power

# 派生专用的平方与立方计算函数
square = make_power(2)
cube = make_power(3)

print(square(5))  # 示例输出: 25 (5 的平方)
print(cube(3))    # 示例输出: 27 (3 的立方)

在此处，exponent 作为形参传入外层函数后，永久被内部的 power 函数捕获。调用 square(5) 时只需传入底数，显著精简了高频重复参数的传递。

3. 必背代码三：通用耗时测量闭包（Python 装饰器的底层原型）

Python 中的装饰器语法糖（@decorator）本质上就是把目标函数作为自由变量传入外层函数，并返回闭包封装后的增强函数。

import time

def measure_time(target_func):
    # target_func 被 inner 闭包持久持有
    def inner(*args, **kwargs):
        start_time = time.perf_counter()
        # 执行原目标函数并获取返回值
        result = target_func(*args, **kwargs)
        duration = time.perf_counter() - start_time
        print(f"[执行度量] 函数 {target_func.__name__} 耗时: {duration:.6f} 秒")
        return result
    return inner

# 模拟一个实际任务函数
def sample_task(n):
    return sum(i * i for i in range(n))

# 手动装配闭包（即 @measure_time 的脱糖形式）
timed_task = measure_time(sample_task)
output = timed_task(100000)
print("计算结果:", output)

三、深入底层：自由变量究竟保存在哪里？

在普通函数执行完毕后，其栈帧（Stack Frame）会立即弹出并销毁，局部变量随之释放。但在闭包中，为什么外部函数 make_counter 已经执行完毕退出，内部函数仍然能够随时读取并修改 count？

答案在于 Python 的 Cell 对象（PyCellObject）。当 Python 编译器发现某个局部变量被内部函数引用时，它不会把该变量仅仅存放在常规的运行时栈上，而是为其在堆内存中额外创建一个独立的 Cell 容器。

# 验证闭包的底层内部结构
c = make_counter(start=10)

# 1. 查看该函数捕获的自由变量名称列表
print("自由变量名称:", c.__code__.co_freevars)

# 2. 查看闭包元组 __closure__
print("闭包元组对象:", c.__closure__)

# 3. 提取 Cell 容器内存储的真实数据
print("当前自由变量的值:", c.__closure__[0].cell_contents)

# 执行一次累加后再次查看
c()
print("调用一次后自由变量的值:", c.__closure__[0].cell_contents)

内部函数对象的 __closure__ 属性是一个元组，里面包含了指向各个 Cell 对象的引用指针。外部函数栈退出后，由于内部函数仍然持有指向 Cell 的强引用，垃圾回收机制不会将其释放，从而保证了变量在堆内存中的持久存活。

四、高频生产事故：循环变量延迟绑定陷阱与修复

在开发过程中，最容易由于对闭包机制理解不透彻而导致 Bug 的场景是：在循环结构中创建闭包函数。

1. 典型错误示例：全部捕获最终值

def create_multipliers():
    funcs = []
    for i in range(3):
        # 错误写法：直接在闭包中使用循环变量 i
        funcs.append(lambda x: x * i)
    return funcs

fns = create_multipliers()
print([f(2) for f in fns])  # 预期输出 [0, 2, 4]，实际输出 [4, 4, 4]！

根本原因：闭包内部引用的自由变量是在真正调用执行时才去作用域链中寻址解析的（Late Binding，延迟绑定），而不是在函数定义时求值。当执行 f(2) 时，外层 for 循环早已经迭代完成，变量 i 的最终值固定为 2，导致所有闭包访问的都是同一个 i=2。

2. 两个标准修复方案

针对此问题，工程实践中有两种标准解决办法：

# 修复方案 A：利用函数默认参数在定义时刻求值的特性就地固化 (推荐，最简洁)
def fix_with_default_arg():
    return [lambda x, i=i: x * i for i in range(3)]

# 修复方案 B：增加一层闭包包裹，强制创建独立的栈帧与 Cell
def fix_with_nested_closure():
    def make_fn(val):
        return lambda x: x * val
    return [make_fn(i) for i in range(3)]

# 验证方案 A
print("方案 A 输出:", [f(2) for f in fix_with_default_arg()])
# 验证方案 B
print("方案 B 输出:", [f(2) for f in fix_with_nested_closure()])

五、工程选型：何时使用闭包？何时使用面向对象类？

闭包与只有一个方法的类（特别是重写了 __call__ 的类）在能力上高度重合。在编写 Python 代码时，应依据业务复杂度做出明晰的选择：

核心记忆口诀：
“外部包内部，内部调外部；外部返回内部，内部记状态；修改加 nonlocal，循环避延迟。”