装饰器的实现

任何可调用对象(任何实现了call方法的对象都是可调用的)都可以用作装饰器，他们返回的对象往往是实现了自己的call方法的更复杂的类的实例

装饰器使用语法

装饰器本质也是一个函数，其返回值就是一个函数对象
使用方法：
1.先定义一个装饰函数（或者类或者偏函数实现）
2.再定义业务函数或者类
3.将业务函数作为参数传入装饰函数

装饰器通用模板

函数装饰器通用模板：

  1. def mydecorator(function):
  2.     def wrapped(*args, **kwargs):
  3.         # 在调用原始函数之前,做点什么
  4.         result = function(*args, **kwargs)
  5.         # 在函数调用之后，做点什么
  6.         # 并返回结果
  7.         return result
  8.         # 返回 wrapper 作为装饰函数
  10.     return wrapped

类装饰器通用模板：如果装饰器需要复杂的参数化或者依赖于特定状态，使用用户自定义类可能更好

  1. class DecoratorAsClass:
  2.     def __init__(self, function):
  3.         self.function = function
  5.     def __call__(self, *args, **kwargs):
  6.         # 调用原始函数前，做点什么
  7.         result = self.function(*args, **kwargs)
  8.         # 调用函数之后，做点什么
  9.         # 并返回结果
  10.         return result

装饰器简单应用

装饰器应用：

  • 数据验证
  • 日志
  • 缓存
  • 监控
  • 调试
  • 业务规则
  • 加密

1.日志打印器
2.时间计时器

  1. #  日志打印器
  2. def logger(func):
  3.     def wrapper(*args, **kwargs):
  4.         print("我准备开始计算：{}函数了".format(func.__name__))
  5.         func(*args, **kwargs)
  6.         print("我已执行完函数了！！！")
  7.     return wrapper
  9. @logger
  10. def add(x, y):
  11.     print('{} + {} = {}'.format(x, y, x+y))
  14. add(1, 2)
  15. ----------------
  16. #我准备开始计算：add函数了
  17. #1 + 2 = 3
  18. #我已执行完函数了！！！
  1. # 时间计时器
  2. def timer(func):
  3.     def wrapper(*args, **kwargs):
  4.         t1 = time.time()
  5.         func(*args, **kwargs)
  6.         t2 = time.time()
  7.         result_time = t2 - t1
  8.         print("执行函数一共花了{}".format(result_time))
  10.     return wrapper
  13. import time
  16. @timer
  17. def want_sleep(sleep_time):
  18.     time.sleep(sleep_time)
  21. want_sleep(10)
  22. ----------------------
  23. #执行函数一共花了10.008701086044312

带参数的函数装饰器

use_logging 是一个带参数的装饰器，我们可以理解为它是一个含有参数的闭包，当我们使用@use_logging(level=’warn’)，
将业务函数foo1作为参数传入，传递到装饰器中

  1. #  带参数的装饰器
  2. def use_logging(level):
  3.     def decorator(func):
  4.         def wrapper(*args, **kwargs):
  5.             if level == 'warn':
  6.                 print("warning !!!!!,{} is running".format(func.__name__))
  7.             if level == 'info':
  8.                 print("{} is running".format(func.__name__))
  9.             return func(*args, **kwargs)
  11.         return wrapper
  13.     return decorator
  16. @use_logging(level='warn')
  17. def foo1(name='foo'):
  18.     print("i am {}".format(name))
  20. @use_logging(level='info')
  21. def foo2(name='FOO'):
  22.     print("i am {}".format(name))
  25. foo1()
  26. foo2()
  27. ----------
  28. #warning !!!!!,foo1 is running
  29. #i am foo
  30. #foo2 is running
  31. #i am FOO

不带参数的类装饰器

实现类装饰器，必须实现__call，和 _init两个内置函数，
init：用于接收被装饰的函数，
call：用于实现装饰逻辑

  1. class logger:
  2.     def __init__(self, func):
  3.         self.func = func
  5.     def __call__(self, *args, **kwargs):
  6.         print("[INFO]:the function {func}() is running".format(func=self.func.__name__))
  7.         return self.func(*args, **kwargs)
  9. @logger
  10. def say(name):
  11.     print("say {}!".format(name))
  13. say("zaygee")
  14. ---------------------
  15. #[INFO]:the function say() is running
  16. #say zaygee!

