devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python3-Cookbook(第九章) - 元编程Part1

作者：从前慢现在也慢 | 2024-04-16 15:44:08

赞

踩

Python3-Cookbook(第九章) - 元编程Part1

一、函数装饰器入门

    对应Cookbook章节 9.1、9.2、9.3 和9.8

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. # @Time    : 2023/8/4 18:44
  4. # @Author  : Maple
  5. # @File    : 01-函数装饰器入门.py
  6.  
  7. #  Cookbook 9.1、9.2、9.3 和9.8
  8.  
  9.  
  10. import time
  11. from functools import wraps
  12.  
  13. def timethis(func):
  14.     '''
  15.     Decorator that reports the execution time.
  16.     '''
  17.     @wraps(func)
  18.     def wrapper(*args, **kwargs):
  19.         start = time.time()
  20.         result = func(*args, **kwargs)
  21.         end = time.time()
  22.         print(func.__name__, end-start)
  23.         return result
  24.     return wrapper
  25.  
  26. @timethis
  27. def countdown(n):
  28.     '''
  29.     Counts down
  30.     '''
  31.     print('hello')
  32.     while n > 0:
  33.       n -= 1
  34.  
  35. # 多层装饰器
  36. def decorator1(func):
  37.     @wraps(func)
  38.     def wrapper(*args, **kwargs):
  39.         print('Decorator 1')
  40.         return func(*args, **kwargs)
  41.     return wrapper
  42.  
  43. def decorator2(func):
  44.     @wraps(func)
  45.     def wrapper(*args, **kwargs):
  46.         print('Decorator 2')
  47.         return func(*args, **kwargs)
  48.     return wrapper
  49.  
  50. @decorator1
  51. @decorator2
  52. def add(x, y):
  53.     return x + y
  54.  
  55. # @wraps装饰func的底层 到底发生了什么？
  56. # Part1
  57. """
  58. # 1.wrapped是被装饰的函数
  59. # 2.WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__doc__','__annotations__')
  60. # 3.WRAPPER_UPDATES = ('__dict__',)
  61. # 4.返回一个 update_wrapper 的偏函数
  63. def wraps(wrapped,
  64.           assigned = WRAPPER_ASSIGNMENTS,
  65.           updated = WRAPPER_UPDATES):
  66.     Decorator factory to apply update_wrapper() to a wrapper function
  67.  
  68.     return partial(update_wrapper, wrapped=wrapped,
  69.                    assigned=assigned, updated=updated)
  71. """
  72.  
  73. # Part2
  74. """
  75. # 1. wrapper是装饰器被装饰后 返回的函数  
  76. # 2. updated =  ('__dict__',)
  78. def update_wrapper(wrapper,
  79.                    wrapped,
  80.                    assigned = WRAPPER_ASSIGNMENTS,
  81.                    updated = WRAPPER_UPDATES):
  82.     Update a wrapper function to look like the wrapped function
  84.     
  85.     for attr in assigned:
  86.         try:
  87.             # 1. 取出`被装饰`函数的属性
  88.             value = getattr(wrapped, attr)
  89.         except AttributeError:
  90.             pass
  91.         else:
  92.             # 2.将第一步取出来的属性值 赋值给 wrapper,也就是说wrapper的元数据实际上替换成[被装饰的函数]了
  93.             #    以此实现了被装饰函数 元数据的保留
  94.             setattr(wrapper, attr, value)
  95.     for attr in updated:
  96.         # 1.update方法实现 字典值的更新，注意是 后面更新前面的(逻辑: 交叉的key,用后面的值更新前面的; 只存在于后面的key,添加到前面的字典 )
  97.         # 2.如果wrapped 有 ('__dict__',)属性[Tips个人理解:类才有dict属性,方法没有这个属性],那么就把wrapper的dict属性也替换成wrapped的
  98.         # 3.如果wrapped 没有 dict属性, getattr去默认值{},而空字典 对wrapper.__dict__'的值 不会有任何影响
  99.         getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
  101.     return wrapper
  103. """
  104.  
  105.  
  106.  
  107. if __name__ == '__main__':
  108.  
  109.     # 1. 简单装饰器测试
  110.     countdown(1000000)
  111.     print('===================')
  112.  
  113.  
  114.  
  115.     # 2.解除装饰器
  116.     # 2-1 方法之一
  117.     """
  118.     1.适用场景: 在函数已经有装饰器的情况下,但是又要单独测试函数本身的场景
  119.     2.必要条件1: 有@wraps修饰
  120.     2.必要条件2：只有一个装饰器,多个装饰器的情况解除之后的测试结果不可预测
  121.     """
  122.     # 通过__wrapped__直接访问被包装的函数：即countdown自身(不会走装饰器里面的逻辑)
  123.     countdown.__wrapped__(1000)
  124.  
  125.     # 2-2 方法之二
  126.  
  127.     print('===================')
  128.     countdown = countdown.__wrapped__
  129.     countdown(100000)
  130.  
  131.     # 2-3 多个装饰器的解除测试
  132.     print('===================')
  133.     add =  add.__wrapped__ 
  134.     result = add(2,3)
  135.     print('result = {}'.format(result)) # result = 5
  136.     """
  137.     output: 
  138.        Decorator 2 ,也就是说内层的装饰器并未解除
  139.        result = 5
  140.     """
  141.  
  142.     print(add.__module__) # __main__
  143.     print(add.__name__) # add

