实用干货：如何理解装饰器（2）

新手·ing

函数引用

从以上两个例子我们可以得出，函数既然作为一个对象，因此：

1. 其可以被赋给其他变量

2. 其可以被定义在另外一个函数内

这也就是说，函数可以返回一个函数，看下面的例子：

1. def getTalk(type="shout") :
   
2. 
   
3.     # 我们定义另外一个函数
   
4.     def shout(word="yes") :
   
5.         return word.capitalize()+" !"
   
6. 
   
7.     def whisper(word="yes") :
   
8.         return word.lower()+"...";
   
9. 
   
10.     # 然后我们返回其中一个
    
11.     if type == "shout" :
    
12.         # 我们没有使用(),因为我们不是在调用该函数
    
13.         # 我们是在返回该函数
    
14.         return shout
    
15.     else :
    
16.         return whisper
    
17. 
    
18. # 然后怎么使用呢 ?
    
19. 
    
20. # 把该函数赋予某个变量
    
21. talk = getTalk()     
    
22. 
    
23. # 这里你可以看到talk其实是一个函数对象:
    
24. print talk
    
25. #输出 : <function shout at 0xb7ea817c>
    
26. 
    
27. # 该对象由函数返回的其中一个对象:
    
28. print talk()
    
29. 
    
30. # 或者你可以直接如下调用 :
    
31. print getTalk("whisper")()
    
32. #输出 : yes...
    
33. 还有，既然可以返回一个函数，我们可以把它作为参数传递给函数：
    
34. 
    
35. def doSomethingBefore(func) :
    
36.     print "I do something before then I call the function you gave me"
    
37.     print func()
    
38. 
    
39. doSomethingBefore(scream)
    
40. #输出 :
    
41. #I do something before then I call the function you gave me
    
42. #Yes !

复制代码

这里你已经足够能理解装饰器了，其他它可被视为封装器。也就是说，它能够让你在装饰前后执行代码而无须改变函数本身内容。

手工装饰

那么如何进行手动装饰呢？

1. # 装饰器是一个函数，而其参数为另外一个函数
   
2. def my_shiny_new_decorator(a_function_to_decorate) :
   
3. 
   
4.     # 在内部定义了另外一个函数：一个封装器。
   
5.     # 这个函数将原始函数进行封装，所以你可以在它之前或者之后执行一些代码
   
6.     def the_wrapper_around_the_original_function() :
   
7. 
   
8.         # 放一些你希望在真正函数执行前的一些代码
   
9.         print "Before the function runs"
   
10. 
    
11.         # 执行原始函数
    
12.         a_function_to_decorate()
    
13. 
    
14.         # 放一些你希望在原始函数执行后的一些代码
    
15.         print "After the function runs"
    
16. 
    
17.     #在此刻，"a_function_to_decrorate"还没有被执行，我们返回了创建的封装函数
    
18.     #封装器包含了函数以及其前后执行的代码，其已经准备完毕
    
19.     return the_wrapper_around_the_original_function
    
20. 
    
21. # 现在想象下，你创建了一个你永远也不远再次接触的函数
    
22. def a_stand_alone_function() :
    
23.     print "I am a stand alone function, don't you dare modify me"
    
24. 
    
25. a_stand_alone_function()
    
26. #输出: I am a stand alone function, don't you dare modify me
    
27. 
    
28. # 好了，你可以封装它实现行为的扩展。可以简单的把它丢给装饰器
    
29. # 装饰器将动态地把它和你要的代码封装起来，并且返回一个新的可用的函数。
    
30. a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)
    
31. a_stand_alone_function_decorated()
    
32. #输出 :
    
33. #Before the function runs
    
34. #I am a stand alone function, don't you dare modify me
    
35. #After the function runs
    
36. 现在你也许要求当每次调用a_stand_alone_function时，实际调用却是a_stand_alone_function_decorated。实现也很简单，可以用my_shiny_new_decorator来给a_stand_alone_function重新赋值。
    
37. 
    
38. a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)
    
39. a_stand_alone_function()
    
40. #输出 :
    
41. #Before the function runs
    
42. #I am a stand alone function, don't you dare modify me
    
43. #After the function runs
    
44. 
    
45. # And guess what, that's EXACTLY what decorators do !

复制代码