浅显易懂的谈一谈python中的装饰器！！

Posted 2020-10-01

hello大家好~~我是稀里糊涂林老冷，一天天稀里糊涂的。

前一段时间学习了装饰器，觉着这东西好高大上哇靠！！哈哈，一定要总结一下，方便以后自己查阅，也希望帮助其他伙伴们共同进步！

装饰器：

　　大家可以这样理解，装饰器是运用闭包的基本原理，对一个目标函数进行装饰。即是在执行一个目标函数之前、之后执行一些特定的事情。

　　学习装饰器一定要有闭包的基础知识，如果对闭包不是特别理解的话，可以参考我之前的博文http://www.cnblogs.com/Lin-Yi/p/7305364.html，也可以学习其他大神的博文哦~~~一定要弄明白闭包，要不然装饰器很难理解的。

　　不理解的话举个例子：

　　　　工作中，他写了登录功能，我写了注销功能，他写了保存个人信息功能.........你和你的伙伴是一个团队，你们完成各种各样的功能。但是再软件上线的时候呢，技术总监说了，我们要统计每一个功能模块执行耗费的时间，针对耗费时间太多的功能，可能我们要开会商讨进行优化。

　　　　问题来了，我们团队五六个人，每个人写了两三个功能，都要统计执行实现，是不是每个人都要修改自己的代码，在功能模块函数开始的时候取一下时间，结束的时候取一下时间，然后做一个减法。每一个人的每一个功能都去增加这样一些代码，是不是可麻烦了呢！是不是可浪费时间了呢！！那怎么办？？ 用装饰器！

　　　　我们只需要编写一个装饰器，用这个装饰器对我们写的所有功能进行装饰，就能达到同一个目的！！哈哈哈，很牛有木有！我们一起看看吧~

先上一段代码！！！

 1 import time
 2 #装饰器会用到闭包的原理：外函数内部定义了一个内函数，内函数使用外函数的局部变量，并且外函数返回了内函数的引用
 3 #装饰器函数 传入一个我们想对他装饰的目标函数的引用，将在内函数中使用
 4 def decorator( func ):
 5     def inner():
 6         t1 = time.time() # 目标函数开始之前取一下时间
 7         print("登录前的时间是",t1)
 8         # 这个func外部函数传入的参数，也就是我们希望装饰的目标函数的引用
 9         # 这里实际上执行了目标函数，我们想对这个函数进行装饰，所有在它执行之前和之后进行一番操作，具体什么操作看业务逻辑
10         func()
11         t2 = time.time() # 目标函数结束之后取一下时间
12         print("登录后的时间是",t2)
13         t = t2 - t1 #计算目标函数执行花了多长时间
14         print("登录花费的时间:",t)
15     #在外函数结束时候返回内函数的引用
16     return inner
17 
18 # 上面是我们写的装饰器函数，用装饰器函数可以对一个目标函数进行操作！！
19 ‘‘‘
20 下面的 @decorator 就是是使用装饰函数decorator的意思
21 它实际上执行的是: login = decorator( login )
22 注意，编程语言都是从右向左来解析执行，这句话实际上会发生的事情是：
23     1 把目标函数login(是一个变量名，里面存的是目标函数的引用) 传入decorator函数被参数func接收了
24         这时候func也是目标函数的引用 func和login指向同一个函数对象
25     2 decorator函数定义了内部函数inner，发现里面会使用到func，
26         这用到闭包的原理，外函数结束的时候会把func绑定给内函数将来使用
27     3 外函数结束的时候把自己创建的内函数的引用inner返回给了login接收，
28         这时候login已经不是原来我们编写的目标函数了，login实际上是一个inner函数的实例对象
29         再执行login() 的时候实际上执行了inner()的一个对象
30     4 再执行login() 的时候 实际上执行inner() 
31         会先执行取时间 打印
32         之后执行func()才是执行我们的目标函数
33         最后又取时间 打印结果
34 ‘‘‘
35 @decorator
36 #下面我们写一个函数模拟是登录功能模块的函数，并且用装饰器进行装饰
37 def login():
38     print("用户正在登录！请稍等。。。。")
39     time.sleep(1)
40     print("登录成功！欢迎登录！")
41 
42 
43 
44 if __name__ == ‘__main__‘:
45     #调用login 实际上调用了装饰之后的函数inner的一个对象，inner里的func才是真正的目标函数
46     login()
47     ‘‘‘
48     执行结果:
49         登录前的时间是 1502163280.2836263
50         用户正在登录！请稍等。。。。
51         登录成功！欢迎登录！
52         登录后的时间是 1502163281.2895217
53         登录花费的时间: 1.0058953762054443
54     ‘‘‘

不知道大家有没有看懂这段代码。认真读一读注释的话，我想有闭包基础的伙伴们一定能读懂装饰器。