二、函数装饰器传参

  对应cookbook章节 9.4 和 9.6

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. # @Time    : 2023/8/4 19:08
  4. # @Author  : Maple
  5. # @File    : 02-函数装饰器传参.py
  6. import logging
  7. from functools import wraps, partial
  8.  
  9. """
  10. 对应cookbook 
  11. 9.4 和 9.6
  13. """
  14.  
  15. def logged(level,name=None,message=None):
  16.  
  17.     def decorater(func):
  18.         logname = name if name else func.__module__
  19.         log = logging.getLogger(logname)
  20.         logmsg = message if message else func.__name__
  21.  
  22.         @wraps(func)
  23.         def wrapper(*args,**kwargs):
  24.             log.log(level,logmsg)
  25.             # print('{}:{}'.format(logname,logmsg))
  26.             return func(*args,**kwargs)
  27.  
  28.         return wrapper
  29.  
  30.     return decorater
  31.  
  32.  
  33. # 正常调用1
  34. @logged(logging.DEBUG)
  35. def add(x,y):
  36.     return x + y
  37.  
  38. # 正常调用2
  39. @logged(logging.CRITICAL,'example')
  40. def spam():
  41.     print('Spam')
  42.  
  43.  
  44.  
  45. # 正常调用3
  46. # @logged()
  47. def sub(x,y):
  48.     return x - y
  49.  
  50. # 非正常调用,会报错
  51. @logged
  52. def sub(x,y):
  53.     return x - y
  54.  
  55. # 因为如上方式等价于
  56. sub = logged(sub) # 即第一个参数是被装饰函数本身,但是logged实际需要是接收的是level,name和message三个参数
  57. # sub()
  58.  
  59. # 如何改进？
  60.  
  61. def logged2(func = None,*, level=logging.DEBUG,name=None,message=None):
  62.     if func is None:
  63.         return partial(logged2,level = level,name = name,message = message)
  64.  
  65.     logname = name if name else func.__module__
  66.     log = logging.getLogger(logname)
  67.     logmsg = message if message else func.__name__
  68.  
  69.  
  70.     @wraps(func)
  71.     def wrapper(*args,**kwargs):
  72.         log.log(level,logmsg)
  73.         print('{}:{}'.format(logname,logmsg))
  74.         return func(*args,**kwargs)
  75.  
  76.     return wrapper
  77.  
  78. """
  79. 如下方式等价于:
  80. sub2 = logged2(sub2) # 即第一个参数是被装饰函数本身
  81. # 此时sub2其实已经变成wrapper
  82. sub2()
  84. 由于第一个参数不为空，所以直接走logger2 if后面的逻辑 
  85. """
  86. # 1. 没有任何参数传递(注意这里并没有使用(),和装饰器的`普通用法`保持一致)
  87. @logged2
  88. def sub2(x,y):
  89.     return x - y
  90.  
  91.  
  92.  
  93. """
  94. 执行流程
  95. 1. 由于logger2中func参数未传入，所以为None,会返回一个偏函数partial(logged2,level = level,name = name,message = message),假设是s.所以第一句执行完成后,变成
  96. @s
  97. def add2(x,y)
  99. 2. add2 = s(add2),此时func参数不为None,所以直接走if后面的逻辑。最终返回的add2其实已经是 wrapper 了
  100. 3. add2() --> 本质上是执行wrapper()
  101. """
  102. # 2. 如果传递参数
  103. @logged2(level=logging.CRITICAL,name='add2',message='add2被执行了')
  104. def add2(x,y):
  105.     return x + y
  106.  
  107.  
  108.  
  109. if __name__ == '__main__':
  110.  
  111.  
  112.     print('======logger 正常有参测试==========')
  113.     result = add(1,2) #3
  114.     print(result) #Spam
  115.  
  116.     spam()
  117.  
  118.     # result2 = sub(3,10)
  119.     # print(result2)
  120.  
  121.     print('=====logger2 sub2无参测试===========')
  122.  
  123.     result2 = sub2(10,2)
  124.     # __main__:sub2
  125.     print('result2 = {}'.format(result2)) # result2 = 8
  126.  
  127.     print('=====logger2 add2有参测试===========')
  128.  
  129.     result3 = add2(10, 2)
  130.     #add2:add2被执行了
  131.     print('result3 = {}'.format(result3)) # result3 = 12

