Python闭包：解锁函数式编程的隐藏力量

——从入门到精通，10个经典场景带你玩转闭包！

内容摘要

本文包括两个部分：

基础速递：浓缩的Python闭包知识点。
经典示例：10 个闭包应用范例。

一、基础速递

1. 什么是Python的闭包？

闭包（Closure）是指在一个函数内部定义的函数，并且这个内部函数引用了外部函数的变量。闭包允许内部函数在外部函数执行完毕后，仍然可以访问和操作外部函数的局部变量。

2. 闭包的作用

数据封装：闭包可以用于封装数据，避免使用全局变量。
保持状态：闭包可以在函数调用之间保持状态，类似于类的实例变量。
函数工厂：闭包可以用于创建定制化的函数。

3. 代码示例

def outer_function(x):def inner_function(y):return x + yreturn inner_function# 创建一个闭包
closure = outer_function(10)# 调用闭包
result = closure(5)
print(result)  # 输出 15

解释

outer_function：这是一个外部函数，接受一个参数 x。
inner_function：这是一个内部函数，接受一个参数 y，并返回 x + y。
closure = outer_function(10)：调用 outer_function 并传入 10，返回 inner_function，此时 x 被设置为 10。
closure(5)：调用 inner_function 并传入 5，返回 10 + 5，即 15。

4. 另一个示例：计数器

def counter():count = 0def increment():nonlocal countcount += 1return countreturn increment# 创建一个闭包
counter1 = counter()# 调用闭包
print(counter1())  # 输出 1
print(counter1())  # 输出 2
print(counter1())  # 输出 3

解释

counter：这是一个外部函数，初始化一个变量 count 为 0。
increment：这是一个内部函数，每次调用时增加 count 的值并返回。
counter1 = counter()：调用 counter 函数，返回 increment 函数，此时 count 被初始化为 0。
counter1()：每次调用 counter1 时，count 的值都会增加并返回。

5. 小结

闭包是Python中一个强大的特性，允许函数在调用之间保持状态，并且可以用于创建定制化的函数。通过闭包，可以实现数据封装和状态保持，避免使用全局变量。

二、经典示例

以下是关于闭包的 10 个经典应用场景，每个场景都附有完整代码、解释、测试案例和执行结果。

1. 累加器

闭包可以用来实现一个累加器，每次调用时进行累加。

def create_accumulator():total = 0  # 内部状态，用于存储累加结果def accumulator(value):nonlocal total  # 声明使用外部函数的变量total += value  # 累加值return total    # 返回当前累加结果return accumulator  # 返回内部函数# 测试案例
acc = create_accumulator()  # 创建累计器# 测试1：初始累加
print(acc(10))  # 输出: 10
print(acc(20))  # 输出: 30
print(acc(30))  # 输出: 60

2. 函数工厂

闭包可以用于创建定制化的函数。

def power_factory(exponent):def power(base):return base ** exponentreturn power# 测试
square = power_factory(2)
cube = power_factory(3)
print(square(4))  # 输出: 16
print(cube(3))    # 输出: 27

3. 缓存（Memoization）

闭包可以用于实现缓存功能，避免重复计算。

def memoize(func):cache = {}def wrapper(*args):if args not in cache:cache[args] = func(*args)return cache[args]return wrapper# 测试
@memoize
def fibonacci(n):if n <= 1:return nreturn fibonacci(n-1) + fibonacci(n-2)print(fibonacci(10))  # 输出: 55

4. 事件处理器

闭包可以用于创建动态的事件处理器。

def create_event_handler(message):def event_handler():print(message)return event_handler# 测试
handler1 = create_event_handler("Button 1 clicked!")
handler2 = create_event_handler("Button 2 clicked!")
handler1()  # 输出: Button 1 clicked!
handler2()  # 输出: Button 2 clicked!

5. 私有变量

闭包可以模拟私有变量，避免直接访问。

def private_variable(initial_value):value = initial_valuedef getter():return valuedef setter(new_value):nonlocal valuevalue = new_valuereturn getter, setter# 测试
get_value, set_value = private_variable(10)
print(get_value())  # 输出: 10
set_value(20)
print(get_value())  # 输出: 20

6. 延迟计算

闭包可以用于延迟计算，直到需要时才执行。

def lazy_computation(func):def wrapper():return func()return wrapper# 测试
def expensive_operation():print("Performing expensive operation...")return 42lazy_value = lazy_computation(expensive_operation)
print("Lazy value created, but not computed yet.")
print(lazy_value())  # 输出: Performing expensive operation... 42

7. 装饰器

闭包是实现装饰器的基础。

def logger(func):def wrapper(*args, **kwargs):print(f"Calling {func.__name__} with {args}, {kwargs}")result = func(*args, **kwargs)print(f"{func.__name__} returned {result}")return resultreturn wrapper# 测试
@logger
def add(a, b):return a + bprint(add(3, 5))  # 输出: Calling add with (3, 5), {} \n add returned 8 \n 8

8. 状态机

闭包可以用于实现简单的状态机。

def state_machine(initial_state):state = initial_statedef transition(new_state):nonlocal statestate = new_statedef current_state():return statereturn transition, current_state# 测试
transition, current_state = state_machine("off")
print(current_state())  # 输出: off
transition("on")
print(current_state())  # 输出: on

9. 回调函数

闭包可以用于创建动态的回调函数。

def create_callback(message):def callback():print(message)return callback# 测试
callback1 = create_callback("Task 1 completed!")
callback2 = create_callback("Task 2 completed!")
callback1()  # 输出: Task 1 completed!
callback2()  # 输出: Task 2 completed!

10. 配置函数

闭包可以用于创建配置化的函数。

def configure_multiplier(factor):def multiplier(x):return x * factorreturn multiplier# 测试
double = configure_multiplier(2)
triple = configure_multiplier(3)
print(double(5))  # 输出: 10
print(triple(5))  # 输出: 15