DIV CSS 佈局教程網

Python 裝飾器入門到進階:從原理到參數傳遞
編輯:Fireworks基礎     

裝飾器在多種語言裡都有,名稱各異,但背後其實是同一種設計思路:強調開放封閉原則,多用於後期的功能擴充,而不是從頭撰寫新程式。它不只可以裝飾函式,也能裝飾類別等物件,不過最常見的說明方式仍以函式為例。

要理解 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()
  • 函式名:foo
  • 函式主體:第 1–3 行
  • 返回值:字串 "ok"。若沒有明確寫出 return 的物件,預設回傳 None。
  • 函式的記憶體位址:函式主體被讀進記憶體後的存放位置,由識別符(即函式名 foo)引用,也就是說 foo 指向的是函式主體在記憶體中的位置。
  • 函式名加括號:例如 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數據接口......")

接著用第一部分的知識逐步分析:

  1. 程式開始由上往下編譯,讀到 def outer(func): 時,辨識出這是個「一等公民」函式,於是先把函式主體載入記憶體,然後繼續往下。
  2. 讀到 @outer 時,程式辨識出這是裝飾器語法,按規則必須立即執行,於是回頭執行 outer 所定義的函式。(@outer 只能寫在被裝飾函式的上方最近處,中間不要留空行。)
  3. 進入 outer 函式後,套用裝飾器的固定規則:被裝飾函式的名字會作為參數傳給裝飾函式;裝飾函式執行完自己的程式碼後,把它的返回值賦值給被裝飾的函式。

這裡有三點要特別注意:

  • @outer 和 @outer() 不同。沒有括號時 outer 一樣會被執行,這與「函式一定要加括號才會呼叫」的直覺不同,需特別留意。至於帶括號的寫法屬於進階用法,留待後續討論。
  • 傳進去的是 f1 這個函式名(而不是 f1() 執行後的結果),也就是 func = f1,@outer 等同於 outer(f1),實際傳遞的是 f1 的函式主體,而非它執行後的返回值。
  • outer 回傳的是 inner 這個函式名,而不是 inner() 執行後的返回值。

接著程式執行 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 的裝飾器語法。

到這裡,裝飾器的基本形狀、參數傳遞與堆疊方式應該都清楚了。接下來要往「帶參數的裝飾器」與更複雜的應用推進時,只需記住一條主線:@ 後面的東西會被立即執行,它回傳什麼,就等於被裝飾的那個名字。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved