元编程的主要目标是创建函数和类，并用它们来操纵代码（比如修改、生成或者包装已有的代码）。Python中基于这个目的的主要特性包括装饰器、类装饰器以及元类。
9.1 给函数添加一个包装
问题
我们想给函数添加一个包装以添加额外的处理。
解决方案
写一个简单的装饰器
import time
from functools import wraps
def timethis(func):
'''
:param func: Decorator that reports the execution time
:return: func
'''
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(func.__name__, end - start)
return result
# 返回一个函数
return wrapper
@timethis
def countdown(n):
while n > 0:
n -= 1
if __name__ == '__main__':
print(countdown(10000))
print(countdown(10000000))
讨论：
装饰器是一个函数，它可以接收一个函数作为输入并返回一个新的函数作为输出。
@timethis def countdown(n):
这个的意思就是countdown = timethis(countdown)
类里面的内置的@staticmethod, @classmethos, @property都是一样的逻辑
9.2编写装饰器时如何保存函数的元数据。
问题：
我们已经编写好一个装饰器，但是当将它用在一个函数上时，一些重要的元数据比如函数名、文档字符串、函数注释以及调用签名都丢失了。
解决方案：
functools.wraps
import time
from functools import wraps
def timethis(func):
'''
:param func: Decorator that reports the execution time
:return: func
'''
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(func.__name__, end - start)
return result
# 返回一个函数
return wrapper
@timethis
def countdown(n: int) -> int:
'''this is countdown'''
while n > 0:
n -= 1
return n
if __name__ == '__main__':
print(countdown(10000))
print(countdown(10000000))
# 函数数据类型
print(countdown.__annotations__)
# 函数名字
print(countdown.__name__)
# 函数文档解释
print(countdown.__doc__)
countdown 0.0006299018859863281
0
countdown 0.5314240455627441
0
{'n': <class 'int'>, 'return': <class 'int'>}
countdown
this is countdown
讨论：
如果取消@wraps
函数的特性都没有了
countdown 0.0007231235504150391
0
countdown 0.5646867752075195
0
{}
wrapper
None
# 取回原函数
print(countdown.__wrapped__)
from inspect import signature
print(signature(countdown))
print(signature(countdown.__wrapped__))
可以通过被装饰函数的__wrapped__取回没有被装饰的函数
9.3 对装饰器进行解包装
问题：
取回没有包装过的函数
解决方案：
通过__wrapped__属性取回
讨论：
只要在装饰器利用了functools.wraps(func)对元数据进行了适当的拷贝，才能用__wrapped__属性取出。
多个装饰器的时候，看__wrapped__的效果。
from functools import wraps
def decorator1(func):
@wraps(func)
def wrapper(*args):
print('Decorator1')
return func(*args)
return wrapper
def decorator2(func):
@wraps(func)
def wrapper(*args):
print('Decorator2')
return func(*args)
return wrapper
@decorator1
@decorator2
def add(x, y):
return x+y
if __name__ == '__main__':
print(add(2,3))
print('=' * 10 )
# 取回的是decorator2函数
print(add.__wrapped__(3,4))
print('=' * 10)
# 取回的是原来的函数
print(add.__wrapped__.__wrapped__(3, 4))
/usr/local/bin/python3.7 /Users/shijianzhong/study/PythonCookbook/chapter_9/t3_3.py Decorator1 Decorator2 5 ========== Decorator2 7 ========== 7 Process finished with exit code 0
Python3.7已经修改了这个漏洞，不会直接穿越到元素的函数了。
但请注意并不是所有的装饰器都使用了@wraps，因此有些装饰器的行为可能与我们预期的有所区别，特别是，由内建的装饰器@staitcmethod和@classmethod创建的描述符对象并不遵循这个约定（相反，它们会把原始函数保存在__func__属性中）。
9.4定义一个可接收参数的装饰器
问题：
编写一个可接收掺乎的装饰器
解决方案：
编写一个装饰器工厂，书中用了logging模块，编写装饰器工厂，刚好我也重新复习下logging模块
from functools import wraps
import logging
import time
def logged(level, name=None, message=None):
def decorate(func):
logname = name if name else func.__name__
# 获取一个log输出对象流
log = logging.getLogger(logname)
logmsg = message if message else func.__name__
@wraps(func)
def wrapper(*args, **kwargs):
# 输出log信息
# log.setLevel(logging.ERROR)
# print(log.level)
log.log(level, logmsg)
return func(*args, **kwargs)
return wrapper
return decorate
@logged(logging.DEBUG)
def add(x, y):
return x+y
@logged(logging.CRITICAL, 'example')
def spam():
print('Spam!')
if __name__ == '__main__':
print(add(1, 2))
print('=' * 10)
time.sleep(1)
print(spam())
/usr/local/bin/python3.7 /Users/shijianzhong/study/PythonCookbook/chapter_9/t4_2.py 3 ========== spam Spam! None Process finished with exit code 0
通过装饰器工厂的主要作用就是可以传递参数给内部函数调用，这里传入的是logging的等级
讨论
@decorator(x, y, z)
def func(a, b):
...
其实底层运行的是
func = decorator(x,y,z)(func)
decorator(x,y,z)返回的必须是一个可调用对象。
9.5 定义一个属性可由用户修改的装饰器
问题
我们想编写一个装饰器来包装函数，但是可以让用户调整装饰器的属性，这样在运行时能够控制装饰器的行为
解决方案:
编写一个访问器函数，通过nonlocal关键字变量来修改装饰器内部的属性。之后把访问器函数作为函数属性附加到包装函数上。
我自己写的测试，根本不需要访问器函数，直接在包装函数外面定义包装函数的属性为函数。
from functools import wraps, partial
import logging
import time
logging.basicConfig(level=logging.DEBUG)
# 访问起函数，是一个简化版的装饰器工厂函数，使用了partial技巧
def attach_wrapper(obj, func=None):
if func is None:
return partial(attach_wrapper, obj)
setattr(obj, func.__name__, func)
return func
def logged(level, name=None, message=None):
def decorate(func):
# print(func.__wrapped__)
# print(func.__name__)
logname = name if name else func.__name__
# 获取一个log输出对象流
log = logging.getLogger(logname)
logmsg = message if message else func.__name__
@wraps(func)
def wrapper(*args, **kwargs):
# 输出log信息
# log.setLevel(logging.ERROR)
# print(log.level)
log.log(level, logmsg)
return func(*args, **kwargs)
# 装饰器工厂会直接装饰器工厂函数调用两次，第一次传wrapper参数，第二次调用传func参数
# 通过这个装饰器工厂给函数赋值属性
@attach_wrapper(wrapper)
def set_level(newlevel):
nonlocal level
level = newlevel
@attach_wrapper(wrapper)
def set_message(newmsg):
nonlocal logmsg
logmsg = newmsg
wrapper.get_level = lambda :level
wrapper.name = 'sidian'
return wrapper
return decorate
@logged(logging.DEBUG)
def add(x, y):
return x+y
@logged(logging.CRITICAL, 'example')
def spam():
print('Spam!')
if __name__ == '__main__':
print(add.set_message('Hello World'))
print(add(1, 2))
print('=' * 10)
time.sleep(1)
print(spam())
/usr/local/bin/python3.7 /Users/shijianzhong/study/PythonCookbook/chapter_9/t5_2.py DEBUG:add:Hello World None 3 ========== Spam! None CRITICAL:example:spam
其实我自己在写的过程中发现，不写访问起函数，
wrapper.get_level = lambda :level wrapper.name = 'sidian'
定义内部函数，然后给内部函数添加属性为函数也可以，相对来说就是多一步手工添加，但可以避免写访问器函数。
讨论：
装饰器都使用了@functoos.wrap的话，内层函数可以括约多个装饰器层进行传播。
9.6定义一个能接收可选参数的装饰器
问题：
我们想编写一个单独的装饰器，使其即可以像@decorator这样不带参数使用，也可以像@decorator(x,y,z)使用装饰器工厂这么用。
解决方案：
定义装饰器函数的传参方式里面有*,通过functools.partail返回一个函数。
from functools import wraps
import logging
import functools
import time
def logged(func=None, *, level=logging.WARNING, name=None, message=None):
# 如果没有传入func，就返回这个partial定义好的函数，第二次执行这个函数，并自动传参被装饰的函数
if func is None:
return functools.partial(logged, level=level, name=name, message=message)
logname = name if name else func.__name__
# 获取一个log输出对象流
log = logging.getLogger(logname)
logmsg = message if message else func.__name__
@wraps(func)
def wrapper(*args, **kwargs):
# 输出log信息
# log.setLevel(logging.ERROR)
# print(log.level)
log.log(level, logmsg)
return func(*args, **kwargs)
return wrapper
@logged
def add(x, y):
return x+y
@logged(level=logging.CRITICAL, name='example')
def spam():
print('Spam!')
if __name__ == '__main__':
print(add(1, 2))
print('=' * 10)
time.sleep(1)
print(spam())
讨论：
整个重点一点要了解到
@decorator(x, y, z)
def func(a, b):
...
其实底层运行的是
func = decorator(x,y,z)(func) 这个是重中之重
decorator(x,y,z)返回的必须是一个可调用对象。
9.7 利用装饰器对函数参数强制执行类型检查（感觉还是非常有用的）
问题
我们想为函数参数添加强制性的类型检查功能，将其作为一种断言或者调用者之间的契约。
解决方法
from inspect import signature
from functools import wraps, partial
def typeassert(*ty_args, **ty_kwargs):
def decorate(func):
# 如果为非debug模式，返回函数本身
if not __debug__:
return func
sig = signature(func)
# print(sig) # (x, y, z=42) 函数的参数签名信息，<class 'inspect.Signature'>形式
bound_types = sig.bind_partial(*ty_args, **ty_kwargs).arguments
# print(bound_types)
# 通过bind_partial可以给每个参数绑定对象，采用OrderDict形式OrderedDict([('x', <class 'int'>), ('z', <class 'int'>)])
@wraps(func)
def wrapper(*args, **kwargs):
# 因为func如果设置由默认值，则sig对面里面保存着由默认值的信息。
bound_values = sig.bind(*args, **kwargs)
# print(bound_values.arguments.items())
# 通过两个输入参数后，对比有序字典
for name, value in bound_values.arguments.items():
if name in bound_types:
if not isinstance(value, bound_types[name]):
raise TypeError(
'Argument {} must be {}'.format(name, bound_types[name])
)
return func(*args, **kwargs)
return wrapper
return decorate
if __name__ == '__main__':
@typeassert(int, z=int)
def spam(x, y, z=[]):
print(x, y, z)
spam(1, 2, 3)
spam(1, [])
spam(1, 2, '')
/usr/local/bin/python3.7 /Users/shijianzhong/study/PythonCookbook/chapter_9/t7_2.py
Traceback (most recent call last):
File "/Users/shijianzhong/study/PythonCookbook/chapter_9/t7_2.py", line 38, in <module>
spam(1, 2, '')
File "/Users/shijianzhong/study/PythonCookbook/chapter_9/t7_2.py", line 26, in wrapper
'Argument {} must be {}'.format(name, bound_types[name])
TypeError: Argument z must be <class 'int'>
1 2 3
1 [] []
Process finished with exit code 1
讨论:
这里主要用到了inspect模块的一些功能
特别是sig = inspect.signature()
sig.bind与sig.bindpartail两个方法绑定输入的参数，通过arrgment.items字典形式输出。整个逻辑相对不是很复制，但需要了解很多内置模块的功能。
9.8在类中定义装饰器
问题：
我们想在类中定义一个装饰器，并将其作用于其他的函数或者方法上
解决方法：
from functools import wraps
class A:
# 实例装饰器方法
def decorator1(self, func):
@wraps(func)
def wrapper(*args, **kwargs):
print('Decorator 1')
return func(*args, **kwargs)
return wrapper
# 类装饰器函数
@classmethod
def decorator2(cls, func):
@wraps(func)
def wrapper(*args, **kwargs):
print('Decorator 2')
return func(*args, **kwargs)
return wrapper
a = A()
@a.decorator1
def spam():
...
@A.decorator2
def grok():
...
spam()
grok()
讨论
我们的 propery类就用了这个
class Person:
# 这个类属性是实例
first_name = property()
# 调用实例方法的装饰器
@first_name.getter
def first_name(self):
return self._first_name
@first_name.setter
def first_name(self, value):
self._first_name = value
if __name__ == '__main__':
p = Person()
p.first_name = 'sh'
print(p.first_name)
9.9把装饰器定义成类
问题：
我们想用装饰器来包装函数，但是希望得到的结果是一个可调用的实例。我们需要装饰器既能在类中工作，也可以在类外部使用。
解决方案：
import types
from functools import wraps
class Profiled:
def __init__(self, func):
wraps(func)(self)
self.ncalls = 0
def __call__(self, *args, **kwargs):
self.ncalls += 1
return self.__wrapped__(*args, **kwargs)
# 定义__get__使的返回的对象可以在调用时，成本绑定对象instance的方法
def __get__(self, instance, owner):
# print(instance, owner)
if instance is None:
print('123')
return self
else:
# 将自身的__call__方法变成instance的方法
return types.MethodType(self, instance)
@Profiled
def add(x, y):
return x+y
class Spam:
@Profiled
def bar(self, x ):
print(self, x)
if __name__ == '__main__':
print(add(2, 3))
print(add.ncalls)
s = Spam()
s.bar(1)
所以用类写装饰器相对非常的麻烦，一定要定义__get__才能给方法进行装饰，没什么特殊情况，还使通过普通函数写，因为函数默认内置定义好了__get__方法。
讨论:
from functools import wraps
# 普通的函数装饰器，方便很多
def profiled(func):
ncalls = 0
@wraps(func)
def wrapper(*args, **kwargs):
nonlocal ncalls
ncalls += 1
return func(*args, **kwargs)
# 必须属性赋值使函数，这样才有运行这个函数，或者最新的数据。
# 这里就像一个读取闭包函数的属性，必须通过函数来读取
wrapper.ncalls = lambda :ncalls
return wrapper
@profiled
def add(x, y):
return x+y
class Spam:
@profiled
def bar(self, x ):
print(self, x)
if __name__ == '__main__':
print(add(2, 3))
print(add(3 ,4))
print(add.ncalls())
s = Spam()
s.bar(1)
9.10 把装饰器作用到类和静态方法上
问题：
我们想在类或者静态方法上应用装饰器
解决方案
直接写上装饰器就可以了，但必须在@classmethod和@staticmethod之前
from functools import wraps
import time
def timethis(func):
'''
:param func: Decorator that reports the execution time
:return: func
'''
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(func.__name__, end - start)
return result
# 返回一个函数
return wrapper
class Spam:
@timethis
def instance_method(self, n):
print(self, n)
while n > 0:
n -=1
@classmethod
@timethis
def class_method(cls, n):
print(cls, n)
while n > 0:
n -= 1
@staticmethod
@timethis
def static_method(n):
print(n)
while n > 0:
n -= 1
if __name__ == '__main__':
s = Spam()
s.instance_method(1000000)
Spam.class_method(1000000)
Spam.static_method(100000)
讨论：
前面不要搞错位置，@classmethod和@staitcmethod并不会实际创建可直接调用的对象。相反，它们创建的是特殊的描述符对象。
9.11编写装饰器为被包装的函数添加参数
问题：
我们想编写一耳光装饰器为被包装的函数添加额外的参数。但是，添加的参数不能影响到该函数的已有的调用约定。
解决方案
通过函数那章学习到的keyword-only参数，额外的参数注入到函数的调用签名。
from functools import wraps
def optional_debug(func):
@wraps(func)
# keyword-only参数传入
def wrapper(*args, debug=False, **kwargs):
if debug:
print('Calling', func.__name__)
return func(*args, **kwargs)
return wrapper
@optional_debug
def spam(a, b, c):
print(a, b, c)
if __name__ == '__main__':
spam(1, 2, 3, debug=True)
print('='*20)
spam(1, 2, 3)
讨论：
我前面的代码中，如果被装修的函数的参数里面与keyword-only中的参数一样，有可能名称冲突，为了避免，应该增加参数选择。
from functools import wraps
import inspect
def optional_debug(func):
# 对函数的默认变量名参数的变量名进行查寻
args = inspect.getfullargspec(func).args
# print(args)
if 'debug' in args:
raise TypeError('debug argument already defined')
@wraps(func)
# keyword-only参数传入
def wrapper(*args, debug=False, **kwargs):
if debug:
print('Calling', func.__name__)
return func(*args, **kwargs)
return wrapper
@optional_debug
def spam(a, b, c):
print(a, b, c)
if __name__ == '__main__':
spam(1, 2, 3, debug=True)
print('='*20)
spam(1, 2, 3)
from functools import wraps
import inspect
def optional_debug(func):
# 对函数的默认变量名参数的变量名进行查寻
args = inspect.getfullargspec(func).args
# print(args)
if 'debug' in args:
raise TypeError('debug argument already defined')
@wraps(func)
# keyword-only参数传入
def wrapper(*args, debug=False, **kwargs):
if debug:
print('Calling', func.__name__)
return func(*args, **kwargs)
# 下面使修改被装饰函数的参数签名信息
sig = inspect.signature(func)
params = list(sig.parameters.values())
# print(params)
params.append(inspect.Parameter('debug',
inspect.Parameter.KEYWORD_ONLY,
default=False))
wrapper.__signature__ = sig.replace(parameters=params)
return wrapper
@optional_debug
def spam(a, b, c):
print(a, b, c)
if __name__ == '__main__':
spam(1, 2, 3, debug=True)
print('='*20)
spam(1, 2, 3)
print(inspect.signature(spam))
/usr/local/bin/python3.7 /Users/shijianzhong/study/PythonCookbook/chapter_9/t11_3.py [<Parameter "a">, <Parameter "b">, <Parameter "c">] Calling spam 1 2 3 ==================== 1 2 3 (a, b, c, *, debug=False) Process finished with exit code 0
9.12 利用装饰器给类打补丁