带参数的类装饰器

实现带参数的类装饰器，必须实现__call，和 _init两个内置函数，
init：用于接收传入参数
call：用于接收被装饰函数+实现装饰逻辑

  1. # 带参数的类装饰器
  3. class loggering(object):
  4.     def __init__(self, level='INFO'):
  5.         """接收传入参数"""
  6.         self.level = level
  8.     def __call__(self, func):
  9.         """接收函数并返回函数"""
  11.         def warpper(*args, **kwargs):
  12.             print("[{level}]: the function {func}() is runnig".format(level=self.level, func=func.__name__))
  13.             func(*args, **kwargs)
  15.         return warpper
  18. @loggering(level='WARNNING')
  19. def say(name):
  20.     print("say {name}".format(name=name))
  23. say("i am zaygee")
  24. ------------------------
  25. #[WARNNING]: the function say() is runnig
  26. #say i am zaygee
  1. # 封装http请求日志打印
  2. class Logger:
  3.     """带参数的类装饰器：http日志输出"""
  4.     def __init__(self, method):
  5.         self.method = method
  7.     def __call__(self, func):
  8.         def logging(*args, **kwargs):
  9.             logger.info(f"用例开始执行{func.__name__}")
  10.             res = func(*args, **kwargs)
  11.             if self.method.lower() == 'post':
  12.                 logger.info(f'请求URl:{res.url}')
  13.             else:
  14.                 logger.info('不是post请求')
  15.             logger.info(f"用例结束执行{func.__name__}")
  16.         return logging
  19. class BaseRequest:
  20.     headers = {'Accept': 'application/json, text/javascript, */*; q=0.01',
  21.                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
  22.                              'Chrome/81.0.4044.122 Safari/537.36',
  23.                'Connection': 'keep-alive',
  24.                'Content-Type': 'application/json'}
  26.     def __init__(self):
  27.         self.res = requests.session()
  28.         self.res.headers = self.headers
  30.     @Logger(method='post')
  31.     def base_post(self, url, data=None, json=None, **kwargs):
  32.         res = self.res.post(url=url, data=data, json=json, verify=True, **kwargs)
  33.         return res
  35. 2021-07-11 22:51:55.818 | INFO     | __main__:case_logging:105 - 用例开始执行
  36. 2021-07-11 22:51:55.818 | INFO     | __main__:case_logging:107 - 1*4 = 4
  37. 2021-07-11 22:51:55.818 | INFO     | __main__:case_logging:108 - 用例执行结束
  38. 2021-07-11 22:51:55.819 | INFO     | __main__:logging:229 - 用例开始执行base_post
  39. 2021-07-11 22:51:56.058 | INFO     | __main__:logging:232 - 请求URl:https://web/accounts/login
  40. 2021-07-11 22:51:56.059 | INFO     | __main__:logging:235 - 用例结束执行base_post

wraps装饰器

@functools.wraps(wrapped, assigned=WRAPPER_ASSIGNMENTS, updated=WRAPPER_UPDATES)
装饰器极大的复用了代码，但是唯一的缺点就是原函数的元信息不见了 ，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数一样的元信息了

  1. #   functions.wraps
  2. from functools import wraps
  3. def my_decorator(func):
  4.     @wraps(func)
  5.     def wrapper(*args, **kwargs):
  6.         print("calling decorated function")
  7.         return func(*args, **kwargs)
  8.     return wrapper
  10. @my_decorator
  11. def example():
  12.     """
  13.     Dcostring
  14.     """
  15.     print("called decorated function")
  16. example()
  17. print(example.__name__)
  18. print(example.__doc__)
  19. -------------
  20. #calling decorated function
  21. #called decorated function
  22. #example
  24. #    Dcostring

内置装饰器property

通常存在于类中，可以将函数定义成一个属性，属性的值就是该函数的返回，
当我们需要对属性做合法性的校验，可以考虑使用proprety装饰器

  1. class C:
  2.     def __init__(self):
  3.         self._x = None
  5.     @property
  6.     def x(self):
  7.         """i am the 'x' property"""
  8.         return self._x
  10.     @x.setter
  11.     def x(self, value):
  12.         self._x = value
  14.     @x.deleter
  15.     def x(self):
  16.         del self._x
  19. c = C()
  21. c.x = 10  # 设置属性
  22. print(c.x)  # 查看属性
  23. del c.x  # 删除属性
  24. -------------
  25. #10

