Python之装饰器

装饰器

今天我们来学习以下Python里面的高阶函数，装饰器decorator；它是一种强盛的工具，可以修改、扩展函数（方法）的行为，而且无需修改原函数（方法）的代码；身为高阶函数，必然有高级的地方，即函数可以作为参数传递，也可以当作返回值返回
别看上面写的一堆话，它的作用其实很简单

• 代码复用，通用的功能抽象为装饰器
  
• 代码解耦，焦点逻辑和附加功能分离开
  
• 动态扩展，运行时候修改函数的行为
  

下面就让我们进行实战以下，看看装饰器到底是个怎么回事
定义、利用装饰器

1. # 定义装饰器
2. def decorator(func):
3.     def wrapper(*args, **kwargs):
4.         # 在调用原始函数之前执行的操作
5.         print("Before calling the function")
6.         result = func(*args, **kwargs)
7.         # 在调用原始函数之后执行的操作
8.         print("After calling the function")
9.         return result
10.     return wrapper
12. # 使用装饰器
13. @decorator
14. def say_hello(name):
15.     return f"Hello, {name} "
17. print(say_hello("Michael"))
20. """
21. Before calling the function
22. After calling the function
23. Hello, Michael
24. """

复制代码

手动应用装饰器

1. # 定义装饰器
2. def decorator(func):
3.     def wrapper(*args, **kwargs):
4.         # 在调用原始函数之前执行的操作
5.         print("Before calling the function")
6.         result = func(*args, **kwargs)
7.         # 在调用原始函数之后执行的操作
8.         print("After calling the function")
9.         return result
10.     return wrapper
13. def say_hello(name):
14.     return f"Hello, {name} "
15.    
17. # 手动应用装饰器
18. decorated_function = decorator(say_hello)
19. print(decorated_function("Anna"))
21. """
22. Before calling the function
23. After calling the function
24. Hello, Michael
25. """

复制代码

带参数的装饰器

1. # 带参数的装饰器
2. # 外层函数接受装饰器参数
3. # 内层函数接受目标函数
4. def repart(num_times):
5.     def decorator(func):
6.         def wrapper(*args, **kwargs):
7.             for _ in range(num_times):
8.                 result = func(*args, **kwargs)
9.             return result
11.         return wrapper
13.     return decorator
16. @repart(3)
17. def greet(name):
18.     print(f"Hello, {name}")
21. greet("Anna")
23. """
24. Hello, Anna
25. Hello, Anna
26. Hello, Anna
27. """

复制代码

类装饰器

1. # 类装饰器
2. # 通过实现__call__方法来装饰函数
4. class Mydecorator:
5.     def __init__(self, func):
6.         self.func = func
8.     def __call__(self, *args, **kwargs):
9.         print("Before calling the function")
10.         result = self.func(*args, **kwargs)
11.         print("After calling the function")
12.         return result
15. @Mydecorator
16. def say_hello(name):
17.     return f"Hello {name}"
20. print(say_hello("John"))
23. """
24. Before calling the function
25. After calling the function
26. Hello John
27. """

复制代码

保存函数的元信息

但是利用装饰器后，原始函数的元信息会被覆盖（__name__和__doc__等）
解决办法就是下面的functools.wraps

1. # 保留函数的元信息
2. from functools import wraps
5. def my_decorator(func):
6.     @wraps(func)
7.     def wrapper(*args, **kwargs):
8.         print("Before calling the function")
9.         result = func(*args, **kwargs)
10.         print("After calling the function")
11.         return result
13.     return wrapper
16. @my_decorator
17. def say_hello(name):
18.     """Greet someone by name."""
19.     print(f"Hello, {name}!")
22. print(say_hello.__name__) # say_hello
23. print(say_hello.__doc__) # Greet someone by name.

复制代码

当然了，有的同学会问，我可不可以利用两个、三个装饰器呢；答案是当然可以的；我们来看一下DeepSeek给出的例子

1. # 装饰器 1：日志记录
2. def log_decorator(func):
3.     def wrapper(*args, **kwargs):
4.         # 记录函数调用
5.         print(f"Log: Calling function {func.__name__} with args: {args}, kwargs: {kwargs}")
6.         # 调用原始函数
7.         result = func(*args, **kwargs)
8.         # 记录函数返回结果
9.         print(f"Log: Function {func.__name__} returned: {result}")
10.         return result
11.     return wrapper
14. # 装饰器 2：权限验证
15. def auth_decorator(func):
16.     def wrapper(*args, **kwargs):
17.         # 模拟权限检查
18.         user = "admin"  # 假设当前用户是 admin
19.         if user == "admin":
20.             print("Auth: User is authorized.")
21.             # 调用原始函数
22.             result = func(*args, **kwargs)
23.             return result
24.         else:
25.             raise PermissionError("Auth: Unauthorized access.")
26.     return wrapper
29. # 装饰器 3：性能测试
30. def timing_decorator(func):
31.     import time
33.     def wrapper(*args, **kwargs):
34.         # 记录开始时间
35.         start_time = time.time()
36.         # 调用原始函数
37.         result = func(*args, **kwargs)
38.         # 记录结束时间
39.         end_time = time.time()
40.         # 计算并输出执行时间
41.         print(f"Timing: Function {func.__name__} took {end_time - start_time:.4f} seconds")
42.         return result
43.     return wrapper
46. # 应用多个装饰器
47. @log_decorator
48. @auth_decorator
49. @timing_decorator
50. def greet(name):
51.     # 模拟一个耗时操作
52.     import time
53.     time.sleep(1)
54.     return f"Hello, {name}!"
56. # 等价于
57. greet = log_decorator(auth_decorator(timing_decorator(greet)))
59. # 测试代码
60. if __name__ == "__main__":
61.     try:
62.         print(greet("Alice"))
63.     except PermissionError as e:
64.         print(e)

复制代码

我们可以看下面的输出信息，首先是打印Log、其次是权限认证、时间；最后就是Log结束；没错通过输出信息我们可以看出来，多个装饰器的时候，执行次序是从上到下的；返回的时候是从下到上

• 当调用 greet("Alice") 时，装饰器会按照以下次序执行：
  
  
  • log_decorator 的 wrapper。
    
  • auth_decorator 的 wrapper。
    
  • timing_decorator 的 wrapper。
    
  • 原始函数 greet。
    
  
  
• 返回时，次序相反：
  
  
  • timing_decorator 的 wrapper。
    
  • auth_decorator 的 wrapper。
    
  • log_decorator 的 wrapper。
    
  
  

下面我们来看一下多装饰器的执行流程

• 调用greet("Alice")
  
  
  
  • 进入log_decorator的wapper，记载函数的调用
    
  • 进入auth_decorator的wapper，检查权限
    
  • 进入timing_decorator的wapper，记载开始时间
    
  • 最后调用原始函数greet
    
  
  
• 返回结果流程
  
  
  
  • 原始函数greet返回结果
    
  • timing_decorator的wapper记载结束时间并输出执行时间
    
  • auth_decorator的wapper返回结果
    
  • log_decorator的wapper记载返回结果并输出
    
  
  

1. Log: Calling function wrapper with args: ('Alice',), kwargs: {}
2. Auth: User is authorized.
3. Timing: Function greet took 1.0002 seconds
4. Log: Function wrapper returned: Hello, Alice!
5. Hello, Alice!

复制代码

装饰器就到这里了，这里只是简单的例子，具体还需要私底下找一些实例来进行操作，才能更好的记忆深刻

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。