一文搞懂Python闭包函数

原创已于 2025-08-20 09:17:27 修改 · 390 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#python #开发语言 #学习 #笔记

于 2025-03-31 11:20:06 首次发布

python编程专栏收录该内容

80 篇文章

订阅专栏

闭包(Closure)是Python中一种特殊的函数对象，它可以记住并访问定义它的作用域中的变量，即使该作用域已经执行完毕。闭包是函数式编程的重要概念，在Python中有着广泛的应用。

一、闭包的基本概念

1.1 什么是闭包

闭包是指一个函数及其相关的引用环境的组合。具体来说：

函数内部定义了另一个函数（嵌套函数）
内部函数引用了外部函数的变量
外部函数返回内部函数

1.2 闭包的三要素

嵌套函数
内部函数引用外部函数的变量
外部函数返回内部函数

二、闭包的基本示例

2.1 简单闭包

def outer_func(x):
    def inner_func(y):
        return x + y
    return inner_func

closure = outer_func(10)  # x被"记住"为10
print(closure(5))  # 15
print(closure(10))  # 20

2.2 闭包的状态保持

def counter():
    count = 0
    
    def increment():
        nonlocal count
        count += 1
        return count
    
    return increment

my_counter = counter()
print(my_counter())  # 1
print(my_counter())  # 2
print(my_counter())  # 3

三、闭包的高级特性

3.1 闭包与变量作用域

闭包可以访问多个外部变量：

def power_factory(exponent):
    def power(base):
        return base ** exponent
    return power

square = power_factory(2)
cube = power_factory(3)

print(square(5))  # 25
print(cube(5))    # 125

3.2 闭包与延迟计算

def lazy_sum(a, b):
    def real_sum():
        return a + b
    return real_sum

sum_func = lazy_sum(10, 20)
print(sum_func())  # 30 (实际计算发生在调用时)

3.3 闭包与可变对象

def accumulator():
    data = []
    
    def add(item):
        data.append(item)
        return sum(data)
    
    return add

acc = accumulator()
print(acc(10))  # 10
print(acc(20))  # 30
print(acc(30))  # 60

四、闭包的实际应用

4.1 装饰器实现

def logger(func):
    def wrapper(*args, **kwargs):
        print(f"调用函数: {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@logger
def add(a, b):
    return a + b

print(add(3, 5))
# 输出:
# 调用函数: add
# 8

4.2 配置预设

def make_adder(add_value):
    def adder(number):
        return number + add_value
    return adder

add5 = make_adder(5)
add10 = make_adder(10)

print(add5(3))   # 8
print(add10(3))  # 13

4.3 回调函数

def event_handler(callback):
    def wrapper(event):
        print(f"处理事件: {event}")
        return callback(event)
    return wrapper

def my_callback(event):
    print(f"自定义处理: {event}")

handler = event_handler(my_callback)
handler("click")  # 处理事件: click \n 自定义处理: click

五、闭包的内部原理

5.1 `closure`属性

闭包函数有一个__closure__属性，它包含引用的外部变量：

def outer(x):
    def inner():
        return x
    return inner

closure = outer(10)
print(closure.__closure__)  # (<cell at 0x..., int object at 0x...>,)
print(closure.__closure__[0].cell_contents)  # 10

5.2 变量绑定机制

闭包引用的变量是延迟绑定的
变量值是在内部函数被调用时查找的

def create_multipliers():
    return [lambda x : i * x for i in range(5)]

for multiplier in create_multipliers():
    print(multiplier(2))  # 全部输出8 (不是预期的0,2,4,6,8)

修正方案：

def create_multipliers():
    return [lambda x, i=i : i * x for i in range(5)]

六、闭包的注意事项

6.1 变量捕获问题

def create_funcs():
    funcs = []
    for i in range(3):
        def func():
            return i
        funcs.append(func)
    return funcs

f1, f2, f3 = create_funcs()
print(f1(), f2(), f3())  # 全部输出2 (不是预期的0,1,2)

解决方案：

def create_funcs():
    funcs = []
    for i in range(3):
        def func(i=i):  # 使用默认参数捕获当前值
            return i
        funcs.append(func)
    return funcs

6.2 内存泄漏风险

闭包会保持对外部变量的引用，可能导致内存无法释放：

def outer():
    big_data = [...]  # 大数据
    def inner():
        return len(big_data)
    return inner

closure = outer()  # big_data不会被释放

解决方案：

def outer():
    big_data = [...]
    def inner():
        length = len(big_data)
        del big_data  # 显式删除引用
        return length
    return inner

七、闭包与类的比较

特性	闭包	类
状态保持	通过捕获变量	通过实例属性
封装性	较好	更好
可扩展性	有限	强
适用场景	简单状态管理	复杂状态管理
性能	略优	略差
可读性	简单场景好	复杂场景好