Python 闭包是指一个嵌套函数，它能够记住并访问其外部函数作用域中的变量，即使外部函数已经执行完毕 。其核心价值在于封装数据与行为，实现状态的持久化。

一、闭包的核心构成与创建

一个典型的闭包需要满足三个条件：

1. 存在嵌套函数（内部函数定义在外部函数内）。
2. 内部函数引用了外部函数的变量（自由变量）。
3. 外部函数返回内部函数（或对内部函数的引用）。

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())  # 输出：3

2. 函数工厂（动态生成函数）

闭包可以根据不同的参数，动态生成功能相似但配置不同的函数。

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_press

5. 实现简单的对象系统

在面向对象编程之前，闭包可用于模拟具有私有属性的对象。

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: 10

3. 闭包与 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装饰器与闭包的高级用法