Python 装饰器：从原理到高级实战完全指南

Python 装饰器是一种强大的语法糖，它可以在不修改原函数代码的情况下，为函数添加额外的功能。装饰器的本质是一个接受函数作为参数，并返回一个新函数的高阶函数。

装饰器的基本原理

装饰器的工作原理可以概括为三个步骤：1. 接收被装饰的函数作为参数；2. 在内部定义一个新的包装函数；3. 返回这个包装函数替代原函数。这种机制使得我们可以在函数执行前后添加额外的逻辑，比如日志记录、性能计时、权限验证等。

基础装饰器示例

让我们从一个简单的计时装饰器开始，这个装饰器可以测量函数的执行时间：

```python
import time
import functools

def timer_decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"{func.__name__} 执行时间: {end_time - start_time:.4f} 秒")
return result
return wrapper

@timer_decorator
def calculate_fibonacci(n):
if n <= 1:
return n
return calculate_fibonacci(n - 1) + calculate_fibonacci(n - 2)

print(calculate_fibonacci(10))
```

在这个例子中，我们使用了 functools.wraps 来保留原函数的元信息，这是编写装饰器的最佳实践。输出结果显示了 fibonacci 函数的执行时间，这对于性能优化非常有用。

带参数的装饰器

有时候我们需要装饰器能够接受参数，这就需要创建一个装饰器工厂函数。例如，我们可以创建一个可以指定重复执行次数的装饰器：

```python
def repeat_decorator(times):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
results = []
for _ in range(times):
result = func(*args, **kwargs)
results.append(result)
return results
return wrapper
return decorator

@repeat_decorator(times=3)
def roll_dice():
import random
return random.randint(1, 6)

print(f"掷骰子结果: {roll_dice()}")
```

这个装饰器工厂模式非常灵活，可以根据不同的需求创建不同行为的装饰器。在实际开发中，这种模式常用于创建可配置的装饰器。

类装饰器的应用

除了函数装饰器，Python 还支持类装饰器。类装饰器可以用来修改类的行为，或者为类添加新的属性和方法。下面是一个使用类装饰器实现单例模式的例子：

```python
def singleton_decorator(cls):
instances = {}

@functools.wraps(cls)
def get_instance(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]

return get_instance

@singleton_decorator
class DatabaseConnection:
def __init__(self):
print("创建数据库连接")
self.connected = True

def query(self, sql):
if self.connected:
return f"执行查询: {sql}"
return "连接已关闭"

db1 = DatabaseConnection()
db2 = DatabaseConnection()
print(f"是否为同一实例: {db1 is db2}")
print(db1.query("SELECT * FROM users"))
```

这个单例装饰器确保了一个类只能创建一个实例，这在资源管理和连接池场景中非常有用。通过类装饰器，我们可以优雅地实现设计模式。

装饰器的组合使用

Python 允许在一个函数上应用多个装饰器，装饰器的执行顺序是从下往上。这个特性可以让我们构建复杂的功能组合：

```python
def log_decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print(f"[日志] 调用函数: {func.__name__}")
print(f"[日志] 参数: args={args}, kwargs={kwargs}")
result = func(*args, **kwargs)
print(f"[日志] 返回结果: {result}")
return result
return wrapper

def cache_decorator(func):
cache = {}

@functools.wraps(func)
def wrapper(*args, **kwargs):
key = str(args) + str(kwargs)
if key in cache:
print(f"[缓存] 命中缓存: {key}")
return cache[key]
result = func(*args, **kwargs)
cache[key] = result
return result
return wrapper

@log_decorator
@cache_decorator
def expensive_computation(x, y):
print(f"[计算] 正在计算 {x} + {y}")
return x + y

print("第一次调用:")
print(expensive_computation(5, 10))
print("\n第二次调用 (从缓存获取):")
print(expensive_computation(5, 10))
```

通过组合日志和缓存装饰器，我们可以在不修改原函数的情况下，同时添加日志记录和性能优化功能。这种模块化的设计使得代码更易于维护和扩展。

实际应用场景

装饰器在实际开发中有广泛的应用场景。在 Web 框架中，装饰器常用于路由定义、权限验证、请求日志记录等。在数据处理中，装饰器可以用于数据验证、格式转换、错误处理等。通过合理使用装饰器，我们可以编写出更加优雅、可维护的代码。

总结

Python 装饰器是一种强大的工具，它体现了 Python 的优雅和简洁。通过装饰器，我们可以实现横切关注点的分离，提高代码的复用性和可维护性。掌握装饰器的使用，将极大地提升你的 Python 编程能力。在实际项目中，建议结合具体需求灵活运用装饰器，但要避免过度使用导致代码可读性下降。