本文实例讲述了Python函数装饰器原理与用法。分享给大家供大家参考，具体如下：
装饰器本质上是一个函数，该函数用来处理其他函数，它可以让其他函数在不需要修改代码的前提下增加额外的功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等应用场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。
严格来说，装饰器只是语法糖，装饰器是可调用的对象，可以像常规的可调用对象那样调用，特殊的地方是装饰器的参数是一个函数。
import time #遵守开放封闭原则 def foo(): start = time.time() # print(start) # 1504698634.0291758从1970年1月1号到现在的秒数，那年Unix诞生 time.sleep(3) end = time.time() print('spend %s'%(end - start)) foo()
bar()、bar2()也有类似的需求，怎么做？再在bar函数里调用时间函数？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个函数：专门设定时间:
import time def show_time(func): start_time=time.time() func() end_time=time.time() print('spend %s'%(end_time-start_time)) def foo(): print('hello foo') time.sleep(3) show_time(foo)
但是这样的话,你基础平台的函数修改了名字，容易被业务线的人投诉的，因为我们每次都要将一个函数作为参数传递给show_time函数。而且这种方式已经破坏了原有的代码逻辑结构，之前执行业务逻辑时，执行运行foo()，但是现在不得不改成show_time(foo)。那么有没有更好的方式的呢？当然有，答案就是装饰器。
def show_time(f): def inner(): start = time.time() f() end = time.time() print('spend %s'%(end - start)) return inner @show_time #foo=show_time(f) def foo(): print('foo...') time.sleep(1) foo() def bar(): print('bar...') time.sleep(2) bar()
输出结果：
foo...
spend 1.0005607604980469
bar...
函数show_time就是装饰器，它把真正的业务方法f包裹在函数里面，看起来像foo被上下时间函数装饰了。在这个例子中，函数进入和退出时 ，被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。
@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作
装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。
装饰器有２个特性，一是可以把被装饰的函数替换成其他函数， 二是可以在加载模块时候立即执行
def decorate(func): print('running decorate', func) def decorate_inner(): print('running decorate_inner function') return func() return decorate_inner @decorate def func_1(): print('running func_1') if __name__ == '__main__': print(func_1) #running decorate <function func_1 at 0x000001904743DEA0> # <function decorate.<locals>.decorate_inner at 0x000001904743DF28> func_1() #running decorate_inner function # running func_1
通过args 和 *kwargs 传递被修饰函数中的参数
1 def decorate(func): 2 def decorate_inner(*args, **kwargs): 3 print(type(args), type(kwargs)) 4 print('args', args, 'kwargs', kwargs) 5 return func(*args, **kwargs) 6 return decorate_inner 7 @decorate 8 def func_1(*args, **kwargs): 9 print(args, kwargs) 10 if __name__ == '__main__': 11 func_1('1', '2', '3', para_1='1', para_2='2', para_3='3') 12 #返回结果 13 #<class 'tuple'> <class 'dict'> 14 # args ('1', '2', '3') kwargs {'para_1': '1', 'para_2': '2', 'para_3': '3'} 15 # ('1', '2', '3') {'para_1': '1', 'para_2': '2', 'para_3': '3'}
带参数的被装饰函数
1 import time 2 # 定长 3 def show_time(f): 4 def inner(x,y): 5 start = time.time() 6 f(x,y) 7 end = time.time() 8 print('spend %s'%(end - start)) 9 return inner 10 @show_time 11 def add(a,b): 12 print(a+b) 13 time.sleep(1) 14 add(1,2)
不定长
1 import time 2 #不定长 3 def show_time(f): 4 def inner(*x,**y): 5 start = time.time() 6 f(*x,**y) 7 end = time.time() 8 print('spend %s'%(end - start)) 9 return inner 10 @show_time 11 def add(*a,**b): 12 sum=0 13 for i in a: 14 sum+=i 15 print(sum) 16 time.sleep(1) 17 add(1,2,3,4)
带参数的装饰器
在上面的装饰器调用中，比如@show_time，该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。
1 import time 2 def time_logger(flag=0): 3 def show_time(func): 4 def wrapper(*args, **kwargs): 5 start_time = time.time() 6 func(*args, **kwargs) 7 end_time = time.time() 8 print('spend %s' % (end_time - start_time)) 9 if flag: 10 print('将这个操作的时间记录到日志中') 11 return wrapper 12 return show_time 13 @time_logger(flag=1) 14 def add(*args, **kwargs): 15 time.sleep(1) 16 sum = 0 17 for i in args: 18 sum += i 19 print(sum) 20 add(1, 2, 5)
@time_logger(flag=1) 做了两件事：
（1）time_logger(1)：得到闭包函数show_time，里面保存环境变量flag
（2）@show_time ：add＝show_time(add)
上面的time_logger是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器(一个含有参数的闭包函数)。当我 们使用@time_logger(1)调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。
叠放装饰器
执行顺序是什么
如果一个函数被多个装饰器修饰，其实应该是该函数先被最里面的装饰器修饰后（下面例子中函数main()先被inner装饰，变成新的函数），变成另一个函数后，再次被装饰器修饰
1 def outer(func): 2 print('enter outer', func) 3 def wrapper(): 4 print('running outer') 5 func() 6 return wrapper 7 def inner(func): 8 print('enter inner', func) 9 def wrapper(): 10 print('running inner') 11 func() 12 return wrapper 13 @outer 14 @inner 15 def main(): 16 print('running main') 17 if __name__ == '__main__': 18 main() 19 #返回结果 20 # enter inner <function main at 0x000001A9F2BCDF28> 21 # enter outer <function inner.<locals>.wrapper at 0x000001A9F2BD5048> 22 # running outer 23 # running inner 24 # running main
类装饰器
相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。
1 import time 2 class Foo(object): 3 def __init__(self, func): 4 self._func = func 5 def __call__(self): 6 start_time=time.time() 7 self._func() 8 end_time=time.time() 9 print('spend %s'%(end_time-start_time)) 10 @Foo #bar=Foo(bar) 11 def bar(): 12 print ('bar') 13 time.sleep(2) 14 bar() #bar=Foo(bar)()>>>>>>>没有嵌套关系了,直接active Foo的 __call__方法
标准库中有多种装饰器
例如：装饰方法的函数有property, classmethod, staticmethod； functools模块中的lru_cache, singledispatch, wraps 等等
from functools import lru_cache
from functools import singledispatch
from functools import wraps
functools.wraps使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表，先看例子：
好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数一样的元信息了。
1 def foo(): 2 print("hello foo") 3 print(foo.__name__)# foo 4 def logged(func): 5 def wrapper(*args, **kwargs): 6 print (func.__name__ + " was called") 7 return func(*args, **kwargs) 8 return wrapper 9 @logged 10 def cal(x): 11 resul=x + x * x 12 print(resul) 13 cal(2) 14 #6 15 #cal was called 16 print(cal.__name__)# wrapper 17 print(cal.__doc__)#None 18 #函数f被wrapper取代了，当然它的docstring，__name__就是变成了wrapper函数的信息了。
使用装饰器会产生我们可能不希望出现的副作用， 例如：改变被修饰函数名称，对于调试器或者对象序列化器等需要使用内省机制的那些工具，可能会无法正常运行；
其实调用装饰器后，会将同一个作用域中原来函数同名的那个变量（例如下面的func_1）,重新赋值为装饰器返回的对象；使用＠wraps后，会把与内部函数（被修饰函数，例如下面的func_1）相关的重要元数据全部复制到外围函数（例如下面的decorate_inner）
1 from functools import wraps 2 def decorate(func): 3 print('running decorate', func) 4 @wraps(func) 5 def decorate_inner(): 6 print('running decorate_inner function', decorate_inner) 7 return func() 8 return decorate_inner 9 @decorate 10 def func_1(): 11 print('running func_1', func_1) 12 if __name__ == '__main__': 13 func_1() 14 #输出结果 15 #running decorate <function func_1 at 0x0000023E8DBD78C8> 16 # running decorate_inner function <function func_1 at 0x0000023E8DBD7950> 17 # running func_1 <function func_1 at 0x0000023E8DBD7950>
---2019.11.21 21:13--多练习，熟能生巧--<https://www.jb51.net/article/167769.htm>