Python 闭包是指一个嵌套函数，它能够记住并访问其外部函数作用域中的变量，即使外部函数已经执行完毕 。其核心价值在于封装数据与行为，实现状态的持久化。
一、闭包的核心构成与创建
一个典型的闭包需要满足三个条件：
- 存在嵌套函数（内部函数定义在外部函数内）。
- 内部函数引用了外部函数的变量（自由变量）。
- 外部函数返回内部函数（或对内部函数的引用）。
def outer_func(msg): # 外部函数 message = msg # 外部函数的局部变量（自由变量） def inner_func(): # 内部函数（闭包） print(f"Message: {message}") # 引用了外部变量 `message` return inner_func # 返回内部函数 # 创建闭包my_closure = outer_func("Hello, Closure!") # 此时 outer_func 已执行完毕，但其变量 `message` 仍可被访问 my_closure() # 输出：Message: Hello, Closure!二、闭包的核心用法详解
1. 状态保持与数据封装
闭包最常见的用途是创建一个有“记忆”的函数，用于维护私有状态。
def make_counter(): count = 0 # 私有状态变量 def counter(): nonlocal count # 声明使用外部函数的变量 count += 1 return count return counter # 创建两个独立的计数器，各自维护独立的状态 counter_a = make_counter() counter_b = make_counter() print(counter_a()) # 输出：1 print(counter_a()) # 输出：2 print(counter_b()) # 输出：1 (状态独立) print(counter_a()) # 输出：32. 函数工厂（动态生成函数）
闭包可以根据不同的参数，动态生成功能相似但配置不同的函数。
def power_factory(exponent): """创建一个计算指定次幂的函数""" def power(base): return base ** exponent return power # 创建平方和立方计算函数 square = power_factory(2) cube = power_factory(3) print(square(5)) # 输出：25 (5^2) print(cube(5)) # 输出：125 (5^3) print(square(3)) # 输出：9 (3^2)3. 实现装饰器（Decorator）
装饰器是闭包最经典的应用之一，它允许在不修改原函数代码的情况下，为其添加额外功能 。
def logger(func): """一个记录函数执行日志的装饰器""" def wrapper(*args, **kwargs): print(f"[LOG] 开始执行函数: {func.__name__}") result = func(*args, **kwargs) print(f"[LOG] 函数 {func.__name__} 执行完毕") return result return wrapper @logger def add(a, b): return a + b @logger def greet(name): return f"Hello, {name}!" print(add(10, 20)) # 输出： # [LOG] 开始执行函数: add # [LOG] 函数 add 执行完毕 # 30 print(greet("Alice")) # 输出： # [LOG] 开始执行函数: greet # [LOG] 函数 greet 执行完毕 # Hello, Alice!4. 回调函数与事件处理
闭包可以捕获创建时的上下文，非常适合用于回调函数，将数据与行为绑定在一起。
def create_button_click_handler(button_id): """为不同按钮创建点击事件处理器""" def click_handler(event): print(f"按钮 {button_id} 被点击了！事件: {event}") # 这里可以访问创建时传入的 button_id return click_handler # 模拟为不同按钮绑定事件处理器 btn1_click = create_button_click_handler("btn_submit") btn2_click = create_button_click_handler("btn_cancel") # 模拟事件触发 btn1_click("mouse_click") # 输出：按钮 btn_submit 被点击了！事件: mouse_click btn2_click("key_press") # 输出：按钮 btn_cancel 被点击了！事件: key_press5. 实现简单的对象系统
在面向对象编程之前，闭包可用于模拟具有私有属性的对象。
def create_person(name, age): """使用闭包创建一个‘人’对象""" def get_info(): return f"Name: {name}, Age: {age}" def have_birthday(): nonlocal age age += 1 return f"Happy Birthday! Now {name} is {age} years old." # 返回一个包含多个方法的字典，模拟对象接口 return { 'get_info': get_info, 'have_birthday': have_birthday } # 创建两个‘人’ alice = create_person("Alice", 25) bob = create_person("Bob", 30) print(alice['get_info']()) # 输出：Name: Alice, Age: 25 print(bob['get_info']()) # 输出：Name: Bob, Age: 30 print(alice['have_birthday']()) # 输出：Happy Birthday! Now Alice is 26 years old. print(alice['get_info']()) # 输出：Name: Alice, Age: 26 (状态已更新)三、高级用法与技巧
1. 带参数的装饰器（多层闭包）
通过多层嵌套，可以创建接收参数的装饰器，提供更大的灵活性 。
def repeat(times): """重复执行指定次数的装饰器工厂""" def decorator(func): def wrapper(*args, **kwargs): results = [] for i in range(times): print(f"第 {i+1} 次执行") result = func(*args, **kwargs) results.append(result) return results return wrapper return decorator @repeat(times=3) def say_hello(name): return f"Hello, {name}!" print(say_hello("World")) # 输出： # 第 1 次执行 # 第 2 次执行 # 第 3 次执行 # ['Hello, World!', 'Hello, World!', 'Hello, World!']2. 使用__closure__属性查看闭包信息
Python 为闭包函数提供了__closure__属性，可以查看其捕获的外部变量。
def outer(x): y = 10 def inner(): return x + y return inner closure_func = outer(5) print(closure_func()) # 输出：15 # 查看闭包捕获的变量 if closure_func.__closure__: for i, cell in enumerate(closure_func.__closure__): print(f"Cell {i}: {cell.cell_contents}") # 输出： # Cell 0: 5 # Cell 1: 103. 闭包与 lambda 表达式结合
lambda 表达式也可以创建闭包，常用于创建简洁的回调或小型函数工厂。
def make_multiplier(n): return lambda x: x * n # lambda 表达式也是一个闭包 double = make_multiplier(2) triple = make_multiplier(3) print(double(7)) # 输出：14 print(triple(7)) # 输出：21四、注意事项与常见问题
| 问题 | 描述与解决方案 |
|---|---|
| 变量绑定时机 | 闭包捕获的是变量的引用，而非创建时的值。如果外部变量在闭包创建后发生改变，闭包内访问的将是最终值。使用默认参数可以“冻结”创建时的值。 |
nonlocal关键字 | 在 Python 3 中，若需在闭包内修改外部函数的变量，必须使用nonlocal声明，否则会视为创建新的局部变量 。 |
| 内存泄漏风险 | 闭包会延长外部函数变量的生命周期。如果闭包长期存在，其捕获的所有变量都无法被垃圾回收。 |
| 调试复杂性 | 过度使用闭包可能使代码流程难以跟踪，尤其是多层嵌套时。 |
变量绑定时机示例：
def create_functions(): funcs = [] for i in range(3): # 错误写法：所有闭包都引用循环结束后的最终 i 值 (2) # def func(): # return i # 正确写法：使用默认参数捕获当前 i 值 def func(num=i): return num funcs.append(func) return funcs func_list = create_functions() print([f() for f in func_list]) # 输出：[0, 1, 2] (正确) # 若使用错误写法，输出将是 [2, 2, 2]五、闭包与装饰器的关系总结
装饰器本质上是一种语法糖，它基于闭包实现。@decorator等价于func = decorator(func)，其核心是闭包对原函数的包装与扩展 。闭包为装饰器提供了保存被装饰函数引用和附加状态的能力，是 Python 元编程的重要基石。
参考来源
- python 闭包的用法
- python中闭包函数的应用以及用法
- python中闭包函数_Python函数中的函数(闭包)用法实例
- Python中的闭包用法实例详解
- Python装饰器与闭包的高级用法
)
