歡迎光臨
每天分享高質量文章

12步輕鬆搞定 Python 裝飾器

(點擊上方公眾號,可快速關註一起學Python)

 

譯者:TypingQuietly

譯文:

https://www.jianshu.com/p/d68c6da1587a

原文:

https://dzone.com/articles/understanding-python

呵呵!作為一名教python的老師,我發現學生們基本上一開始很難搞定python的裝飾器,也許因為裝飾器確實很難懂。搞定裝飾器需要你瞭解一些函式式編程的概念,當然還有理解在python中定義和呼叫函式相關語法的一些特點。

我沒法讓裝飾器變得簡單,但是通過一步步的剖析,我也許能夠讓你在理解裝飾器的時候更自信一點。因為裝飾器很複雜,這篇文章將會很長(自己都說很長,還敢這麼多廢話blablabla…前戲就不繼續翻譯直接省略了)

1. 函式

在python中,函式通過 def關鍵字、函式名和可選的引數串列定義。通過 return關鍵字傳回值。我們舉例來說明如何定義和呼叫一個簡單的函式:

  1. >>> def foo():
  2. ...     return 1
  3. >>> foo()
  4. 1

方法體(當然多行也是一樣的)是必須的,通過縮進來表示,在方法名的後面加上雙括號 ()就能夠呼叫函式

2. 作用域

在python中,函式會創建一個新的作用域。python開發者可能會說函式有自己的命名空間,差不多一個意思。這意味著在函式內部碰到一個變數的時候函式會優先在自己的命名空間裡面去尋找。讓我們寫一個簡單的函式看一下 本地作用域 和 全域性作用域有什麼不同:

  1. >>> a_string = "This is a global variable"
  2. >>> def foo():
  3. ...     print locals()
  4. >>> print globals()
  5. {..., 'a_string': 'This is a global variable'}
  6. >>> foo()

內置的函式 globals傳回一個包含所有python解釋器知道的變數名稱的字典(為了乾凈和洗的白白的,我省略了python自行創建的一些變數)。在#2我呼叫了函式 foo 把函式內部 本地作用域裡面的內容打印出來。我們能夠看到,函式 foo有自己獨立的命名空間,雖然暫時命名空間裡面什麼都還沒有。

3. 變數解析規則

當然這並不是說我們在函式裡面就不能訪問外面的全域性變數。在python的作用域規則裡面,創建變數一定會一定會在當前作用域里創建一個變數,但是訪問或者修改變數時會先在當前作用域查找變數,沒有找到匹配變數的話會依次向上在閉合的作用域裡面進行查看找。所以如果我們修改函式 foo的實現讓它打印全域性的作用域里的變數也是可以的:

  1. >>> a_string = "This is a global variable"
  2. >>> def foo():
  3. ...     print a_string

在#1處,python解釋器會嘗試查找變數 a_string,當然在函式的 本地作用域裡面是找不到的,所以接著會去上層的作用域裡面去查找。

但是另一方面,假如我們在函式內部給全域性變數賦值,結果卻和我們想的不一樣:

  1. >>> a_string = "This is a global variable"
  2. >>> def foo():
  3. ...     a_string = "test"

我們能夠看到,全域性變數能夠被訪問到(如果是可變資料型別(像list,dict這些)甚至能夠被更改)但是賦值不行。在函式內部的#1處,我們實際上 新創建了一個區域性變數, 隱藏全域性作用域中的同名變數。我們可以通過打印出區域性命名空間中的內容得出這個結論。我們也能看到在#2處打印出來的變數 a_string的值並沒有改變。

4. 變數生存周期

值得註意的一個點是,變數不僅是生存在一個個的命名空間內,他們都有自己的生存周期,請看下麵這個例子:

  1. >>> def foo():
  2. ...     x = 1
  3. >>> foo()
  4. >>> print x

1處發生的錯誤不僅僅是因為 作用域規則導致的(儘管這是丟擲了NameError的錯誤的原因)它還和python以及其它很多編程語言中函式呼叫實現的機制有關。在這個地方這個執行時間點並沒有什麼有效的語法讓我們能夠獲取變數 x的值,因為它這個時候壓根不存在!函式 foo的命名空間隨著函式呼叫開始而開始,結束而銷毀。

5. 函式引數

python允許我們向函式傳遞引數,引數會變成本地變數存在於函式內部。

  1. >>> def foo(x):
  2. ...     print locals()
  3. >>> foo(1)
  4. {'x': 1}

