裝飾器在多種語言裡都有,名稱各異,但背後其實是同一種設計思路:強調開放封閉原則,多用於後期的功能擴充,而不是從頭撰寫新程式。它不只可以裝飾函式,也能裝飾類別等物件,不過最常見的說明方式仍以函式為例。
要理解 Python 裝飾器的原理,得一步一步來。本文盡量從最基礎的地方講起(以下範例基於 Python 3.5.1)。
第一件必須牢記的事:Python 由上而下順序執行,而且遇到函式定義的程式碼區塊時不會立刻執行它,只有等到該函式被呼叫,內部程式碼才會跑。
1 def foo():
2 print("foo 函式被運行了!")
3
4
5 如果就這樣寫,foo 裡的語句是不會被執行的。
6 程式只是簡單的將定義區塊讀入記憶體中。
再看順序執行的例子:
1 def foo():
2 print("我是上面的函式定義!")
3
4 def foo():
5 print("我是下面的函式定義!")
6
7 foo()
8
9 運行結果:
10
11 我是下面的函式定義
由於順序執行,下面的 foo 覆蓋了上面的 foo。所以 Python 對程式碼的位置是有要求的:函式主體必須放在被呼叫的語句之前,不能隨意擺放。
其次,得先分清幾個概念:函式名、函式主體、返回值、函式的記憶體位址、函式名加括號、函式名當作參數、函式名加括號當作參數、回傳函式名、回傳函式名加括號。以這個函式為例:
1 def foo():
2 print("讓我們幹點啥!")
3 return "ok"
4
5 foo()
再看一個例子:
1 def outer(func):
2 def inner():
3 print("我是內層函式!")
4 return inner
5
6 def foo():
7 print("我是原始函式!")
8
9 outer(foo)
10 outer(foo())
在 Python 中一切都是物件,函式也不例外,因此函式名、甚至「函式名加括號呼叫後的結果」都可以作為另一個函式的返回值。上面這段程式裡,outer(foo) 是把 foo 的函式名當作參數傳給 outer 並執行它;outer(foo()) 則是先把 foo 執行完,再把它的返回值當作參數傳給 outer。由於 foo 沒有指定返回值,實際上傳進去的是一個 None。有沒有括號,是兩件完全不同的事。
同樣地,outer 內部 return 的是 inner 這個函式名而非 inner(),所以回傳的是 inner 的函式主體引用。如果寫成 inner(),那就會先執行 inner 的內容,再把得到的 None 交給 outer,outer 再把这个 None 回傳給呼叫方。
請記住:函式名、函式加括號,都可以當參數傳遞,也可以當返回值回傳,有沒有括號是關鍵差異。
裝飾器通常用來在不改動原有函式程式碼與功能的前提下,為它加上額外行為,例如執行前先做些事、執行後再做些事。
用一個情境來說明(案例沿用常見的經典比喻):某大公司的基礎平台部負責內部應用程式與 API 開發,上百個業務部門各自呼叫平台部提供的函式處理自己的業務:
1 # 基礎平台部門開發了上百個函式
2 def f1():
3 print("業務部門1數據接口......")
4 def f2():
5 print("業務部門2數據接口......")
6 def f3():
7 print("業務部門3數據接口......")
8 def f100():
9 print("業務部門100數據接口......")
10
11 #各部門分別調用
12 f1()
13 f2()
14 f3()
15 f100()
創業初期因為種種原因(時間、考慮不周等),這些函式沒有做安全認證。現在平台部主管決定補上這個缺陷,於是有了下面幾回折騰。
第一回:主管叫來一位運維工程師,工程師跑遍各部門通知大家在程式碼裡加上認證,當天他被開除了。
第二回:第二位運維工程師用 shell 寫了個複雜腳本勉強實作出來,然後回去繼續做運維了。
第三回:一位 Python 自動化開發工程師直接在平台部的每個函式裡插入認證程式碼,讓 N 個業務部門無需改動。他很快也被開了:
def f1():
#加入認證程序代碼
print("業務部門1數據接口......")
def f2():
# 加入認證程序代碼
print("業務部門2數據接口......")
def f3():
# 加入認證程序代碼
print("業務部門3數據接口......")
def f100():
#加入認證程序代碼
print("業務部門100數據接口......")
#各部門分別調用
f1()
f2()
f3()
f100()
第四回:又換了一位工程師,他定義一個認證函式,原本的其他函式去呼叫它:
def login():
print("認證成功!")
def f1():
login()
print("業務部門1數據接口......")
def f2():
login()
print("業務部門2數據接口......")
def f3():
login()
print("業務部門3數據接口......")
def f100():
login()
print("業務部門100數據接口......")
#各部門分別調用
f1()
f2()
f3()
f100()
主管依然不滿意,這次他解釋了原因:寫程式要遵循開放封閉原則。這個原則雖主要針對物件導向,但同樣適用於函式式編程——已經完成的功能程式碼內部不允許修改,但外部可以擴充。也就是說,不允許在 f1、f2、f3……f100 的內部動手腳。遺憾的是,這位工程師也離開了。
第五回:主管決定親自上陣,順便把日誌功能也加上:
#/usr/bin/env Python
#coding:utf-8
def outer(func):
def inner():
print("認證成功!")
result = func()
print("日誌添加成功")
return result
return inner
@outer
def f1():
print("業務部門1數據接口......")
@outer
def f2():
print("業務部門2數據接口......")
@outer
def f3():
print("業務部門3數據接口......")
@outer
def f100():
print("業務部門100數據接口......")
#各部門分別調用
f1()
f2()
f3()
f100()
這次的作法只擴充了基礎平台部的程式碼:所有被裝飾的函式在呼叫前會先認證,結束後寫入日誌,而各業務部門既不必改自己的程式碼,呼叫方式也不用變。這就是裝飾器的價值所在。
以 f1 為例拆解:
def outer(func):
def inner():
print("認證成功!")
result = func()
print("日誌添加成功")
return result
return inner
@outer
def f1():
print("業務部門1數據接口......")
接著用第一部分的知識逐步分析:
這裡有三點要特別注意:
接著程式執行 outer 內部內容,又遇到一個函式定義。inner 的定義區塊不會立刻執行,而是被讀入記憶體。
再往下碰到 return inner,回傳的是函式名,這個名字會被賦值給 f1,也就是 f1 = inner。此時 f1 這個名字改指向 inner 的函式主體在記憶體中的位址,不再指向原來的函式主體。後續呼叫 f1() 跑的其實是 inner 的內容。那原來的函式主體去哪了?還記得我們把 f1 當參數傳給了形參 func 嗎?func 保存了老函式在記憶體中的位址,inner 裡那句 result = func() 就是靠它執行原本的主體。
所以當業務部門仍以 f1() 呼叫時,實際流程是:先印出「認證成功」,接著執行 func() 並把返回值存進 result,然後印出「日誌保存」,最後回傳 result。呼叫端可以用 r = f1() 接住這個值。
整套流程走完你會發現:既沒改動業務部門的程式碼與呼叫方式,也沒動平台部原有函式的內部實作,僅僅加上一個裝飾函式,就達成了「呼叫前認證、呼叫後寫日誌」的需求。
那為什麼非得 outer 包一層 inner?只用一層不行嗎?
因為 @outer 這行在程式執行到該處時就會立刻執行 outer 內部的程式碼。若不包裝,業務部門還沒呼叫,事情就已經先做了,這與初衷不符。若你確實需要這種行為,也可以這樣寫:
def outer(func):
print("認證成功!")
result = func()
print("日誌添加成功")
return result
@outer
def f1():
print("業務部門1數據接口......")
# 業務部門並沒有開始執行 f1 函式
執行結果:
認證成功!
業務部門1數據接口......
日誌添加成功
看到了嗎?我只是定義好函式,業務部門還沒呼叫,程式就把工作全做完了。這正是要多包一層的原因。
前面的範例 f1 都沒有參數,實務上當然會有。單一參數的情況:
def outer(func):
def inner(username):
print("認證成功!")
result = func(username)
print("日誌添加成功")
return result
return inner
@outer
def f1(name):
print("%s 正在連接業務部門1數據接口......" % name)
# 調用方法
f1("jack")
在 inner 的定義處補上參數,呼叫 func 時再把它傳進去即可。但如果 f2 有兩個參數、f3 有三個呢?這時就輪到「萬能參數」登場:
def outer(func):
def inner(*args, **kwargs):
print("認證成功!")
result = func(*args, **kwargs)
print("日誌添加成功")
return result
return inner
@outer
def f1(name, age):
print("%s 正在連接業務部門1數據接口......" % name)
# 調用方法
f1("jack", 18)
一個函式可以被多個函式裝飾嗎?可以:
def outer1(func):
def inner(*args, **kwargs):
print("認證成功!")
result = func(*args, **kwargs)
print("日誌添加成功")
return result
return inner
def outer2(func):
def inner(*args, **kwargs):
print("一條歡迎信息。。。")
result = func(*args, **kwargs)
print("一條歡送信息。。。")
return result
return inner
@outer1
@outer2
def f1(name, age):
print("%s 正在連接業務部門1數據接口......" % name)
# 調用方法
f1("jack", 18)
執行結果:
認證成功!
一條歡迎信息。。。
jack 正在連接業務部門1數據接口......
一條歡送信息。。。
日誌添加成功
注意裝飾器的堆疊順序:靠近函式的那一層先套用,執行時則由最外層開始,因此輸出順序如上。
那裝飾器自己能有參數嗎?也可以:
# 認證函式
def auth(request, kargs):
print("認證成功!")
# 日誌函式
def log(request, kargs):
print("日誌添加成功")
# 裝飾器函式。接收兩個參數,這兩個參數應該是某個函式的名字
def Filter(auth_func, log_func):
# 第一層封裝,f1 函式實際上被傳遞給了 main_func 這個參數
def outer(main_func):
# 第二層封裝,auth 和 log 的參數值被傳遞到了這裡
def wrapper(request, kargs):
before_result = auth(request, kargs)
if (before_result != None):
return before_result;
main_result = main_func(request, kargs)
if (main_result != None):
return main_result;
after_result = log(request, kargs)
if (after_result != None):
return after_result;
return wrapper
return outer
# 注意了,這裡的裝飾器函式有參數,意思是先執行 filter 函式,
# 然後將 filter 函式的返回值作為裝飾器函式的名字返回到這裡,所以,
# 其實這裡,Filter(auth, log) = outer , @Filter(auth, log) = @outer
@Filter(auth, log)
def f1(name, age):
print("%s 正在連接業務部門1數據接口......" % name)
# 調用方法
f1("jack", 18)
運行結果:
認證成功!
jack 正在連接業務部門1數據接口......
日誌添加成功
有點繞的話,可以這樣理解:先執行 Filter 取得它的返回值 outer,再套用 @outer 的裝飾器語法。
到這裡,裝飾器的基本形狀、參數傳遞與堆疊方式應該都清楚了。接下來要往「帶參數的裝飾器」與更複雜的應用推進時,只需記住一條主線:@ 後面的東西會被立即執行,它回傳什麼,就等於被裝飾的那個名字。