好的，我们开始今天的讲座，主题是Python装饰器模式。装饰器是一种强大的元编程工具，它允许我们动态地修改函数或类的行为，而无需实际修改它们的源代码。这使得装饰器在代码复用、关注点分离以及实现横切关注点（例如日志记录、性能分析和权限验证）方面非常有用。
什么是装饰器？
从本质上讲，装饰器是一个函数，它接受另一个函数作为输入，并返回一个新的函数。这个新的函数通常是对原始函数的包装，它在调用原始函数之前或之后添加了一些额外的行为。
装饰器的基本语法
Python提供了简洁的语法来应用装饰器，使用@符号。例如：
@decorator_function
def my_function():
print("Hello from my_function")上面的代码等价于：
def my_function():
print("Hello from my_function")
my_function = decorator_function(my_function)一个简单的装饰器示例
让我们创建一个简单的装饰器，它在调用函数之前和之后打印一些消息：
def my_decorator(func):
def wrapper():
print("Before calling the function.")
func()
print("After calling the function.")
return wrapper
@my_decorator
def say_hello():
print("Hello!")
say_hello()输出：
Before calling the function.
Hello!
After calling the function.在这个例子中，my_decorator是装饰器函数，say_hello是被装饰的函数。wrapper函数是装饰器内部的函数，它包含了在调用原始函数之前和之后执行的逻辑。
带有参数的装饰器
如果被装饰的函数有参数，我们需要确保装饰器能够正确地处理这些参数。我们可以使用*args和**kwargs来接收任意数量的位置参数和关键字参数。
def my_decorator(func):
def wrapper(*args, **kwargs):
print("Before calling the function with arguments:", args, kwargs)
result = func(*args, **kwargs)
print("After calling the function with result:", result)
return result
return wrapper
@my_decorator
def add(x, y):
return x + y
result = add(5, 3)
print("Result:", result)输出：
Before calling the function with arguments: (5, 3) {}
After calling the function with result: 8
Result: 8在这个例子中，wrapper函数接收了*args和**kwargs，并将它们传递给原始函数func。这使得装饰器可以用于任何带有参数的函数。
带有参数的装饰器工厂
有时，我们希望装饰器本身也能够接收参数。这种情况下，我们需要创建一个装饰器工厂函数，它接受参数并返回一个装饰器。
def repeat(num_times):
def decorator_repeat(func):
def wrapper(*args, **kwargs):
for i in range(num_times):
print(f"Running repetition {i+1}:")
result = func(*args, **kwargs)
return result
return wrapper
return decorator_repeat
@repeat(num_times=3)
def greet(name):
print(f"Hello, {name}!")
greet("Alice")输出：
Running repetition 1:
Hello, Alice!
Running repetition 2:
Hello, Alice!
Running repetition 3:
Hello, Alice!在这个例子中，repeat是一个装饰器工厂函数，它接受num_times作为参数，并返回一个装饰器decorator_repeat。decorator_repeat的行为与之前的装饰器类似，但它可以访问num_times参数。
类装饰器
装饰器不仅可以用于函数，还可以用于类。类装饰器通常用于修改类的行为或添加新的方法。
def my_class_decorator(cls):
class NewClass(cls):
def say_goodbye(self):
print("Goodbye!")
return NewClass
@my_class_decorator
class MyClass:
def say_hello(self):
print("Hello!")
obj = MyClass()
obj.say_hello()
obj.say_goodbye()输出：
Hello!
Goodbye!在这个例子中，my_class_decorator接收一个类cls作为参数，并返回一个新的类NewClass。NewClass继承自cls，并添加了一个新的方法say_goodbye。
使用 functools.wraps 保持函数元信息
在使用装饰器时，原始函数的元信息（例如函数名、文档字符串和参数列表）可能会丢失。为了解决这个问题，可以使用functools.wraps装饰器来保留原始函数的元信息。
import functools
def my_decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
"""Wrapper function for my_decorator."""
print("Before calling the function.")
result = func(*args, **kwargs)
print("After calling the function.")
return result
return wrapper
@my_decorator
def say_hello(name):
"""Says hello to the given name."""
print(f"Hello, {name}!")
print(say_hello.__name__)
print(say_hello.__doc__)
say_hello("Bob")输出：
say_hello
Says hello to the given name.
Before calling the function.
Hello, Bob!
After calling the function.在这个例子中，functools.wraps(func)将原始函数func的元信息复制到wrapper函数。这使得我们可以访问say_hello的函数名和文档字符串。
常见的装饰器使用场景
以下是一些常见的装饰器使用场景：
- 日志记录: 记录函数的调用和返回。
- 性能分析: 测量函数的执行时间。
- 缓存: 缓存函数的返回值，以避免重复计算。
- 权限验证: 检查用户是否有权限访问函数。
- 重试: 在函数失败时自动重试。
- 类型检查: 验证函数的输入和输出类型。
示例：日志记录装饰器
import logging
logging.basicConfig(level=logging.INFO)
def log_calls(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
logging.info(f"Calling {func.__name__} with arguments: {args}, {kwargs}")
result = func(*args, **kwargs)
logging.info(f"{func.__name__} returned: {result}")
return result
return wrapper
@log_calls
def calculate_sum(a, b):
return a + b
calculate_sum(10, 20)这段代码会记录 calculate_sum 函数的调用信息以及返回结果到日志中。
示例：性能分析装饰器
import time
def timer(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
execution_time = end_time - start_time
print(f"{func.__name__} took {execution_time:.4f} seconds to execute")
return result
return wrapper
@timer
def slow_function():
time.sleep(2) # Simulate a slow operation
return "Finished"
slow_function()这段代码会测量 slow_function 的执行时间并打印出来。
示例：缓存装饰器
import functools
def cache(func):
cache_dict = {}
@functools.wraps(func)
def wrapper(*args, **kwargs):
key = (args, tuple(sorted(kwargs.items()))) # Create a unique key for the arguments
if key not in cache_dict:
cache_dict[key] = func(*args, **kwargs)
return cache_dict[key]
return wrapper
@cache
def expensive_function(n):
print(f"Calculating expensive_function({n})") # Only printed on first call with n
time.sleep(1) #simulate expensive calculation
return n * 2
print(expensive_function(5))
print(expensive_function(5)) # Uses cached value
print(expensive_function(10))这个例子展示了如何使用装饰器来缓存函数的返回值。 第一次使用特定参数调用expensive_function时，它会进行计算，并将结果存储在cache_dict中。 后续使用相同参数的调用将直接从缓存中检索结果，而无需重新计算。 注意，缓存键需要考虑args和kwargs，并确保kwargs的顺序不影响缓存。
表格：装饰器的优缺点
| 优点 | 缺点 |
|---|---|
| 代码复用: 可以轻松地将相同的行为应用于多个函数或类。 | 调试难度增加: 装饰器会增加代码的复杂性，使得调试更加困难。 |
| 关注点分离: 可以将横切关注点（例如日志记录、性能分析）与核心业务逻辑分离。 | 元信息丢失: 如果不使用functools.wraps，原始函数的元信息可能会丢失。 |
| 动态修改: 可以在运行时动态地修改函数或类的行为。 | 过度使用: 过度使用装饰器可能会导致代码难以理解和维护。 |
| 提高可读性: 通过使用装饰器，可以使代码更加简洁和易于理解。 | 性能影响: 装饰器会增加函数的调用开销，虽然通常很小，但在性能关键的场景中需要注意。 |
一些使用装饰器的最佳实践
- 使用
functools.wraps来保留原始函数的元信息。 - 避免过度使用装饰器，以免增加代码的复杂性。
- 在编写装饰器时，考虑参数的处理和错误处理。
- 编写清晰的文档字符串，说明装饰器的作用和用法。
- 对于复杂的需求，可以考虑使用多个装饰器组合。
总结一下装饰器的要点
装饰器是Python中一种强大的元编程工具，能够动态地修改函数或类的行为。通过使用装饰器，我们可以实现代码复用、关注点分离以及简化复杂逻辑。 熟练掌握装饰器是成为高级Python开发者的重要一步。