在Python里有很多的方式來定義和傳遞引數,完整版可以查看 python官方文件。我們這裡簡略的說明一下:函式的引數可以是必須的 位置引數或者是可選的 命名,預設引數

  1. >>> def foo(x, y=0):

在#1處我們定義了函式 foo,它有一個位置引數 x和一個命名引數 y。在#2處我們能夠通過常規的方式來呼叫函式,儘管有一個命名引數,但引數依然可以通過位置傳遞給函式。在呼叫函式的時候,對於命名引數 y我們也可以完全不管就像#3處所示的一樣。如果命名引數沒有接收到任何值的話,python會自動使用宣告的預設值也就是 0。需要註意的是我們不能省略第一個位置引數 x, 否則的話就會像#5處所示發生錯誤。

目前還算簡潔清晰吧, 但是接下來可能會有點令人困惑。python支持函式呼叫時的命名引數(個人覺得應該是命名引數)。看看#5處的函式呼叫,我們傳遞的是兩個命名引數,這個時候因為有名稱標識,引數傳遞的順序也就不用在意了。

當然相反的情況也是正確的:函式的第二個形參是 y,但是我們通過位置的方式傳遞值給它。在#2處的函式呼叫 foo(3,1),我們把 3傳遞給了第一個引數,把 1傳遞給了第二個引數,儘管第二個引數是一個命名引數。

桑不起,感覺用了好大一段才說清楚這麼一個簡單的概念:函式的引數可以有 名稱和 位置。這意味著在函式的定義和呼叫的時候會稍稍在理解上有點兒不同。我們可以給只定義了位置引數的函式傳遞命名引數(引數),反之亦然!如果覺得不夠可以查看官方文件

6. 嵌套函式

Python允許創建嵌套函式。這意味著我們可以在函式裡面定義函式而且現有的作用域和變數生存周期依舊適用。

  1. >>> def outer():
  2. ...     x = 1
  3. ...     def inner():
  4. ...         print x

這個例子有一點兒複雜,但是看起來也還行。

想一想在#1發生了什麼:python解釋器需找一個叫 x的本地變數,查找失敗之後會繼續在上層的作用域裡面尋找,這個上層的作用域定義在另外一個函式裡面。對函式 outer來說,變數 x是一個本地變數,但是如先前提到的一樣,函式 inner可以訪問封閉的作用域(至少可以讀和修改)。

在#2處,我們呼叫函式 inner,非常重要的一點是, inner也僅僅是一個遵循python變數解析規則的變數名,python解釋器會優先在 outer的作用域裡面對變數名 inner查找匹配的變數.

7. 函式是python世界里的一級類物件

顯而易見,在python里函式和其他東西一樣都是物件。(此處應該大聲歌唱)啊!包含變數的函式,你也並不是那麼特殊!

  1. >>> issubclass(int, object)

你也許從沒有想過,你定義的函式居然會有屬性。沒辦法,函式在python裡面就是物件,和其他的東西一樣,也許這樣描述會太學院派太官方了點:在python里,函式只是一些普通的值而已和其他的值一毛一樣。

這就是說你尅一把函式想引數一樣傳遞給其他的函式或者說從函式了裡面傳回函式!如果你從來沒有這麼想過,那看看下麵這個例子:

  1. >>> def add(x, y):
  2. ...     return x + y
  3. >>> def sub(x, y):
  4. ...     return x - y
  5. >>> def apply(func, x, y):

這個例子對你來說應該不會很奇怪。 add和 sub是非常普通的兩個python函式,接受兩個值,傳回一個計算後的結果值。

在#1處你們能看到準備接收一個函式的變數只是一個普通的變數而已,和其他變數一樣。

在#2處我們呼叫傳進來的函式:” ()代表著呼叫的操作並且呼叫變數包含的值。

在#3處,你們也能看到傳遞函式並沒有什麼特殊的語法。”函式的名稱只是很其他變數一樣的表識別符號而已。你們也許看到過這樣的行為:”python把頻繁要用的操作變成函式作為引數進行使用,像通過傳遞一個函式給內置排序函式的 key引數從而來自定義排序規則。那把函式當做傳回值回事這樣的情況呢:

  1. >>> def outer():
  2. ...     def inner():
  3. ...         print "Inside inner"
  4. ...     return inner

