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