Python闭包是一种强大而精巧的函数式编程技巧，通过函数嵌套、引用外部局部变量并返回内部函数，使函数能“记住”定义时的环境，实现轻量级的状态封装与行为定制；它不仅可优雅替代简单类（如计数器）、构建灵活装饰器（如带参数的重试机制），还广泛用于配置化函数生成，但需警惕延迟绑定等常见陷阱——掌握闭包，是写出简洁、可复用且富有表现力Python代码的关键一步。

Python闭包的核心在于：内部函数引用了外部函数的局部变量，并且外部函数返回了这个内部函数。它让函数能“记住”自己被定义时的环境，实现轻量级的状态封装。

闭包的基本写法与判断要点

一个函数要构成闭包，必须同时满足三个条件：

• 存在函数嵌套（内部函数定义在外部函数内部）
• 内部函数使用了外部函数的局部变量（非全局变量）
• 外部函数返回了内部函数（注意：不是调用结果，是函数对象本身）

例如：

def make_adder(n):
    def add(x):
        return x + n  # 引用了外部变量 n
    return add  # 返回函数，不是 add(x)
plus_5 = make_adder(5)
print(plus_5(3))  # 输出 8

利用闭包保存状态，替代类的简单场景

当只需要维护少量、单一维度的状态（比如计数器、偏移量、配置参数），闭包比定义类更简洁直观。

比如实现一个自增计数器：

def counter():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc
c = counter()
print(c())  # 1
print(c())  # 2

这里 nonlocal 是关键——它告诉 Python，count 不是局部变量，而是外层函数的变量，允许内部函数修改它。

闭包常见陷阱：延迟绑定问题

初学者容易遇到的问题：多个闭包共享同一个外部变量，而该变量在循环中被反复赋值，导致所有闭包最终“记住”的是最后一次值。

错误写法：

funcs = []
for i in range(3):
    funcs.append(lambda: i)  # 全部引用同一个 i
print([f() for f in funcs])  # [2, 2, 2]

修复方式：用默认参数立即绑定当前值：

funcs = []
for i in range(3):
    funcs.append(lambda x=i: x)  # x=i 在定义时就固定了 i 的当前值
print([f() for f in funcs])  # [0, 1, 2]

或改用闭包函数封装：

def make_func(x):
    return lambda: x
funcs = [make_func(i) for i in range(3)]

实际应用：装饰器与配置化函数生成

装饰器本质就是闭包。比如写一个带参数的重试装饰器：

def retry(max_attempts=3):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for i in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception:
                    if i == max_attempts - 1:
                        raise
            return None
        return wrapper
    return decorator
@retry(max_attempts=2)
def fetch_data():
模拟可能失败的操作
pass

这里的 retry 接收配置，返回装饰器函数；装饰器再接收目标函数，返回包装后的函数——三层嵌套，典型闭包链，每一层都保持了上一层的参数状态。

以上就是《Python闭包技巧：函数嵌套与状态保持解析》的详细内容，更多关于的资料请关注golang学习网公众号！