這個例子看起來也許會更加的奇怪。在#1處我把恰好是函式識別符號的變數 inner作為傳回值傳回出來。這並沒有什麼特殊的語法:”把函式 inner傳回出來,否則它根本不可能會被呼叫到。”還記得變數的生存周期嗎?每次函式 outer被呼叫的時候,函式 inner都會被重新定義,如果它不被當做變數傳回的話,每次執行過後它將不復存在。

在#2處我們捕獲住傳回值 – 函式 inner,將它存在一個新的變數 foo里。我們能夠看到,當對變數 foo進行求值,它確實包含函式 inner,而且我們能夠對他進行呼叫。初次看起來可能會覺得有點奇怪,但是理解起來並不困難是吧。堅持住,因為奇怪的轉折馬上就要來了(嘿嘿嘿嘿,我笑的並不猥瑣!)

8. 閉包

我們先不急著定義什麼是閉包,先來看看一段代碼,僅僅是把上一個例子簡單的調整了一下:

  1. >>> def outer():
  2. ...     x = 1
  3. ...     def inner():
  4. ...         print x

在上一個例子中我們瞭解到, inner作為一個函式被 outer傳回,儲存在一個變數 foo,並且我們能夠對它進行呼叫 foo()。不過它會正常的運行嗎?我們先來看看作用域規則。

所有的東西都在python的作用域規則下進行工作:” x是函式 outer里的一個區域性變數。當函式 inner在#1處打印 x的時候,python解釋器會在 inner內部查找相應的變數,當然會找不到,所以接著會到封閉作用域裡面查找,並且會找到匹配。

但是從變數的生存周期來看,該怎麼理解呢?我們的變數 x是函式 outer的一個本地變數,這意味著只有當函式 outer正在運行的時候才會存在。根據我們已知的python運行樣式,我們沒法在函式 outer傳回之後繼續呼叫函式 inner,在函式 inner被呼叫的時候,變數 x早已不復存在,可能會發生一個運行時錯誤。

萬萬沒想到,傳回的函式 inner居然能夠正常工作。Python支持一個叫做 函式閉包的特性,用人話來講就是,嵌套定義在 非全域性作用域裡面的函式能夠記住它在被定義的時候它所處的封閉命名空間。這能夠通過查看函式的 func_closure屬性得出結論,這個屬性裡面包含封閉作用域裡面的值(只會包含被捕捉到的值,比如 x,如果在 outer裡面還定義了其他的值,封閉作用域裡面是不會有的)

記住,每次函式 outer被呼叫的時候,函式 inner都會被重新定義。現在變數 x的值不會變化,所以每次傳回的函式 inner會是同樣的邏輯,假如我們稍微改動一下呢?

  1. >>> def outer(x):
  2. ...     def inner():
  3. ...         print x

從這個例子中你能夠看到 閉包 – 被函式記住的封閉作用域 – 能夠被用來創建自定義的函式,本質上來說是一個 硬編碼的引數。事實上我們並不是傳遞引數 1或者 2給函式 inner,我們實際上是創建了能夠打印各種數字的各種自定義版本。

閉包單獨拿出來就是一個非常強大的功能, 在某些方面,你也許會把它當做一個類似於面向物件的技術: outer像是給 inner服務的建構式, x像一個私有變數。使用閉包的方式也有很多:你如果熟悉python內置排序方法的引數 key,你說不定已經寫過一個 lambda方法在排序一個串列的串列的時候基於第二個元素而不是第一個。現在你說不定也可以寫一個 itemgetter方法,接收一個索引值來傳回一個完美的函式,傳遞給排序函式的引數 key

不過,我們現在不會用閉包做這麼low的事(⊙o⊙)…!相反, 讓我們再爽一次,寫一個高大上的 裝飾器!

9. 裝飾器

裝飾器其實就是一個閉包,把一個函式當做引數然後傳回一個替代版函式。我們一步步從簡到繁來瞅瞅:

  1. >>> def outer(some_func):
  2. ...     def inner():
  3. ...         print "before some_func"
  4. ...         ret = some_func()

仔細看看上面這個裝飾器的例子。們定義了一個函式 outer,它只有一個 some_func的引數,在他裡面我們定義了一個嵌套的函式 inner。 inner會打印一串字串,然後呼叫 some_func,在#1處得到它的傳回值。在 outer每次呼叫的時候 some_func的值可能會不一樣,但是不管 some_func的之如何,我們都會呼叫它。最後, inner傳回 some_func() + 1的值 – 我們通過呼叫在#2處儲存在變數 decorated裡面的函式能夠看到被打印出來的字串以及傳回值 2,而不是期望中呼叫函式 foo得到的傳回值 1

