（轉）5個案例詳解裝飾器 | 手把手教你入門Python之四十六

阿新 • • 發佈：2021-11-27

原文：https://developer.aliyun.com/article/766149

裝飾器

裝飾器是程式開發中經常會⽤到的⼀個功能，⽤好了裝飾器，開發效率如⻁添翼，所以這也是Python⾯試中必問的問題。但對於好多初次接觸這個知識的⼈來講，這個功能有點繞，⾃學時直接繞過去了，然後⾯試問到了就掛了，因為裝飾器是程式開發的基礎知識，這個都不會，別跟⼈家說你會Python, 看了下⾯的⽂章，保證你學會裝飾器。

1、先明⽩這段程式碼

#### 第⼀波 ####
def foo():
 print('foo')
foo # 表示是函式
foo() # 表示執⾏foo函式
#### 第⼆波 ####
def foo():
 print('foo')
foo = lambda x: x + 1
foo() # 執⾏lambda表示式，⽽不再是原來的foo函式，因為foo這個名字被重新指向了另外⼀個匿名函式

函式名僅僅是個變數，只不過指向了定義的函式⽽已，所以才能通過函式名()調⽤，如果函式名=xxx被修改了，那麼當在執⾏函式名()時，調⽤的就不知之前的那個函數了

2、需求來了

初創公司有N個業務部⻔，基礎平臺部⻔負責提供底層的功能，如：資料庫操作、redis調⽤、監控API等功能。業務部⻔使⽤基礎功能時，只需調⽤基礎平臺提供的功能即可。如下：

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

跟每個業務部⻔交涉，每個業務部⻔⾃⼰寫程式碼，調⽤基礎平臺的功能之前先驗證。誒，這樣⼀來基礎
平臺就不需要做任何修改了。太棒了，有充⾜的時間泡妹⼦...

當天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 被開除了…

⽼⼤把⼯作交給 Low BBB，他是這麼做的：

只對基礎平臺的程式碼進⾏重構，其他業務部⻔⽆需做任何修改

############### 基礎平臺提供的功能如下 ###############
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⼀個實現⽅案：

def w1(func):
 def inner():
 # 驗證1
 # 驗證2
 # 驗證3
 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
 func()
 return inner
@w1
def f1():
 print('f1')

python直譯器就會從上到下解釋程式碼，步驟如下：

def w1(func): ==>將w1函式載入到記憶體
@w1

沒錯，從表⾯上看直譯器僅僅會解釋這兩句程式碼，因為函式在沒有被調⽤之前其內部程式碼不會被執⾏。
從表⾯上看直譯器著實會執⾏這兩句，但是 @w1 這⼀句程式碼⾥卻有⼤⽂章， @函式名是python的⼀種語法糖。

上例@w1內部會執⾏⼀下操作：

執⾏w1函式

執⾏w1函式，並將 @w1 下⾯的函式作為w1函式的引數，即：@w1 等價於 w1(f1) 所以，內部就會去
執⾏：

def inner():
 #驗證 1
 #驗證 2
 #驗證 3
 f1() # func是引數，此時 func 等於 f1
 return inner# 返回的 inner，inner代表的是函式，⾮執⾏函式 ,其實就是將原來的 f1 函式塞進另外
⼀個函式中

w1的返回值

將執⾏完的w1函式返回值賦值給@w1下⾯的函式的函式名f1 即將w1的返回值再重新賦值給 f1，即：

新f1 = def inner():
 #驗證 1
 #驗證 2
 #驗證 3
 原來f1()
 return inner

所以，以後業務部⻔想要執⾏ f1 函式時，就會執⾏新f1 函式，在新f1 函式內部先執⾏驗證，再執⾏原
來的f1函式，然後將原來f1 函式的返回值返回給了業務調⽤者。

如此⼀來，即執⾏了驗證的功能，⼜執⾏了原來f1函式的內容，並將原f1函式返回值返回給業務調⽤者。
Low BBB 你明⽩了嗎？要是沒明⽩的話，我晚上去你家幫你解決吧！！！

