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

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

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

装饰器：

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

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

　　不理解的话举个例子：

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

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

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

先上一段代码！！！

 import time
 #装饰器会用到闭包的原理：外函数内部定义了一个内函数，内函数使用外函数的局部变量，并且外函数返回了内函数的引用
 #装饰器函数 传入一个我们想对他装饰的目标函数的引用，将在内函数中使用
 def decorator( func ):
     def inner():
         t1 = time.time() # 目标函数开始之前取一下时间
         print("登录前的时间是",t1)
         # 这个func外部函数传入的参数，也就是我们希望装饰的目标函数的引用
         # 这里实际上执行了目标函数，我们想对这个函数进行装饰，所有在它执行之前和之后进行一番操作，具体什么操作看业务逻辑
         func()
         t2 = time.time() # 目标函数结束之后取一下时间
         print("登录后的时间是",t2)
         t = t2 - t1 #计算目标函数执行花了多长时间
         print("登录花费的时间:",t)
     #在外函数结束时候返回内函数的引用
     return inner

 # 上面是我们写的装饰器函数，用装饰器函数可以对一个目标函数进行操作！！
 '''
 下面的 @decorator 就是是使用装饰函数decorator的意思
 它实际上执行的是: login = decorator( login )
 注意，编程语言都是从右向左来解析执行，这句话实际上会发生的事情是：
     1 把目标函数login(是一个变量名，里面存的是目标函数的引用) 传入decorator函数被参数func接收了
         这时候func也是目标函数的引用 func和login指向同一个函数对象
     2 decorator函数定义了内部函数inner，发现里面会使用到func，
         这用到闭包的原理，外函数结束的时候会把func绑定给内函数将来使用
     3 外函数结束的时候把自己创建的内函数的引用inner返回给了login接收，
         这时候login已经不是原来我们编写的目标函数了，login实际上是一个inner函数的实例对象
         再执行login() 的时候实际上执行了inner()的一个对象
     4 再执行login() 的时候 实际上执行inner()
         会先执行取时间 打印
         之后执行func()才是执行我们的目标函数
         最后又取时间 打印结果
 '''
 @decorator
 #下面我们写一个函数模拟是登录功能模块的函数，并且用装饰器进行装饰
 def login():
     print("用户正在登录！请稍等。。。。")
     time.sleep(1)
     print("登录成功！欢迎登录！")

 if __name__ == '__main__':
     #调用login 实际上调用了装饰之后的函数inner的一个对象，inner里的func才是真正的目标函数
     login()
     '''
     执行结果:
         登录前的时间是 1502163280.2836263
         用户正在登录！请稍等。。。。
         登录成功！欢迎登录！
         登录后的时间是 1502163281.2895217
         登录花费的时间: 1.0058953762054443
     '''

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

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

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

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

　　我们先回顾一下：上面的目标函数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执行的时候又没有设置变量接收返回值，这样目标函数的返回值就丢了！！！

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

一、通用的装饰器模板：

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

 #装饰器函数 传入目标函数做参数
 def decorator( func ):
     #实际调用目标函数会发生调用inner，
     # 所以我们让inner接收不定参数，我们再把不定参数传给目标函数func
     #这样不论我们传入什么参数目标函数都能接收到！！
     def inner( *args , **kwargs ):
         print("装饰器函数中。。目标函数执行之前的操作！！")
         # 我们设置一个变量接收目标函数的返回值，在inner结束的时候再把返回值返回去
         # python不同于其他语言，即使我们没有编写func的返回值，也会默认返回None，所以这里不会报错
         res = func( *args , **kwargs )
         print("装饰器函数中。。目标函数执行之后的操作！！")
         return res
     return inner
 #这样编写的装饰器，在外部看来，我们就可以传入参数给目标函数
 # 同时也可以正常接收目标函数返回的参数!!!

 @decorator  #实际上会发生 destination = decorator( destination )
             # 把目标函数传入装饰器函数返回了inner给destination
             # 此后我们再调用destination 实际上调用了inner函数的一个对象
 def destination( a ):
     print( "目标函数接受到参数:%s"%a )
     return "目标函数的返回值%s"%a

 if __name__ == '__main__':
     # 这里实际上调用了inner函数的对象，我们传入参数和接收返回值都没有问题了！
     res = destination(10)
     # 打印一下返回值！
     print(res)
     '''
     执行结果:
         装饰器函数中。。目标函数执行之前的操作！！
         目标函数接受到参数:10
         装饰器函数中。。目标函数执行之后的操作！！
         目标函数的返回值10
     '''

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

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

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

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

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

