Python闭包与装饰器：函数式编程核心技巧

1. 闭包与装饰器：Python函数式编程的进阶利器

第一次接触闭包这个概念时，我正试图给一个Web接口添加调用次数统计功能。当时我傻乎乎地用了全局变量来计数，结果在多线程环境下各种计数错乱。直到一位资深同事拍了拍我的肩膀："小伙子，该学学闭包了。"那一刻我才明白，原来Python函数还能这么玩！

闭包和装饰器是Python函数式编程中最迷人的两个特性。它们不仅能优雅地解决状态管理问题，更能让你的代码像乐高积木一样灵活组合。在Flask、Django等主流框架中，装饰器几乎无处不在。掌握它们，你就能读懂框架源码中那些"魔法"般的@符号背后的奥秘。

2. 闭包的三要素与实现原理

2.1 闭包的官方定义

闭包(Closure)在Python中是指：一个内部函数引用了外部函数的非全局变量，且该内部函数在外部函数作用域之外被调用时，仍然能够访问这些变量的函数对象及其关联的变量环境。

这个定义听起来有点绕，我们可以用现实生活中的例子来理解：想象你有一个带记忆功能的咖啡机（内部函数），它能记住你上次选择的咖啡浓度（外部变量）。即使你把它搬到另一个办公室（外部函数执行完毕），它依然保持着原来的设置。

2.2 闭包三要素详解

要创建一个合法的闭包，必须同时满足以下三个条件：

1. 函数嵌套结构：必须存在外层函数和内层函数的嵌套关系
2. 变量引用关系：内层函数必须引用外层函数的非全局变量
3. 函数返回机制：外层函数需要将内层函数作为返回值返回

python复制def outer_func():  # 外层函数
    cache = {}  # 非全局变量
    
    def inner_func(key, value):  # 内层函数
        cache[key] = value  # 引用外层变量
        return cache
    
    return inner_func  # 返回内层函数

closure = outer_func()  # 获取闭包
print(closure('name', 'Alice'))  # {'name': 'Alice'}

2.3 闭包的底层实现

Python通过__closure__属性来标识闭包。这是一个包含cell对象的元组，每个cell对象保存着闭包引用的外部变量：

python复制def make_counter():
    count = 0
    
    def counter():
        nonlocal count
        count += 1
        return count
    
    return counter

cnt = make_counter()
print(cnt.__closure__)  # (<cell at 0x...: int object at 0x...>,)
print(cnt.__closure__[0].cell_contents)  # 0

注意：如果没有引用外部变量，__closure__将是None。这是判断一个函数是否是闭包的重要依据。

3. 闭包的实战应用场景

3.1 轻量级状态管理

闭包最典型的应用就是实现有状态的函数。相比类，闭包提供了更轻量级的方案：

python复制def create_cache():
    cached_data = {}
    
    def get_cache(key):
        return cached_data.get(key)
    
    def set_cache(key, value):
        cached_data[key] = value
        
    return get_cache, set_cache

getter, setter = create_cache()
setter('config', {'debug': True})
print(getter('config'))  # {'debug': True}

3.2 函数工厂模式

闭包可以动态生成具有不同行为的函数：

python复制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.3 回调函数保持状态

在事件驱动编程中，闭包可以让回调函数记住创建时的上下文：

python复制def create_handler(prefix):
    def handle_message(message):
        print(f"[{prefix}] {message}")
    return handle_message

error_handler = create_handler("ERROR")
warning_handler = create_handler("WARNING")

error_handler("Disk full!")     # [ERROR] Disk full!
warning_handler("Low memory!")  # [WARNING] Low memory!

4. 闭包常见问题与解决方案

4.1 nonlocal关键字的使用

当内层函数需要修改外层变量时，必须使用nonlocal声明：

python复制def counter():
    num = 0
    
    def increment():
        nonlocal num  # 必须声明
        num += 1
        return num
    
    return increment

如果不加nonlocal，Python会认为你在创建一个新的局部变量，导致UnboundLocalError。

4.2 延迟绑定问题

在循环中创建闭包时，所有闭包会共享同一个变量引用：

python复制functions = []
for i in range(3):
    def func():
        return i
    functions.append(func)

print([f() for f in functions])  # [2, 2, 2] 不是预期的[0,1,2]

解决方案是使用默认参数或functools.partial：

python复制# 方法1：默认参数
functions = []
for i in range(3):
    def func(i=i):  # 创建新的作用域
        return i
    functions.append(func)

# 方法2：使用partial
from functools import partial
functions = [partial(lambda x: x, i) for i in range(3)]

4.3 内存泄漏风险

闭包会保持对外部变量的引用，可能导致意外内存占用：