我們可以認為變數 decorated是函式 foo的一個裝飾版本,一個加強版本。事實上如果打算寫一個有用的裝飾器的話,我們可能會想願意用裝飾版本完全取代原先的函式 foo,這樣我們總是會得到我們的”加強版” foo。想要達到這個效果,完全不需要學習新的語法,簡單地賦值給變數 foo就行了:

  1. >>> foo = outer(foo)
  2. >>> foo

現在,任何怎麼呼叫都不會牽扯到原先的函式 foo,都會得到新的裝飾版本的 foo,現在我們還是來寫一個有用的裝飾器。

想象我們有一個庫,這個庫能夠提供類似坐標的物件,也許它們僅僅是一些x和y的坐標對。不過可惜的是這些坐標物件不支持數學運算子,而且我們也不能對原始碼進行修改,因此也就不能直接加入運算子的支持。我們將會做一系列的數學運算,所以我們想要能夠對兩個坐標物件進行合適加減運算的函式,這些方法很容易就能寫出:

  1. >>> class Coordinate(object):
  2. ...     def __init__(self, x, y):
  3. ...         self.x = x
  4. ...         self.y = y
  5. ...     def __repr__(self):
  6. ...         return "Coord: " + str(self.__dict__)
  7. >>> def add(a, b):
  8. ...     return Coordinate(a.x + b.x, a.y + b.y)
  9. >>> def sub(a, b):
  10. ...     return Coordinate(a.x - b.x, a.y - b.y)
  11. >>> one = Coordinate(100, 200)
  12. >>> two = Coordinate(300, 200)
  13. >>> add(one, two)
  14. Coord: {'y': 400, 'x': 400}

如果不巧我們的加減函式同時也需要一些邊界檢查的行為那該怎麼辦呢?搞不好你只能夠對正的坐標物件進行加減操作,任何傳回的值也都應該是正的坐標。所以現在的期望是這樣:

  1. >>> one = Coordinate(100, 200)
  2. >>> two = Coordinate(300, 200)
  3. >>> three = Coordinate(-100, -100)
  4. >>> sub(one, two)
  5. Coord: {'y': 0, 'x': -200}
  6. >>> add(one, three)
  7. Coord: {'y': 100, 'x': 0}

我們期望在不更改坐標物件 one, two, three的前提下 one減去 two的值是 {x: 0, y: 0}, one加上 three的值是 {x: 100, y: 200}。與其給每個方法都加上引數和傳回值邊界檢查的邏輯,我們來寫一個邊界檢查的裝飾器!

  1. >>> def wrapper(func):
  2. ...     def checker(a, b):

這個裝飾器能想先前的裝飾器例子一樣進行工作,傳回一個經過修改的函式,但是在這個例子中,它能夠對函式的輸入引數和傳回值做一些非常有用的檢查和格式化工作,將負值的 x和 y替換成 0。 
顯而易見,通過這樣的方式,我們的代碼變得更加簡潔:將邊界檢查的邏輯隔離到單獨的方法中,然後通過裝飾器包裝的方式應用到我們需要進行檢查的地方。

另外一種方式通過在計算方法的開始處和傳回值之前呼叫邊界檢查的方法也能夠達到同樣的目的。但是不可置否的是,使用裝飾器能夠讓我們以最少的代碼量達到坐標邊界檢查的目的。事實上,如果我們是在裝飾自己定義的方法的話,我們能夠讓裝飾器應用的更加有逼格。

10. 使用 @ 識別符號將裝飾器應用到函式

Python2.4支持使用識別符號 @將裝飾器應用在函式上,只需要在函式的定義前加上 @和裝飾器的名稱。在上一節的例子里我們是將原本的方法用裝飾後的方法代替:

  1. >>> add = wrapper(add)

這種方式能夠在任何時候對任意方法進行包裝。但是如果我們自定義一個方法,我們可以使用 @進行裝飾:

  1. >>> @wrapper
  2. ... def add(a, b):
  3. ...     return Coordinate(a.x + b.x, a.y + b.y)

需要明白的是,這樣的做法和先前簡單的用包裝方法替代原有方法是一毛一樣的, python只是加了一些語法糖讓裝飾的行為更加的直接明確和優雅一點。