例子：校验手机号的合法性

  1. class Phone:
  2.     def __init__(self):
  3.         self._x = None
  5.     @property
  6.     def x(self):
  7.         """i am the 'x' property"""
  8.         return self._x
  10.     @x.setter
  11.     def x(self, value):
  12.         if not isinstance(value, int):
  13.             # raise ValueError("请输入合法手机号")
  14.             print("请输入合法手机号")
  15.         else:
  16.             self._x = value
  17.             print("输入的手机:{}是合法的".format(self._x))
  19.     @x.deleter
  20.     def x(self):
  21.         del self._x
  23. sj = Phone()
  24. sj.x = 'dfdfd'
  25. del sj.x
  26. sj.x = 13838839333
  27. ----------------
  28. #请输入合法手机号
  29. #输入的手机:13838839333是合法的

多装饰器装饰的执行顺序

执行顺序为：至上而下，再至下而上 执行

  1. from logzero import logger
  2. import time
  3. # here put the import lib
  4. def my_decorator(func):
  5.     def wrapper(*args, **kwargs):
  6.         logger.info(f"调用业务代码前执行")
  7.         result = func(*args, **kwargs)
  8.         logger.info(f"调用业务代码后执行")
  9.         return  result
  10.     return wrapper
  13. def decorator_time(func):
  14.     def wrapper(*args, **kwargs):
  15.         start = time.time()
  16.         logger.info(f"开始执行: {start}")
  17.         result = func(*args, **kwargs)
  18.         logger.info(f"执行代码耗时: {time.time()-start}")
  19.         return result
  20.     return wrapper
  22. def decorator_with_params(params):
  23.     def decorator(func):
  24.         def wrapper(*args, **kwargs):
  25.             if params != 1:
  26.                 logger.info("params=1")
  27.             else:
  28.                 logger.info("params is not eq 1")
  29.             return func(*args, **kwargs)
  30.             logger.info("带参数decorator执行完毕")
  31.         return wrapper
  32.     return decorator
  35. @decorator_time
  36. @my_decorator
  37. @decorator_with_params(1)
  38. def test_decorator():
  39.     logger.info("执行业务代码")
  42. if __name__ == "__main__":
  43.     test_decorator()
  46. """
  47. [I 220112 23:30:23 test1:23] 开始执行: 1642001423.521113
  48. [I 220112 23:30:23 test1:13] 调用业务代码前执行
  49. [I 220112 23:30:23 test1:35] params is not eq 1
  50. [I 220112 23:30:23 test1:46] 执行业务代码
  51. [I 220112 23:30:23 test1:15] 调用业务代码后执行
  52. [I 220112 23:30:23 test1:25] 执行代码耗时: 0.00032520294189453125
  53. """

使用decorator轻松实现装饰器

  1. from decorator import decorator
  4. # @decorator
  5. # def decoration(func, *args, **kwargs):
  6. #     """decorator装饰 生成一个装饰器函数"""
  7. #     print("Ready to run func " + func.__name__)
  8. #     func(*args, **kwargs)
  9. #     print("successful to run func " + func.__name__)
  11. # 等同于如下实现
  12. def decoration(func, *args, **kwargs):
  13.     def wrapper(*args, **kwargs):
  14.         print("Ready to run func " + func.__name__)
  15.         func(*args, **kwargs)
  16.         print("successful to run func " + func.__name__)
  17.     return wrapper
  21. @decoration
  22. def demo():
  23.     print("run the demo task")
  25. demo()
  26. print(demo.__name__)    # wrapper
  30. @decorator
  31. def decoration_with_params(func, values=1, *args, **kwargs):
  32.     results = func(*args, **kwargs)
  33.     if values == 1:
  34.         print('values = 1')
  35.         return results
  36.     else:
  37.         print('values ! = 1')
  38.         return '3'
  41. @decoration_with_params(values=1)
  42. def demo_2():
  43.     print("run the demo 2 task")
  44.     return 1
  47. print(demo_2())
  48. print(demo_2.__name__)  # demo_2

参考自：https://zhuanlan.zhihu.com/p/65968462、https://foofish.net/decorator.html