裝飾器是程式開發中經常會用到的一個功能，用好了裝飾器，開發效率如虎添翼，所以這也是Python面試中必問的問題，但對於好多小白來講，這個功能 有點繞，自學時直接繞過去了，然後面試問到了就掛了，因為裝飾器是程式開發的基礎知識，這個都 不會，別跟人家說你會Python, 看了下面的文章，保證你學會裝飾器。
1、先明白這段程式碼
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
#### 第一波 #### def foo(): print 'foo' foo #表示是函式 foo() #表示執行foo函式 #### 第二波 #### def foo(): print 'foo' foo = lambda x: x + 1 foo() # 執行下面的lambda表示式，而不再是原來的foo函式，因為函式 foo 被重新定義了 |
2、需求來了
初創公司有N個業務部門，1個基礎平臺部門，基礎平臺負責提供底層的功能，如：資料庫操作、redis呼叫、監控API等功能。業務部門使用基礎功能時，只需呼叫基礎平臺提供的功能即可。如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
############### 基礎平臺提供的功能如下 ############### def f1(): print 'f1' def f2(): print 'f2' def f3(): print 'f3' def f4(): print 'f4' ############### 業務部門A 呼叫基礎平臺提供的功能 ############### f1() f2() f3() f4() ############### 業務部門B 呼叫基礎平臺提供的功能 ############### f1() f2() f3() f4() |
目前公司有條不紊的進行著，但是，以前基礎平臺的開發人員在寫程式碼時候沒有關注驗證相關的問題，即：基礎平臺的提供的功能可以被任何人使用。現在需要對基礎平臺的所有功能進行重構，為平臺提供的所有功能新增驗證機制，即：執行功能前，先進行驗證。
老大把工作交給 Low B，他是這麼做的：
|
1 |
跟每個業務部門交涉，每個業務部門自己寫程式碼，呼叫基礎平臺的功能之前先驗證。誒，這樣一來基礎平臺就不需要做任何修改了。 |
當天Low B 被開除了…
老大把工作交給 Low BB，他是這麼做的：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
############### 基礎平臺提供的功能如下 ############### def f1(): # 驗證1 # 驗證2 # 驗證3 print 'f1' def f2(): # 驗證1 # 驗證2 # 驗證3 print 'f2' def f3(): # 驗證1 # 驗證2 # 驗證3 print 'f3' def f4(): # 驗證1 # 驗證2 # 驗證3 print 'f4' ############### 業務部門不變 ############### ### 業務部門A 呼叫基礎平臺提供的功能### f1() f2() f3() f4() ### 業務部門B 呼叫基礎平臺提供的功能 ### f1() f2() f3() f4() |
過了一週 Low BB 被開除了…
老大把工作交給 Low BBB，他是這麼做的：
|
1 |
只對基礎平臺的程式碼進行重構，其他業務部門無需做任何修改 |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
############### 基礎平臺提供的功能如下 ############### def check_login(): # 驗證1 # 驗證2 # 驗證3 pass def f1(): check_login() print 'f1' def f2(): check_login() print 'f2' def f3(): check_login() print 'f3' def f4(): check_login() print 'f4' |
老大看了下Low BBB 的實現，嘴角漏出了一絲的欣慰的笑，語重心長的跟Low BBB聊了個天：
老大說：
寫程式碼要遵循開發封閉原則，雖然在這個原則是用的物件導向開發，但是也適用於函數語言程式設計，簡單來說，它規定已經實現的功能程式碼不允許被修改，但可以被擴充套件，即：
- 封閉：已實現的功能程式碼塊
- 開放：對擴充套件開發
如果將開放封閉原則應用在上述需求中，那麼就不允許在函式 f1 、f2、f3、f4的內部進行修改程式碼，老闆就給了Low BBB一個實現方案：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
def w1(func): def inner(): # 驗證1 # 驗證2 # 驗證3 return func() return inner @w1 def f1(): print 'f1' @w1 def f2(): print 'f2' @w1 def f3(): print 'f3' @w1 def f4(): print 'f4' |
對於上述程式碼，也是僅僅對基礎平臺的程式碼進行修改，就可以實現在其他人呼叫函式 f1 f2 f3 f4 之前都進行【驗證】操作，並且其他業務部門無需做任何操作。
Low BBB心驚膽戰的問了下，這段程式碼的內部執行原理是什麼呢？
老大正要生氣，突然Low BBB的手機掉到地上，恰恰屏保就是Low BBB的女友照片，老大一看一緊一抖，喜笑顏開，交定了Low BBB這個朋友。詳細的開始講解了：
單獨以f1為例：
|
1 2 3 4 5 6 7 8 9 10 11 |
def w1(func): def inner(): # 驗證1 # 驗證2 # 驗證3 return func() return inner @w1 def f1(): print 'f1' |
當寫完這段程式碼後（函式未被執行、未被執行、未被執行），python直譯器就會從上到下解釋程式碼，步驟如下：
- def w1(func): ==>將w1函式載入到記憶體
- @w1
沒錯，從表面上看直譯器僅僅會解釋這兩句程式碼，因為函式在沒有被呼叫之前其內部程式碼不會被執行。
從表面上看直譯器著實會執行這兩句，但是 @w1 這一句程式碼裡卻有大文章，@函式名 是python的一種語法糖。
如上例@w1內部會執行一下操作：
- 執行w1函式，並將 @w1 下面的 函式 作為w1函式的引數，即：@w1 等價於 w1(f1)
所以，內部就會去執行：
def inner:
#驗證
return f1() # func是引數，此時 func 等於 f1
return inner # 返回的 inner，inner代表的是函式，非執行函式
其實就是將原來的 f1 函式塞進另外一個函式中 - 將執行完的 w1 函式返回值賦值給@w1下面的函式的函式名
w1函式的返回值是：
def inner:
#驗證
return 原來f1() # 此處的 f1 表示原來的f1函式
然後，將此返回值再重新賦值給 f1，即：
新f1 = def inner:
#驗證
return 原來f1()
所以，以後業務部門想要執行 f1 函式時，就會執行 新f1 函式，在 新f1 函式內部先執行驗證，再執行原來的f1函式，然後將 原來f1 函式的返回值 返回給了業務呼叫者。
如此一來， 即執行了驗證的功能，又執行了原來f1函式的內容，並將原f1函式返回值 返回給業務呼叫著
Low BBB 你明白了嗎？要是沒明白的話，我晚上去你家幫你解決吧！！！
先把上述流程看懂，之後還會繼續更新…
3、問答時間
問題：被裝飾的函式如果有引數呢？
|
1 2 3 4 5 6 7 8 9 10 11 12 |
#一個引數 def w1(func): def inner(arg): # 驗證1 # 驗證2 # 驗證3 return func(arg) return inner @w1 def f1(arg): print 'f1' |
|
1 2 3 4 5 6 7 8 9 10 11 12 |
#兩個引數 def w1(func): def inner(arg1,arg2): # 驗證1 # 驗證2 # 驗證3 return func(arg1,arg2) return inner @w1 def f1(arg1,arg2): print 'f1' |
|
1 2 3 4 5 6 7 8 9 10 11 12 |
#三個引數 def w1(func): def inner(arg1,arg2,arg3): # 驗證1 # 驗證2 # 驗證3 return func(arg1,arg2,arg3) return inner @w1 def f1(arg1,arg2,arg3): print 'f1' |
問題：可以裝飾具有處理n個引數的函式的裝飾器？
|
1 2 3 4 5 6 7 8 9 10 11 |
def w1(func): def inner(*args,**kwargs): # 驗證1 # 驗證2 # 驗證3 return func(*args,**kwargs) return inner @w1 def f1(arg1,arg2,arg3): print 'f1' |
問題：一個函式可以被多個裝飾器裝飾嗎？
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
def w1(func): def inner(*args,**kwargs): # 驗證1 # 驗證2 # 驗證3 return func(*args,**kwargs) return inner def w2(func): def inner(*args,**kwargs): # 驗證1 # 驗證2 # 驗證3 return func(*args,**kwargs) return inner @w1 @w2 def f1(arg1,arg2,arg3): print 'f1' |
問題：還有什麼更吊的裝飾器嗎？
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
#!/usr/bin/env python #coding:utf-8 def Before(request,kargs): print 'before' def After(request,kargs): print 'after' def Filter(before_func,after_func): def outer(main_func): def wrapper(request,kargs): before_result = before_func(request,kargs) if(before_result != None): return before_result; main_result = main_func(request,kargs) if(main_result != None): return main_result; after_result = after_func(request,kargs) if(after_result != None): return after_result; return wrapper return outer @Filter(Before, After) def Index(request,kargs): print 'index' |
好啦，至此， 面試時任何裝飾器的問題都 難不到道 你啦！