二、多层装饰器嵌套：

 #多层装饰器的嵌套

 #外层装饰器函数
 def decorator_out(func ):
     def inner( *args , **kwargs ):
         print("外装饰器前置操作。。。。。。。。。")
         res = func( *args , **kwargs)
         print("外装饰器后置操作..............")
         return res
     return inner

 #内层装饰器函数
 def decorator_in( func ):
     def inner( *args , **kwargs ):
         print("内装饰器前置操作。。。。。。。。。")
         res = func( *args , **kwargs)
         print("内装饰器后置操作..............")
         return res
     return inner

 #目标函数被两个装饰器装饰
 '''
 这里实际上会发生的情况是 login = decorator_out( decorator_in( destination )   )
 先in装饰器装饰目标函数之后，把inner返回给destination,
 然后 out装饰器 再对新的destination进行装饰，out里的func 存了 in装饰器装饰过的destination函数
     又把inner返回给destination

 这时候再执行目标函数destination() 实际上
     1 执行out装饰器的inner() 执行到func的时候 执行in装饰器的inner
     2 在内装饰器inner中执行func才是原来的目标函数
     3 目标函数执行完跳出到in装饰器的inner
     4 in装饰器函数inner执行完 相当于out装饰器的func执行完 跳到out装饰器的inner中
     5 out装饰器执行结束，全部过程结束

 '''
 @decorator_out
 @decorator_in
 def destination():
     print("目标函数！")

 if __name__ == '__main__':
     destination()
     '''
     执行结果：
         外装饰器前置操作。。。。。。。。。
         内装饰器前置操作。。。。。。。。。
         目标函数！
         内装饰器后置操作..............
         外装饰器后置操作..............
     '''

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

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

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

三、可选择装饰器：

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

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

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

 #我们传入一个flag决定是不是要执行目标函数之后的操作
 def flagOperation( flag ):
     def decorator(func):
         def inner(*args , **kwargs):
             print("装饰器前置操作。。。。。。。。")
             res = func(*args , **kwargs)
             if flag :   #如果传入flag是真则执行后置操作 否则不执行
                 print("我是后置操作")
             return res
         return inner
     return decorator

 '''
 @flagOperation(True) 这里实际上先执行了flagOperation(True) ，返回了decorator装饰器，
     并且把flag的值是True绑定给了他
     这时候用带着flag的decorator 对目标函数进行装饰
     相当于@decorator  带着一个flag
 '''
 @flagOperation(True)
 def destination():
     print("目标函数！")

 @flagOperation(False)
 def desti2():
     print("目标函数2")

 if __name__ == '__main__':
     destination()
     '''
     结果：
         装饰器前置操作。。。。。。。。
         目标函数！
         我是后置操作
     '''
     desti2()
     '''
     结果：
         装饰器前置操作。。。。。。。。
         目标函数2
     '''

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

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

四、类实现装饰器

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

 #类装配期
 class Decorator(object):
     def __init__(self,func):
         self.func = func
     def __call__(self):
         print("类装饰器前操作")
         self.func()
         print("类装饰器后操作")

 @Decorator
 def login():
     print("login now")

 if __name__ == '__main__':
     login()

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

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

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

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

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

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

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

欢迎其他朋友批评指正！