3. 再議裝飾器

# 定義函式：完成包裹資料
def makeBold(fn):
 def wrapped():
 return "<b>" + fn() + "</b>"
 return wrapped
# 定義函式：完成包裹資料
def makeItalic(fn):
 def wrapped():
 return "<i>" + fn() + "</i>"
 return wrapped
@makeBold
def test1():
 return "hello world-1"
@makeItalic
def test2():
 return "hello world-2"
@makeBold
@makeItalic
def test3():
 return "hello world-3"
print(test1())
print(test2())
print(test3())

執行結果;

<b>hello world-1</b>
<i>hello world-2</i>
<b><i>hello world-3</i><b>

4. 裝飾器(decorator)功能

引⼊⽇志
函式執⾏時間統計
執⾏函式前預備處理
執⾏函式後清理功能
許可權校驗等場景
快取

5. 裝飾器示例

例1:⽆引數的函式

def check_time(action):
 def do_action():
 action()
 return do_action
@check_time
def go_to_bed():
 print('去睡覺')
go_to_bed()

上⾯程式碼理解裝飾器執⾏為可理解成

result = check_time(go_to_bed) # 把go_to_bed 當做引數傳⼊給 check_time函式，再定義⼀個
變數⽤來儲存check_time的運⾏結果
result() # check_time 函式的返回值result是⼀個函式, result()再調⽤這個函式，讓它再調⽤go_
to_bed函式

例2:被裝飾的函式有引數

def check_time(action):
 def do_action(a,b):
 action(a,b)
 return do_action
@check_time
def go_to_bed(a,b):
 print('{}去{}睡覺'.format(a,b))
go_to_bed("zhangsan","床上“)

例3:被裝飾的函式有不定⻓引數

def test(cal):
 def do_cal(*args,**kwargs):
 cal(*args,**kwargs)
 return do_cal
@test
def demo(*args):
 sum = 0
 for x in args:
 sum +=x
 print(sum)
demo(1, 2, 3, 4)

例4:裝飾器中的return

def test(cal):
 def do_cal(*args,**kwargs):
 return cal(*args,**kwargs) # 需要再這⾥寫return語句，表示調⽤函式，獲取函式的返回
值並返回
 return do_cal
@test
def demo(a,b):
 return a + b
print(demo(1, 2)) #3

總結：
⼀般情況下為了讓裝飾器更通⽤，可以有return

例5:裝飾器帶引數

def can_play(clock):
    print('最外層函式被呼叫了，clock = {}'.format(clock))
    def handle_action(fn):
        def do_action(name, game):
            if clock < 21:
                fn(name, game)
            else:
                print('太晚了，不能玩兒遊戲了')

        return do_action

    return handle_action

@can_play(20)  # 裝飾器函式帶引數
def play_game(name, game):
    print(name + '正在玩兒' + game)

play_game('張三', '王者榮耀')

1、呼叫can_play函式，並將12傳遞給clock
2、再呼叫handle_action方法，把play_game傳遞給fn
3、此時再呼叫play_game其實呼叫的就是do_action

提⾼：使⽤裝飾器實現許可權驗證

以下程式碼不要求掌握，如果能看懂最好，如果能⾃⼰⼿動寫出來，那就太棒了！

def outer_check(base_permission):
    def check_permission(action):
        def do_action(my_permission):
            if my_permission & base_permission:
                return action(my_permission)
            else:
                return '對不起，您不具有該許可權'
            return do_action
        return check_permission
        
        
READ_PERMISSION = 1
WRITE_PERMISSION = 2
EXECUTE_PERMISSION = 4


@outer_check(base_permission=READ_PERMISSION)
def read(my_permission):
    return '讀取資料'

@outer_check(base_permission=WRITE_PERMISSION)
def write(my_permission):
    return '寫⼊資料'

@outer_check(base_permission=EXECUTE_PERMISSION)
def execute(my_permission):
    return '執⾏程式'

print(read(5))

裝飾器的高階使用

技術連結