11. args and *kwargs

我們已經完成了一個有用的裝飾器,但是由於硬編碼的原因它只能應用在一類具體的方法上,這類方法接收兩個引數,傳遞給閉包捕獲的函式。如果我們想實現一個能夠應用在任何方法上的裝飾器要怎麼做呢?再比如,如果我們要實現一個能應用在任何方法上的類似於計數器的裝飾器,不需要改變原有方法的任何邏輯。這意味著裝飾器能夠接受擁有任何簽名的函式作為自己的被裝飾方法,同時能夠用傳遞給它的引數對被裝飾的方法進行呼叫。

非常巧合的是Python正好有支持這個特性的語法。可以閱讀 Python Tutorial 獲取更多的細節。當定義函式的時候使用了 *,意味著那些通過位置傳遞的引數將會被放在帶有 *前綴的變數中, 所以:

  1. >>> def one(*args):
  2. ...     print args

第一個函式 one只是簡單地講任何傳遞過來的位置引數全部打印出來而已,你們能夠看到,在代碼#1處我們只是取用了函式內的變數 args*args僅僅只是用在函式定義的時候用來表示位置引數應該儲存在變數 args裡面。Python允許我們制定一些引數並且通過 args捕獲其他所有剩餘的未被捕捉的位置引數,就像#2處所示的那樣。

*運算子在函式被呼叫的時候也能使用。意義基本是一樣的。當呼叫一個函式的時候,一個用 *標誌的變數意思是變數裡面的內容需要被提取出來然後當做位置引數被使用。同樣的,來看個例子:

  1. >>> def add(x, y):
  2. ...     return x + y
  3. >>> lst = [1,2]
  4. >>> add(lst[0], lst[1])

1處的代碼和2處的代碼所做的事情其實是一樣的,在#2處,python為我們所做的事其實也可以手動完成。這也不是什麼壞事, *args要麼是表示呼叫方法大的時候額外的引數可以從一個可迭代串列中取得,要麼就是定義方法的時候標誌這個方法能夠接受任意的位置引數。

接下來提到的 **會稍多更複雜一點, **代表著鍵值對的引數字典,和 *所代表的意義相差無幾,也很簡單對不對:

  1. >>> def foo(**kwargs):
  2. ...     print kwargs
  3. >>> foo()
  4. {}
  5. >>> foo(x=1, y=2)
  6. {'y': 2, 'x': 1}

當我們定義一個函式的時候,我們能夠用 **kwargs來表明,所有未被捕獲的關鍵字引數都應該儲存在 kwargs的字典中。如前所訴, argshe kwargs並不是python語法的一部分,但在定義函式的時候,使用這樣的變數名算是一個不成文的約定。和 *一樣,我們同樣可以在定義或者呼叫函式的時候使用 **

  1. >>> dct = {'x': 1, 'y': 2}
  2. >>> def bar(x, y):
  3. ...     return x + y
  4. >>> bar(**dct)
  5. 3

12. 更通用的裝飾器

有了這招新的技能,我們隨隨便便就可以寫一個能夠記錄下傳遞給函式引數的裝飾器了。先來個簡單地把日誌輸出到界面的例子:

  1. >>> def logger(func):
  2. ...     def inner(*args, **kwargs):

請註意我們的函式 inner,它能夠接受任意數量和型別的引數並把它們傳遞給被包裝的方法,這讓我們能夠用這個裝飾器來裝飾任何方法。

  1. >>> @logger
  2. ... def foo1(x, y=1):
  3. ...     return x * y
  4. >>> @logger
  5. ... def foo2():
  6. ...     return 2
  7. >>> foo1(5, 4)
  8. Arguments were: (5, 4), {}
  9. 20
  10. >>> foo1(1)
  11. Arguments were: (1,), {}
  12. 1
  13. >>> foo2()
  14. Arguments were: (), {}
  15. 2

隨便呼叫我們定義的哪個方法,相應的日誌也會打印到輸出視窗,和我們預期的一樣。

(完)

看完本文有收穫?請轉發分享給更多人

關註「Python那些事」,做全棧開發工程師

推薦閱讀(點擊標題可跳轉閱讀)


全面深入理解 Python 面向物件

賊好理解,這個專案教你如何用百行代碼搞定各類NLP模型

神經網絡入門

    赞(0)

    分享創造快樂