装饰器

装饰器

需求

一个加法函数，想增强它的功能，能够输出被调用过以及调用的参数信息

def add(x, y):

return x + y

增加信息输出功能

def add(x, y):

print(“call add, x + y”)  # 日志输出到控制台

return x + y p

上面的加法函数是完成了需求，但是有以下的缺点

打印语句的耦合太高

加法函数属于业务功能，而输出信息的功能，属于非业务功能代码，不该放在业务函数加法中

装饰器做到了业务功能分离，但是fn函数调用传参是个问题

def add(x,y):
return x+y
def logger(fn)
print(‘begin’)#增强输出
x = fn(4,5)
print(‘end’)#增强的功能
return
print(logger(add)

解决传参的问题

def add(x,y):
return x+y
def logger(fn,*args,**kwargs):
print(“begin”)
x = fn(*args,**kwargs)
print(‘end’)
return x
print(logger(add,5,y=60))

将函数柯里化

def add(x,y):
return x+y
def logger(fn):
def _logger(*args,**kwargs):
print(“begin”)
x = fn(*args,**kwargs)
print(‘end’)
return x
return _logger
print(logger(add)(5,y=60))

开始变形装饰器

ef logger(fn):
def _logger(*args,**kwargs):
print(“begin”)
x = fn(*args,**kwargs)
print(‘end’)
return x
return _logger
#print(logger(add)(5,y=60))
@logger #等价于add=logger(add)
def add(x,y):
return x+y
print((add(4,50)))

装饰器（无参）

他是一个函数

函数作为他的形参

返回值也是一个函数

可以使用@functioname方式，简化调用

装饰器和高阶函数

装饰器是高阶函数，但是装饰器是对传入函数的功能的装饰（功能增强）

装饰器具体用法

import datetime
import time
def logger(fn):
def wrap(*args,**kwargs):
print(“args={},kwargs={}”.format(args,kwargs))
start = datetime.datetime.now()
ret = fn(*args,**kwargs)
duration =  datetime.datetime.now() – start
print(“function {} took {}s.”.format(fn.__name__,duration.total_seconds()))

return ret
return wrap
@logger #add = logger(add)
def add(x,y):
print(“=============================”)
time.sleep(1)
return x+y
print(add(4,y=10))

Python的文档

Python是文档字符串Documenttstion strings

在函数语句的块的第一行，且习惯是多行的文本，所以多使用三引号

惯例是首字母大写，第一行写概述，空一行，第三行写详细描述

可以使用特殊属性__doc__访问这个文档

def add(x,y):
“””this is function of addtion”””
    a = x+y
return  x+y
print(“name={}\ndoc={}”.format(add.__name__,add.__doc__))
print(help(add))

副作用：原函数对象的属性都被替换了。而使用装饰器，我们的需求是看被封装函数的属性

def logger(fn):
def wrapper(*args,**kwargs):
“iam    wrapper”
        print(“begin”)
x = fn(*args,**kwargs)
print(“end”)
return x
return wrapper
@logger
def add(x,y):
”’his   is a function for add”’
    return x+y
print(“name={},doc={}”.format(add.__name__,add.__doc__))

改进：提供一个函数，本封装函数属性 ==copy==> 包装函数属性

def copy_pro(src,dst):
dst.__name__ = src.__name__
dst.__doc__ = src.__doc__

def logger(fn):
def wrapper(*args,**kwargs):
“l am wrapper”
        print(“begin”)
x = fn(*args,**kwargs)
print(“end”)
return x
copy_pro(fn,wrapper)
return wrapper
@logger
def add(x,y):
“this is function for add”
    return x+y
print(“name={},doc={}”.format(add.__name__,add.__doc__))

通过copy_pro函数将被包装函数的属性覆盖掉包装函数

凡是被装饰的函数都需要复制这些属性，这个函数很通用

可以将复制函数属性的函数构建成装饰器函数，带参装饰器

提供一个函数，被封装函数属性 ==copy==> 包装函数属性改造成带参装饰器

def copy_pro(src):
def _copy(dst):
dst.__name__ = src.__name__
dst.__doc__ = src.__doc__
return dst
return _copy

def logger(fn):
@copy_pro(fn)
def wrapper(*args,**kwargs):
“l am wrapper”
        print(“begin”)
x = fn(*args,**kwargs)
print(“end”)
return x
return wrapper
@logger
def add(x,y):
“this is function for add”
    return x+y
print(“name={},doc={}”.format(add.__name__,add.__doc__))

带参装饰器

获取函数的执行时长，对时长超过阈值的函数记录一下

import datetime
import time
def copy_pro(src):
def _copy(dst):
dst.__name__ = src.__name__
dst.__doc__ = src.__doc__
return dst
return _copy
def logger(duration):
def _logger(fn):
@copy_pro(fn)
def wrapper(*args,**kwargs):
start = datetime.datetime.now()
ret = fn(*args,**kwargs)
delta = (datetime.datetime.now() – start).total_seconds()
print(‘so slow’) if delta > duration else print(“so fast”)
return ret
return wrapper
return _logger
@logger(1)
def add(x,y):
time.sleep(2)
return x + y
print(add(5,6))

带参装饰器

他是一个函数

函数作为它的形参

返回值是一个不带参的装饰器函数

使用@functionname方式调用

可以看做在装饰器外层又加了一层函数

将记录的功能提取出来，这样就可以通过外部提供的函数来灵活的控制输出

import datetime
import time
def copy_pro(src):
def _copy(dst):
dst.__name__ = src.__name__
dst.__doc__ = src.__doc__
return dst
return _copy
def logger(duration,func=lambda name,duration:print(“{} took {}s”.format(name,duration))):
def _logger(fn):
@copy_pro(fn)
def weapper(*args,**kwargs):
start = datetime.datetime.now()
ret = fn(*args,**kwargs)
delta = (datetime.datetime.now() – start).total_seconds()
print(‘ {}s.’.format(delta))
if  delta > duration:
func(fn.__name__,duration)
print(delta)
return ret
return weapper
return _logger
@logger(5)
def add(x,y):
“this is function for add”
    print(“============call add===============”)
return x+y
print(add(4,y=7),add.__name__,add.__doc__)