总之装饰器很神奇，运用引用之间互相改变，实现了一段很厉害的功能！

 

但是呢，其实上面的装饰器非常不好。我写这样一个装饰器，只是为了帮助大家理解装饰器的执行过程和实现的结果。

请大家继续跟着我的思路：

　　我们先回顾一下：上面的目标函数login，当使用@decoration的意思是，login = decoration（login），我们把目标函数当作参数传给了decoration，然后decoration返回了一个inner给login。这时候login就已经不再是之前的login了，而是装饰函数里的inner函数的一个实例对象。当我们再执行login() 实际上执行了inner() ，原来的目标函数被装饰器的func保存了，在inner里面决定了什么时候执行func。

　　但是问题来了！

　　1 如果我们想给这个login目标函数传入参数：当调用login()的时候实际上调用的是inner(),如果我们想给login传参，但是却传参给了inner，inner又没有接收参数，这就会报错！！！

　　2 如果我们login函数有返回值，调用login()实际调用了inner()，inner内执行的func()才是执行的目标函数，func执行的时候又没有设置变量接收返回值，这样目标函数的返回值就丢了！！！

为了让我们的装饰器能够在各种各样的目标函数上使用，不论有没有参数，有没有返回值，我们都不会丢数据也不会报错，我们要对我们的装饰器进行修改，让它变得更加健壮！

 

 

一、通用的装饰器模板：

上代码！ 我们把装饰器函数简化一下，不要他那么复杂。请看下面的装饰器实例：

 1 #装饰器函数 传入目标函数做参数
 2 def decorator( func ):
 3     #实际调用目标函数会发生调用inner，
 4     # 所以我们让inner接收不定参数，我们再把不定参数传给目标函数func
 5     #这样不论我们传入什么参数目标函数都能接收到！！
 6     def inner( *args , **kwargs ):
 7         print("装饰器函数中。。目标函数执行之前的操作！！")
 8         # 我们设置一个变量接收目标函数的返回值，在inner结束的时候再把返回值返回去
 9         # python不同于其他语言，即使我们没有编写func的返回值，也会默认返回None，所以这里不会报错
10         res = func( *args , **kwargs )
11         print("装饰器函数中。。目标函数执行之后的操作！！")
12         return res
13     return inner
14 #这样编写的装饰器，在外部看来，我们就可以传入参数给目标函数
15 # 同时也可以正常接收目标函数返回的参数!!!
16 
17 @decorator  #实际上会发生 destination = decorator( destination )
18             # 把目标函数传入装饰器函数返回了inner给destination
19             # 此后我们再调用destination 实际上调用了inner函数的一个对象
20 def destination( a ):
21     print( "目标函数接受到参数:%s"%a )
22     return "目标函数的返回值%s"%a
23 
24 if __name__ == ‘__main__‘:
25     # 这里实际上调用了inner函数的对象，我们传入参数和接收返回值都没有问题了！
26     res = destination(10)
27     # 打印一下返回值！
28     print(res)
29     ‘‘‘
30     执行结果:
31         装饰器函数中。。目标函数执行之前的操作！！
32         目标函数接受到参数:10
33         装饰器函数中。。目标函数执行之后的操作！！
34         目标函数的返回值10
35     ‘‘‘

以上这个装饰器，实际上就可以作为一个通用版本的装饰器来使用了，它基本可以为各种各样的函数进行装饰。

　　我们传入目标函数的参数 在inner中设置不定参数去接收，又传给了func

　　func的返回值我们设置了变量res去接，又在inner结束时候返回了res

这样从外部看来，调用destination 只是单纯的被包装，并不知道里面这么复杂。

 

ok啦！！到这里呢，装饰器基本就介绍完了，下面来一点拓展！

 

二、多层装饰器嵌套：

 1 #多层装饰器的嵌套
 2 
 3 #外层装饰器函数
 4 def decorator_out(func ):
 5     def inner( *args , **kwargs ):
 6         print("外装饰器前置操作。。。。。。。。。")
 7         res = func( *args , **kwargs)
 8         print("外装饰器后置操作..............")
 9         return res
