Python自動化面試必備之你真明白裝飾器麼？

時間 2020-07-19

原文原文鏈接

裝飾器是程序開發中常常會用到的一個功能，用好了裝飾器，開發效率如虎添翼，因此這也是Python面試中必問的問題，但對於好多小白來說，這個功能有點繞，自學時直接繞過去了，而後面試問到了就掛了，由於裝飾器是程序開發的基礎知識，這個都不會，別跟人家說你會Python, 看了下面的文章，保證你學會裝飾器。html

一、先明白這段代碼

#### 第一波 ####
def foo():
    print 'foo'
 
foo     #表示是函數
foo()   #表示執行foo函數
 
#### 第二波 ####
def foo():
    print 'foo'
 
foo = lambda x: x + 1
 
foo()   # 執行下面的lambda表達式，而再也不是原來的foo函數，由於函數 foo 被從新定義了

二、需求來了

初創公司有N個業務部門，1個基礎平臺部門，基礎平臺負責提供底層的功能，如：數據庫操做、redis調用、監控API等功能。業務部門使用基礎功能時，只需調用基礎平臺提供的功能便可。以下：python

############### 基礎平臺提供的功能以下 ###############
 
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，他是這麼作的：redis

跟每一個業務部門交涉，每一個業務部門本身寫代碼，調用基礎平臺的功能以前先驗證。誒，這樣一來基礎平臺就不須要作任何修改了。

當天Low B 被開除了...數據庫

老大把工做交給 Low BB，他是這麼作的：編程

############### 基礎平臺提供的功能以下 ############### 

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 被開除了...app

老大把工做交給 Low BBB，他是這麼作的：ide

只對基礎平臺的代碼進行重構，其餘業務部門無需作任何修改

############### 基礎平臺提供的功能以下 ############### 

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 、f二、f三、f4的內部進行修改代碼，老闆就給了Low BBB一個實現方案：

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爲例：

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 你明白了嗎？要是沒明白的話，我晚上去你家幫你解決吧！！！

先把上述流程看懂，以後還會繼續更新...

三、問答時間

問題：被裝飾的函數若是有參數呢？

#一個參數
def w1(func):
    def inner(arg):
        # 驗證1
        # 驗證2
        # 驗證3
        return func(arg)
    return inner

@w1
def f1(arg):
    print 'f1'

#兩個參數
def w1(func):
    def inner(arg1,arg2):
        # 驗證1
        # 驗證2
        # 驗證3
        return func(arg1,arg2)
    return inner

@w1
def f1(arg1,arg2):
    print 'f1'

#三個參數
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個參數的函數的裝飾器？

def w1(func):
    def inner(*args,**kwargs):
        # 驗證1
        # 驗證2
        # 驗證3
        return func(*args,**kwargs)
    return inner
 
@w1
def f1(arg1,arg2,arg3):
    print 'f1'

問題：一個函數能夠被多個裝飾器裝飾嗎？

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'

問題：還有什麼更吊的裝飾器嗎？

#!/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'

好啦，至此，面試時任何裝飾器的問題都難不到道你啦！

更多問題，加Alex 的專屬羣討論，

PYTHON自動化交流1羣

255012808

博客園同步地址 http://www.cnblogs.com/wupeiqi/articles/4980620.html