三、可自定义属性的装饰器

对应cookbook章节 9.5

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. # @Time    : 2023/8/16 21:17
  4. # @Author  : Maple
  5. # @File    : 05-可自定义属性的装饰器.py
  6. import logging
  7. from functools import partial, wraps
  8.  
  9.  
  10. """
  11. cookbook 9.5
  12. """
  13. def attach_wrapper(obj,func = None):
  14.     if func is None:
  15.         return partial(attach_wrapper,obj)
  16.  
  17.     setattr(obj,func.__name__,func)
  18.     return func
  19.  
  20. def logged(level,name = None ,msg = None):
  21.  
  22.     def decorate(func):
  23.         log_name = name if name else func.__module__
  24.         log = logging.getLogger(log_name)
  25.         log_msg = msg if msg else func.__name__
  26.  
  27.         @wraps(func)
  28.         def wrapper(*args,**kwargs):
  29.             log.log(level, log_msg)
  30.             print('level:',level,'log_msg',log_msg)
  31.             func(*args,**kwargs)
  32.  
  33.         # 通过装饰器,给wrapper设置一个属性，属性名字就是被装饰函数:即set_level,然后属性值是 该函数的引用
  34.         # 所以调用wrapper的set_level属性时，本质上就是在调用该方法。然后该方法会修改 level的值
  35.         @attach_wrapper(wrapper)
  36.         def set_level(new_level):
  37.             # 申明该变量不是函数set_level中的局部变量,而是函数之外 logged函数中的参数
  38.             nonlocal level
  39.             level = new_level
  40.  
  41.         @attach_wrapper(wrapper)
  42.         def set_message(new_msg):
  43.             # 注意这里不要去改msg的值,而是要去修改log_msg
  44.             # 1. 因为方法调用set_message的时候，首先跳到这里修改局部变量的值
  45.             # 2. 然后跳到 wrapper方法,所以 如果修改msg的值, 由于[log_msg = msg if msg else func.__name__]这段代码(在wrapper上面)根本不会执行，所以msg的值也就无法改变
  46.             nonlocal log_msg
  47.             log_msg = new_msg
  48.  
  49.         return wrapper
  50.  
  51.     return decorate
  52.  
  53.  
  54. @logged(level=logging.DEBUG,name = '罗二',msg="你也有今天")
  55. def add(a,b):
  56.     return a + b
  57.  
  58. if __name__ == '__main__':
  59.  
  60.  
  61.     result = add(1,2)
  62.     print('----------------')
  63.  
  64.     # 执行顺序
  65.     ## 1. add此时是 wrapper
  66.     ## 2. 而 set_level是wrapper中的一个实例属性，且对用的值是fun set_level
  67.     ## 3. 因此以下语句会执行set_level逻辑，将level 修改为logging.INFO)
  68.  
  69.     add.set_level(logging.INFO)
  70.     ## 4. 执行 wrapper中的逻辑：log.log(level, log_msg).....,注意此时level已经被修改成logging.INFO
  71.     result = add(1, 2)
  72.  
  73.     print('----------------')
  74.     add.set_message('好汉不提当年勇')
  75.     result = add(1, 2)

