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模块的一些常用工具！
希望大家有所收获，我们共同进步！
欢迎其他朋友批评指正！