10     return inner
11 
12 #内层装饰器函数
13 def decorator_in( func ):
14     def inner( *args , **kwargs ):
15         print("内装饰器前置操作。。。。。。。。。")
16         res = func( *args , **kwargs)
17         print("内装饰器后置操作..............")
18         return res
19     return inner
20 
21 #目标函数被两个装饰器装饰
22 ‘‘‘
23 这里实际上会发生的情况是 login = decorator_out( decorator_in( destination )   )
24 先in装饰器装饰目标函数之后，把inner返回给destination,
25 然后 out装饰器 再对新的destination进行装饰，out里的func 存了 in装饰器装饰过的destination函数
26     又把inner返回给destination
27 
28 这时候再执行目标函数destination() 实际上
29     1 执行out装饰器的inner() 执行到func的时候 执行in装饰器的inner
30     2 在内装饰器inner中执行func才是原来的目标函数
31     3 目标函数执行完跳出到in装饰器的inner
32     4 in装饰器函数inner执行完 相当于out装饰器的func执行完 跳到out装饰器的inner中
33     5 out装饰器执行结束，全部过程结束
34 
35 ‘‘‘
36 @decorator_out
37 @decorator_in
38 def destination():
39     print("目标函数！")
40 
41 if __name__ == ‘__main__‘:
42     destination()
43     ‘‘‘
44     执行结果：
45         外装饰器前置操作。。。。。。。。。
46         内装饰器前置操作。。。。。。。。。
47         目标函数！
48         内装饰器后置操作..............
49         外装饰器后置操作..............
50     ‘‘‘

当多层装饰器嵌套的时候，实际上先内层装饰器装饰目标函数

外层装饰器会对内层装饰器装饰的结果进行再装饰

 

不太好理解呀！！我很害怕好伙伴们理解不了我想表达的事情。如果是在不理解，不妨敲一敲代码，看一看注释，也许就懂了！！我也是懵懵懂懂学过来的~

 

 

三、可选择装饰器：

 

接下来我们再对装饰器来一个功能！

　　团队中一个人写了装饰器，大家一块用，之前的代码中，我写的装饰器，都是对目标函数执行之前和之后都有一些操作。如果某一个功能不需要之前或者之后的操作，只需要一个操作怎么办？？

　　这时候用到三层闭包嵌套。我们来一段代码理解一下

 1 #我们传入一个flag决定是不是要执行目标函数之后的操作
 2 def flagOperation( flag ):
 3     def decorator(func):
 4         def inner(*args , **kwargs):
 5             print("装饰器前置操作。。。。。。。。")
 6             res = func(*args , **kwargs)
 7             if flag :   #如果传入flag是真则执行后置操作 否则不执行
 8                 print("我是后置操作")
 9             return res
10         return inner
11     return decorator
12 
13 
14 
15 ‘‘‘
16 @flagOperation(True) 这里实际上先执行了flagOperation(True) ，返回了decorator装饰器，
17     并且把flag的值是True绑定给了他
18     这时候用带着flag的decorator 对目标函数进行装饰
19     相当于@decorator  带着一个flag
20 ‘‘‘
21 @flagOperation(True)
22 def destination():
23     print("目标函数！")
24 
25 @flagOperation(False)
26 def desti2():
27     print("目标函数2")
28 
29 if __name__ == ‘__main__‘:
30     destination()
31     ‘‘‘
32     结果：
33         装饰器前置操作。。。。。。。。
34         目标函数！
35         我是后置操作
36     ‘‘‘
37     desti2()
38     ‘‘‘
39     结果：
40         装饰器前置操作。。。。。。。。
41         目标函数2
42     ‘‘‘

 

ok啦，到目前位置，已经探讨了好多种牛逼的装饰器了，他们功能非常强大。学习要站在巨人的肩膀上，我么能完成更加厉害的功能。

对于理解有困难的好伙伴，只要努力的把我分享的 通用的装饰就可以了 其他可以不用理解。

 

四、类实现装饰器

如果对一个类名后跟() , 实际上会调用类内的__call__方法，所以我们把装饰器的逻辑写到__call__ 方法里就可以！

 1 #类装配期
 2 class Decorator(object):
 3     def __init__(self,func):
 4         self.func = func
 5     def __call__(self):
 6         print("类装饰器前操作")
 7         self.func()
 8         print("类装饰器后操作")
 9 
10 
11 
12 @Decorator
13 def login():
14     print("login now")
15 
16 if __name__ == ‘__main__‘:
17     login()

 

 

 

不装饰器到这里还有一些小问题没有解决。

目标函数是一个函数对象，它里面有自己的魔法属性 函数名__name__ 、说明文档__doc__等等。

如果我们目标函数被装饰器装饰之后，我们再调用 目标函数 destination.__name__ 会发现 本来 我们本来想要的 destination这个名字 打印出来确是 inner

　　这种情况确实不出乎意料，因为destination被装饰之后确实存的就是inner了，我们对destination的操作实际上都是对inner的操作

但是这带来了使用的不一致性。我们如果能把本来目标函数各种方法覆盖给inner函数就好了！

当然这是能实现的，我们可以用functools 包里的工具来实现。这里就不探讨了，再后续的博文中，我会再发表我学习functool模块的一些常用工具！

 

希望大家有所收获，我们共同进步！

欢迎其他朋友批评指正！