1给函数添加一个包装
问题：给函数加一个外包装层，已添加额外的处理，例如，记录日志，计时统计等
解决方案：可以定义一个装饰器来包装函数
2编写装饰器时如何保存函数的元数据
问题：当一个函数被装饰器装饰时，一些重要的元数据比如：函数名、文档字符串、函数注解以及调用签名都丢失了
解决方案：每当定义一个装饰器时应该总是记得为底层的包装函数添加functools库中的@wraps装饰器
#问题：当一个函数被装饰器装饰时，一些重要的元数据比如：函数名、文档字符串、函数注解以及调用签名都丢失了
#解决方案：每当定义一个装饰器时应该总是记得为底层的包装函数添加functools库中的@wraps装饰器
import time
import functools
def timethis(func):
@functools.wraps(func)
def wrapper(*args,**kwargs):
start_time = time.time()
result = func(*args,**kwargs)
end_time = time.time()
print(func.__name__,end_time-start_time)
return result
return wrapper
@timethis
def mysleep(num:int):
"""
原函数注释文档
:param num:
:return:
"""
time.sleep(num)
print("我是原函数")
mysleep(3)
print(mysleep.__name__)
print(mysleep.__doc__)
print(mysleep.__annotations__)
#如果装饰器使用@functools.wraps(func) 装饰，我们就可以使用下面的方法获取到原函数！！！
mysleep.__wrapped__(3)
3对装饰器进行解包装
问题： 我们已经把装饰器添加到函数上了，但是想撤销它，访问未经包装的原函数。
解决方案：假设装饰器已经实现了@warps(func)，一般来说我们可以通过访问__wrapped__属性来获取到原函数
4定义一个可接收参数的装饰器
问题：我们想编写一个可接收参数的装饰器函数
解决方案：假设我们想编写一个为函数添加日志功能的装饰器，但是又允许用户指定日志的等级以及一些其他的细节操作作为参数。
import logging
import functools
def logged(level,name=None,message=None):
def decorate(func):
logname = name if name else func.__module__
log = logging.getLogger(logname)
logmsg = message if message else func.__name__
@functools.wraps(func)
def wrapper(*args,**kwargs):
log.log(level,message)
return func(*args,**kwargs)
return wrapper
return decorate
5定义一个属性可由用户修改的装饰器
问题：我们想编写一个装饰器来包装函数，但是可以让用户调整装饰器的属性，这样在运行时就能够控制装饰器的行为
from functools import wraps,partial
import logging
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):
logname = name if name else func.__module__
log = logging.getLogger(logname)
logmsg = message if message else func.__name__
@wraps(func)
def wrapper(*args,**kwargs):
log.log(level,logmsg)
return func(*args,**kwargs)
@attach_wrapper(wrapper)
def set_level(newlevel):
nonlocal level
level = newlevel
@attach_wrapper(wrapper)
def set_message(newmsg):
nonlocal logmsg
logmsg = newmsg
return wrapper
return decorate
logging.basicConfig(level=logging.DEBUG)
@logged(logging.DEBUG)
def add(x,y):
return x + y
add(2,5)
add.set_message("Add called")
add(3,8)
6定义一个能接收可选参数的装饰器
问题：我们想编写一个单独的装饰器，使其既可以像@decorator 这样不带参数，也可以像@decorator(x,y,z)这样接收可选参数
from functools import wraps,partial
import logging
def logged(func=None,*,level=logging.DEBUG,name=None,message=None):
if func is None:
return partial(logged,level=level,name=name,message=message)
logname = name if name else func.__module__
log = logging.getLogger(logname)
logmsg = message if message else func.__name__
@wraps(func)
def wrapper(*args,**kwargs):
log.log(level,logmsg)
return func(*args,**kwargs)
return wrapper
@logged
def add(x,y):
logging.debug("hahahah")
return x+y
#没有参数时，装饰器就相当于：logged(func),所以装饰器的第一个参数就是func,其他都是可选参数
@logged(level=logging.CRITICAL,name="example")
def spam():
print("spam!!!")
#有参数时，装饰器就相当于logged(level=logging.DEBUG,name="example")(spam)
#巧妙的利用functools.partial 将构建好的方法返回
add(1,2)
spam()
7利用装饰器对函数参数强制执行类型检查
问题：我们想为函数参数添加强制类型检查功能，将其作为一种断言或者与调用者之间的契约
from inspect import signature
from functools import wraps
def typeassert(*ty_args,**ty_kwargs):
def decorate(func):
if not __debug__:
return func
sig = signature(func)#获取func的参数签名（x,y,z）
bound_types = sig.bind_partial(*ty_args,**ty_kwargs).arguments# 参数签名与类型参数做映射 [("x",<class "int">),("z",<class "int">)]
@wraps(func)
def wrapper(*args,**kwargs):
bound_values = sig.bind(*args,**kwargs).arguments# 参数签名与函数参数做映射
for name,value in bound_values.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
class A():
def a(self):
print("a")
@typeassert(int,A,z=int)
def add(x,y,z):
print(x,y,z)
return x
add(1,A(),3)
#想法：参数类型的限制可以使用在参数处理方法中，对前端接收的参数进行检查，也可以使用在一些需要限制传入参数类型的地方
#注：此装饰器一个微妙的地方，只检查传递的参数，如果是默认参数，没有进行传递，参数类型不进行检查
@typeassert(int,list)
def bar(x,items=None):
if items is None:
items = []
items.append(x)
return items
print(bar(2))
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
#思考：@property 实际上是一个拥有 getter(),setter(),deleter()方法的类，每一个方法都可作为一个装饰器
#几个装饰器都可以操纵实例的状态，因此，如果需要装饰器在背后记录或合并信息，这是一个很明智的方法。
9把装饰器定义成类
问题： 我们想用装饰器来包装函数，但是希望得到的结果是一个可调用的实例。我们需要装饰器既能在类中工作，也可以在类外部使用
解决方案：要把装饰器定义成类实例，需要确保在类中实现__call__()和__get__()方法
import types
from functools import wraps
class Profield:
def __init__(self,func):
wraps(func)(self)
self.ncalls = 0
def __call__(self, *args, **kwargs):
self.ncalls +=1
return self.__wrapped__(*args,**kwargs)
def __get__(self, instance, cls):
if instance is None:
return self
else:
return types.MethodType(self,instance)
#该装饰器相当于为函数添加一个属性 ncalls
10把装饰器作用到类和静态方法上
问题：我们想在类或者静态方法上应用装饰器
解决方案：将装饰器作用到类和静态方法上是简单而直接的，但是要保证装饰器在应用的时候需要放在@classmethod 和 @staticmethod 之前，示例如下：
import time
from functools import wraps
def timethis(func):
@wraps(func)
def wrapper(*args,**kwargs):
start = time.time()
r = func(*args,**kwargs)
end = time.time()
print(end-start)
return r
return wrapper
@classmethod 和 @staticmethod 装饰器并不会返回一个可执行对象，所以装饰器都要放在他们下面！！！
11编写装饰器为被包装函数添加参数
问题：我们想编写一个装饰器，为被包装的函数添加额外的参数，但是添加的参数不能影响到该函数已有的调用约定
解决方案：
from functools import wraps
def optinoal_debug(func):
@wraps(func)
def wrapper(*args,debug=False,**kwargs):
if debug:
print("Calling",func.__name__)
return func(*args,**kwargs)
return wrapper
函数中的一部分参数被装饰器解析所用，剩下参数给到函数，可以用被包装函数的参数来控制装饰器的行为
12利用装饰器给函数定义打补丁
#问题：我们想检查或改写一部分类的定义，以此来修改类的行为，但是不想通过继承或者元类的方式来做
#解决方案：
def log_getattribute(cls):
orig_getattribute = cls.__getattribute__
def new_getattribute(self,name):
print("getting",name)
return orig_getattribute(self,name)
cls.__getattribute__ = new_getattribute
return cls
@log_getattribute
class A:
def __init__(self,x):
self.x = x
def spam(self):
pass
a = A(42)
a.x
可以通过此方法对类的属性做监控