四、强制参数类型检测

对应cookbook章节 9.7
  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. # @Time    : 2023/8/5 0:53
  4. # @Author  : Maple
  5. # @File    : 03-强制参数类型检测.py
  6.  
  7. from inspect import signature
  8. from functools import wraps
  9.  
  10. """
  11. 对应cookbook 9.7
  12. """
  13.  
  14. def typeassert(*ty_args,**ty_kwargs):
  15.  
  16.     def decorate(func):
  17.         # 如果是优化执行模式，不进行参数类型检查
  18.         if not __debug__:
  19.             return func
  20.  
  21.         sig = signature(func)
  22.  
  23.         # 自定义的参数类型限制条件,Sample：OrderedDict([('x', <class 'int'>), ('z', <class 'int'>)])
  24.         bound_types = sig.bind_partial(*ty_args,**ty_kwargs).arguments
  25.         print('bound_types',bound_types) # OrderedDict([('x', <class 'int'>), ('z', <class 'int'>)])
  26.  
  27.         @wraps(func)
  28.         def wrapper(*args,**kwargs):
  29.             # 被装饰函数所有实参的sig 字典,bound_values.arguments:OrderedDict([('x', 1), ('y', 2), ('z', 3)])
  30.             bound_values = sig.bind(*args,**kwargs) # <BoundArguments (a=1, b=2, c=1)>
  31.  
  32.             for name,value in  bound_values.arguments.items():
  33.                 if name in bound_types:
  34.                     if not isinstance(value,bound_types[name]):
  35.                         raise TypeError('参数{} Expect type {}'.format(name, bound_types[name]))
  36.  
  37.             return func(*args,**kwargs)
  38.  
  39.         return wrapper
  40.  
  41.     return decorate
  42.  
  43. @typeassert(int,c=str)
  44. def add(a,b,c='maple'):
  45.     print(a,b,c)
  46.  
  47.  
  48. if __name__ == '__main__':
  49.  
  50.     sig = signature(add)
  51.  
  52.     bound_values = sig.bind(1,2,c = 1)
  53.     print(bound_values.arguments)
  54.  
  55.  
  56.     add(1,2,'Maple')
  57.     try:
  58.         add('I', 2, 'Maple') # TypeError: 参数a Expect type <class 'int'>
  59.  
  60.     except TypeError as e:
  61.         print(e)
  62.  
  63.     try:
  64.         add(1, 3, 3)
  65.     except TypeError as e:
  66.         print(e) # 参数c Expect type <class 'str'>

五、类装饰器