python复制def create_huge_closure():
    big_data = [0] * 10_000_000  # 大对象
    
    def closure():
        return len(big_data)
    
    return closure

# big_data会一直存在，直到closure被销毁

解决方案是及时清理不再需要的闭包，或使用弱引用(weakref)。

5. 装饰器：闭包的语法糖

5.1 从闭包到装饰器

装饰器本质上是一个接受函数作为参数并返回函数的闭包：

python复制def logger(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@logger  # 语法糖
def greet(name):
    return f"Hello, {name}"

# 等价于 greet = logger(greet)

5.2 保留元信息

直接使用装饰器会覆盖原函数的元信息，需要使用functools.wraps：

python复制from functools import wraps

def timer(func):
    @wraps(func)  # 保留原函数信息
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"Time: {time.time()-start:.2f}s")
        return result
    return wrapper

5.3 带参数的装饰器

通过三层嵌套实现可配置的装饰器：

python复制def repeat(times):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(times=3)
def say_hello():
    print("Hello!")

say_hello()  # 打印3次Hello!

6. 实战：开发常用装饰器

6.1 异常捕获装饰器

python复制def catch_exception(logger=None):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except Exception as e:
                if logger:
                    logger.error(f"{func.__name__} failed: {str(e)}")
                return None
        return wrapper
    return decorator

@catch_exception(logger=print)
def risky_operation():
    raise ValueError("Something went wrong")

6.2 性能计时装饰器

python复制import time
from functools import wraps

def timeit(print_args=False):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            start = time.perf_counter()
            result = func(*args, **kwargs)
            elapsed = time.perf_counter() - start
            
            if print_args:
                arg_str = ', '.join(map(str, args))
                print(f"{func.__name__}({arg_str}): {elapsed:.6f}s")
            else:
                print(f"{func.__name__}: {elapsed:.6f}s")
                
            return result
        return wrapper
    return decorator

6.3 权限校验装饰器

python复制def require_role(role):
    def decorator(func):
        @wraps(func)
        def wrapper(user, *args, **kwargs):
            if user.get('role') != role:
                raise PermissionError(f"Requires {role} role")
            return func(user, *args, **kwargs)
        return wrapper
    return decorator

@require_role('admin')
def delete_user(user, user_id):
    print(f"User {user_id} deleted by {user['name']}")

7. Python内置装饰器

7.1 @staticmethod

静态方法装饰器，方法不需要访问实例或类属性：

python复制class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

7.2 @classmethod

类方法装饰器，第一个参数是类本身(cls)：

python复制class Person:
    def __init__(self, name):
        self.name = name
        
    @classmethod
    def from_json(cls, json_data):
        return cls(json_data['name'])

7.3 @property

属性装饰器，将方法转为属性访问：

python复制class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def radius(self):
        return self._radius
    
    @radius.setter
    def radius(self, value):
        if value <= 0:
            raise ValueError("Radius must be positive")
        self._radius = value

8. 装饰器的高级技巧

8.1 多个装饰器叠加

装饰器从下往上执行：

python复制@timer
@catch_exception
def process_data(data):
    # 数据处理逻辑
    pass

8.2 装饰器类实现

通过实现__call__方法，类也可以作为装饰器：

python复制class Retry:
    def __init__(self, max_retries=3):
        self.max_retries = max_retries
    
    def __call__(self, func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(self.max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception:
                    if attempt == self.max_retries - 1:
                        raise
        return wrapper

@Retry(max_retries=5)
def unreliable_api_call():
    # 可能失败的API调用
    pass

8.3 装饰器状态保持

装饰器本身也可以使用闭包保持状态：

python复制def call_counter(func):
    count = 0
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        nonlocal count
        count += 1
        print(f"{func.__name__} called {count} times")
        return func(*args, **kwargs)
    
    return wrapper

9. 实际项目中的应用建议

1. 保持装饰器简单：每个装饰器应该只做一件事
2. 谨慎使用装饰器堆叠：过多的装饰器会降低代码可读性
3. 注意执行顺序：装饰器从下往上执行，但实际调用时是从上往下
4. 性能考量：高频调用的函数要避免重量级装饰器
5. 文档记录：为自定义装饰器编写清晰的文档字符串

在我参与的一个Web项目中，我们使用装饰器统一处理了身份验证、日志记录、性能监控等横切关注点。这不仅减少了代码重复，还使得业务逻辑更加清晰。例如：

python复制@require_login
@log_operation
@validate_input(schema=user_schema)
def update_profile(user_id, data):
    # 纯净的业务逻辑
    pass

记住，装饰器就像调味料 - 适量使用能提升代码的味道，但过量就会破坏整体风味。当你的装饰器逻辑变得复杂时，可能是时候考虑重构为显式的函数调用了。