1. 闭包与装饰器：Python中的魔法工具

第一次听说闭包和装饰器时，我完全被这些概念绕晕了。直到在实际项目中反复使用它们，才真正理解这两个Python特性的强大之处。闭包和装饰器就像Python开发者的瑞士军刀，能让你写出更优雅、更高效的代码。它们不仅是面试常考的知识点，更是日常开发中提升代码质量的利器。

闭包(Closure)是指一个函数"记住"并访问其词法作用域中的变量，即使该函数在其词法作用域之外执行。而装饰器(Decorator)则是Python中一种特殊的语法糖，它允许你在不修改原函数代码的情况下，为函数添加额外的功能。这两者经常一起使用，构成了Python中强大的元编程能力。

2. 闭包：函数中的记忆大师

2.1 闭包的基本概念

闭包的核心在于"记住"环境变量。来看一个简单例子：

def outer_func(): message = "Hello" def inner_func(): print(message) return inner_func my_func = outer_func() my_func() # 输出: Hello

这里，inner_func就是一个闭包，它记住了outer_func作用域中的message变量，即使outer_func已经执行完毕。这种特性在实际开发中非常有用，比如可以用来创建特定配置的函数。

2.2 闭包的常见应用场景

闭包在Python中有多种实用场景：

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

2. 数据封装：创建私有变量

def counter(): count = 0 def increment(): nonlocal count count += 1 return count return increment c = counter() print(c()) # 1 print(c()) # 2

3. 回调函数：在事件驱动编程中保持状态

注意：使用闭包时要注意变量作用域问题。Python 3中可以使用nonlocal关键字修改外部函数的变量，但在Python 2中这是不允许的。

3. 装饰器：不修改原代码增强函数功能

3.1 装饰器基础

装饰器本质上是一个接受函数作为参数并返回一个新函数的高阶函数。最简单的装饰器示例：

def my_decorator(func): def wrapper(): print("函数执行前") func() print("函数执行后") return wrapper @my_decorator def say_hello(): print("Hello!") say_hello()

输出：

函数执行前 Hello! 函数执行后

装饰器语法@decorator只是say_hello = my_decorator(say_hello)的语法糖。

3.2 带参数的装饰器

装饰器也可以接受参数，这需要再嵌套一层函数：

def repeat(num_times): def decorator_repeat(func): def wrapper(*args, **kwargs): for _ in range(num_times): result = func(*args, **kwargs) return result return wrapper return decorator_repeat @repeat(num_times=3) def greet(name): print(f"Hello {name}") greet("Alice")

输出：

Hello Alice Hello Alice Hello Alice

3.3 类装饰器

装饰器不仅可以是函数，还可以是类。类装饰器通过实现__call__方法来工作：

class CountCalls: def __init__(self, func): self.func = func self.num_calls = 0 def __call__(self, *args, **kwargs): self.num_calls += 1 print(f"调用次数: {self.num_calls}") return self.func(*args, **kwargs) @CountCalls def say_hello(): print("Hello!") say_hello() say_hello()

输出：

调用次数: 1 Hello! 调用次数: 2 Hello!

4. 装饰器的实际应用

4.1 性能测试装饰器

import time def timer(func): def wrapper(*args, **kwargs): start_time = time.perf_counter() result = func(*args, **kwargs) end_time = time.perf_counter() print(f"函数 {func.__name__} 执行时间: {end_time - start_time:.4f}秒") return result return wrapper @timer def slow_function(): time.sleep(2) slow_function()

4.2 缓存装饰器

def cache(func): cached_data = {} def wrapper(*args): if args in cached_data: print("返回缓存结果") return cached_data[args] result = func(*args) cached_data[args] = result return result return wrapper @cache def compute(x): print("执行复杂计算...") return x * x print(compute(4)) # 执行计算 print(compute(4)) # 返回缓存

4.3 权限验证装饰器

def requires_auth(func): def wrapper(*args, **kwargs): if not kwargs.get('authenticated'): raise PermissionError("需要认证") return func(*args, **kwargs) return wrapper @requires_auth def get_secret_data(authenticated=False): return "机密数据" try: print(get_secret_data(authenticated=True)) # 正常工作 print(get_secret_data()) # 抛出异常 except PermissionError as e: print(e)

5. 高级技巧与常见问题

5.1 保留函数元信息

使用装饰器后，原函数的__name__、__doc__等元信息会被覆盖。可以使用functools.wraps来保留：

from functools import wraps def my_decorator(func): @wraps(func) def wrapper(*args, **kwargs): """包装函数文档""" return func(*args, **kwargs) return wrapper @my_decorator def example(): """示例函数文档""" pass print(example.__name__) # example print(example.__doc__) # 示例函数文档

5.2 多个装饰器的执行顺序

装饰器是从下往上执行的：

@decorator1 @decorator2 def func(): pass # 等同于 func = decorator1(decorator2(func))

5.3 装饰器常见问题排查

1. 忘记返回内部函数：装饰器必须返回一个函数对象
2. 参数传递错误：确保wrapper函数能接受任意参数(*args, **kwargs)
3. 元信息丢失：使用functools.wraps保留原函数信息
4. 状态共享问题：避免在装饰器函数外部定义可变对象

5.4 装饰器与闭包的结合

装饰器本身就是闭包的一种应用。这个例子展示了如何用闭包实现装饰器：

def html_tag(tag): def decorator(func): def wrapper(text): return f"<{tag}>{func(text)}</{tag}>" return wrapper return decorator @html_tag("div") @html_tag("strong") def greet(name): return f"Hello, {name}" print(greet("Alice")) # <div><strong>Hello, Alice</strong></div>

6. 实际项目中的应用经验

在大型项目中，装饰器可以大幅减少重复代码。比如在Web开发中：

# Flask路由装饰器 @app.route('/') def index(): return "首页" # Django登录要求装饰器 @login_required def profile(request): return "用户资料"

我在实际项目中最常用的几种装饰器：

1. 日志记录：自动记录函数调用和参数
2. 重试机制：网络请求失败时自动重试
3. 类型检查：验证函数参数类型
4. 性能监控：记录函数执行时间
5. 缓存：缓存昂贵计算的结果

一个实用的建议是：当发现自己在多个函数中重复相同的代码模式时，考虑是否可以用装饰器来抽象这种模式。这不仅能减少代码量，还能提高可维护性。