对应cookbook章节：9.8 和 9.9
  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. # @Time    : 2023/8/5 1:55
  4. # @Author  : Maple
  5. # @File    : 04-装饰器类.py
  6.  
  7. """
  8. 对应cookbook章节：9.8 和 9.9
  11. """
  12.  
  13.  
  14. # 1. 将装饰器定义为类的一部分
  15. import types
  16. from functools import wraps
  17.  
  18.  
  19. class A:
  20.  
  21.     def decorator1(self,func):
  22.         @wraps(func)
  23.         def wrapper(*args,**kwargs): # 内部的wrapper方法通常不需要传入self 或者 cls
  24.             print('decorator1')
  25.             return func(*args,**kwargs)
  26.  
  27.         return wrapper
  28.  
  29.     @classmethod
  30.     def decorator2(cls, func):
  31.         def wrapper(*args, **kwargs):
  32.             print('decorator2')
  33.             return func(*args, *kwargs)
  34.  
  35.         return wrapper
  36.  
  37. a = A()
  38.  
  39. @a.decorator1
  40. def add(a,b):
  41.     return a + b
  42.  
  43. @A.decorator2
  44. def sub(a,b):
  45.     return a - b
  46.  
  47.  
  48. """
  49. @property 的getter(), setter(), deleter()，其实就是在类中定义的三个装饰器
  50. """
  51.  
  52. class Person:
  53.  
  54.     def __init__(self,name):
  55.         self._first_name = name
  56.  
  57.     # 创建一个类的实例
  58.     first_name = property()
  59.  
  60.     # 通过类的实例中的getter方法,实现装饰器的功能
  61.     @first_name.getter
  62.     def first_name(self):
  63.         return self._first_name
  64.  
  65.     @first_name.setter
  66.     def first_name(self,value):
  67.         if not isinstance(value,str):
  68.             raise TypeError('Expect str type')
  69.  
  70.  
  71. # 2. 将类定义为装饰器
  72. # ！！！get 方法:还是没有彻底理解
  73. class Profiled:
  74.     def __init__(self,func):
  75.         wraps(func)(self)
  76.         self.ncalls = 0
  77.  
  78.     def __call__(self, *args, **kwargs):
  79.         self.ncalls += 1
  80.         print('装饰器类被调用了{}次'.format(self.ncalls))
  81.         return self.__wrapped__(*args,**kwargs)
  82.  
  83.     def __get__(self, instance, cls):
  84.         if instance is None:
  85.             return self
  86.         else:
  87.             # 该方法是为实例/类动态增加方法，第一个参数应该是方法,但这里是Profiled类的一个实例, 不懂~~
  88.             ## 返回结果是
  89.             print('get 方法被调用')
  90.             print('self',self)
  91.             print('instance:',instance)
  92.             print('cls:',cls)
  93.             return types.MethodType(self,instance)
  94.  
  95. @Profiled
  96. def mul(a,b):
  97.     return a * b
  98.  
  99.  
  100. class Spam:
  101.     @Profiled
  102.     def div(self,a,b):
  103.         return a / b
  104.  
  105. class Spam2:
  106.     def div(self,a,b):
  107.         return a / b
  108.  
  109.  
  110. if __name__ == '__main__':
  111.  
  112.     result1 = add(1,2)
  113.     print(result1)
  114.  
  115.  
  116.     print('=================')
  117.     result2 = sub(10,2)
  118.     print(result2)
  119.  
  120.     print('=================')
  121.     p = Person('Maple')
  122.     print(p.first_name)
  123.     # p.first_name = 12
  124.  
  125.     print('======将类定义为装饰器测试===========')
  126.     mul(1,2) # 装饰器类被调用了1次
  127.     mul(1,2) # 装饰器类被调用了2次
  128.     print(mul.ncalls) # 2
  129.  
  130.     print('---------------------------')
  131.     """
  132.     执行步骤:
  133.      1. 实例化Profiled，Profiled 装饰Spam,然后才实例化Spam,得到s
  134.      2. 调用s.div(10,2),进到Profiled类的get方法，返回一个Spam的bound方法
  135.      3. 调用Profiled的call 方法，执行self.__wrapped__(*args,**kwargs)，其实self.__wrapped__为Spam的bound方法(Spam.div,就是被装饰的函数)
  136.         ,执行spam.div()方法，得到最终结果
  137.     
  138.     """
  139.     s = Spam()
  140.     print('s',s)
  141.     s.div(10,2) # 装饰器类被调用了1次
  142.     s.div(15, 5) # 装饰器类被调用了1次
  143.     print(s.div.ncalls)  # 2
  144.  
  145.     # 装饰器的用法等价于:
  146.     print('======装饰器的用法等价测试===========')
  147.     s2 = Spam2()
  148.     s2  = Profiled(s2.div)
  149.     print(s2(15,3))

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/435082
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号