装饰器

什么是装饰器

装饰器遵循在不改变装饰对象（函数）原有的“调用方式”和“内部代码”的情况下给被装饰对象添加新的功能。装饰器的原则是对扩展开放，对修改封闭

为什么要用装饰器

在项目完成后，需要在原有的基础上有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况这就用到了装饰器

装饰器的实现

简易版本装饰器

  1. import time
  4. def index():
  5.     time.sleep(3)  # 5.停止3秒
  6.     print("from function index")  # 6.输出
  9. # 要求：给index函数增加了一个统计执行时间的功能
  10. def outer(func):
  11.     def get_time():  # 2.把index函数名绑定给func
  12.         start_time = time.time()  # 3.开始计时
  13.         func()  # 4.调用index函数
  14.         end_time = time.time()  # 计时结束
  15.         print(end_time - start_time)  # index()执行的时间
  17.     return get_time  
  20. index = outer(index)  # 1.通过调用get_time函数把index函数名当做参数传进去
  21. index()  # 可以看做似调用的index其实调用的是get_time
  22. # from function index
  23. # 3.0043959617614746
  24. print(index)  #  全局名称空间中的index指向的是get_time函数体代码
  25. # <function outer.<locals>.get_time at 0x7fcf403edf28>

进阶版本装饰器

  1. # 解决不同函数，需要传的参数个数问题  
  2. def outer(func_name):
  3.     def get_time(*args, **kwargs):
  4.         start_time = time.time()
  5.         func_name(*args, **kwargs)
  6.         end_time = time.time()
  7.         print(end_time - start_time)
  8.     return get_time

完整版本装饰器

  1. # 解决无法返回值问题
  2. def outer(func_name):
  3.     def get_time(*args, **kwargs):
  4.         start_time = time.time()
  5.         res = func_name(*args, **kwargs)
  6.         end_time = time.time()
  7.         print(end_time - start_time)
  8.         return res
  9.     return get_time

装饰器模板(重要)

  1. def outer(func_name):
  2.     def inner(*arg, **wargs):
  3.         print("修改前的操作")
  4.         res = func_name(*arg, **kwargs)
  5.         print("修改后的操作")
  6.         return res
  7.     return inner

装饰器语法糖

  1. # 仅仅是让代码编写的更加好看、简洁!!!
  2. def outer(func_name):
  3.     def inner(*arg, **kwargs):
  4.         print("修改前的操作")
  5.         res = func_name(*arg, **kwargs)
  6.         print("修改后的操作")
  7.         return res
  9.     return inner
  12. @outer  # 等价于 index = outer(index)
  13. def index():
  14.     print("from function index")
  17. index()

装饰器“修复技术”

  1. # 做到比真的还要真  但是本质其实没有变
  2. from functools import wraps
  5. def outer(func_name):
  6.     @wraps(func_name)
  7.     def inner(*arg, **kwargs):
  8.         print("修改前的操作")
  9.         res = func_name(*arg, **kwargs)
  10.         print("修改后的操作")
  11.         return res
  13.     return inner
  16. @outer
  17. def index():
  18.     """这是注释"""
  19.     print('from function index')
  22. help(index)  # help可以查看指定函数的注释信息
  23. index()
  24. # 修改前的操作
  25. # from function index
  26. # 修改后的操作

多层装饰器

  1. """语法糖会将紧挨着的被装饰对象的名字当做参数自动传入装饰器函数中"""
  4. def outer_1(func_1):
  5.     print('加载了outer_1')
  7.     def inner_1(*args, **kwargs):
  8.         print('执行了inner_1')
  9.         res1 = func_1(*args, **kwargs)
  10.         return res1
  12.     return inner_1
  15. def outer_2(func_2):
  16.     print('加载了outer_2')
  18.     def inner_2(*args, **kwargs):
  19.         print('执行了inner_2')
  20.         res2 = func_2(*args, **kwargs)
  21.         return res2
  23.     return inner_2
  26. def outer_3(func3):
  27.     print('加载了outer_3')
  29.     def inner_3(*args, **kwargs):
  30.         print('执行了inner_3')
  31.         res3 = func3(*args, **kwargs)
  32.         return res3
  34.     return inner_3
  37. @outer_1  # index = outer_1(index)
  38. @outer_2  # index = outer_2(index)
  39. @outer_3  # index = outer_1(outer_2(outer_3(index)))
  40. def index():
  41.     print('from function index')
  44. index()
  45. # 加载了outer_3
  46. # 加载了outer_2
  47. # 加载了outer_1
  48. # 执行了inner_1
  49. # 执行了inner_2
  50. # 执行了inner_3
  51. # from function index

有参装饰器

  1. def outer(source_data):  # 用来给装饰器传递值
  2.     def login_auth(func_name):  # 不能动，只能接收一个被装饰对象名字
  3.         def inner(*args, **kwargs):  # 不能动，是专门用来给被装饰的对象传参的
  4.             if source_data == '1':
  5.                 print('操作1')
  6.             elif source_data == '2':
  7.                 print('操作2')
  8.             elif source_data == '3':
  9.                 print('操作3')
  10.             else:
  11.                 print('其他操作')
  12.             res = func_name(*args, **kwargs)
  13.             return res
  15.         return inner
  17.     return login_auth
  20. num = input("输入你要操作的方式：")
  23. @outer(num)
  24. def index():
  25.     print('from function index')
  28. index()

类作为装饰器

  1. class Decorator(object):
  2.     def __init__(self, f):
  3.         self.f = f
  5.     def __call__(self):
  6.         print("进入", self.f.__name__)
  7.         self.f()
  8.         print("退出", self.f.__name__)
  11. @Decorator
  12. def func():
  13.     print("执行 func1()")
  15. func()
  16. # 进入 func
  17. # 执行 func1()
  18. # 退出 func

对象作为装饰器

  2. class Decorator:
  3.     def __init__(self, arg1, arg2):
  4.         print('执行类Decorator的__init__()方法')
  5.         self.arg1 = arg1
  6.         self.arg2 = arg2
  8.     def __call__(self, f):
  9.         print('执行类Decorator的__call__()方法')
  11.         def wrap(*args):
  12.             print('执行wrap()')
  13.             print('装饰器参数：', self.arg1, self.arg2)
  14.             print('执行' + f.__name__ + '()')
  15.             f(*args)
  16.             print(f.__name__ + '()执行完毕')
  18.         return wrap
  21. @Decorator('Hello', 'World')
  22. def example(a1, a2, a3):
  23.     print('传入example()的参数：', a1, a2, a3)
  26. print('装饰完毕')
  27. print('准备调用example()')
  28. example('Wish', 'Happy', 'EveryDay')
  29. print('测试代码执行完毕')

这里的参考文章：https://zhuanlan.zhihu.com/p/93846887