前言
或許你已經(jīng)用過裝飾器，它的使用方式非常簡單但理解起來困難（其實真正理解的也很簡單），想要理解裝飾器，你需要懂點函數(shù)式編程的概念，python函數(shù)的定義以及函數(shù)調(diào)用的語法規(guī)則等，雖然我沒法把裝飾器變得簡單，但是我希望可以通過下面的步驟讓你由淺入深明白裝飾器是什么。假定你擁有最基本的Python知識，本文闡述的東西可能對那些在工作中經(jīng)常接觸Python的人有很大的幫助。
1、函數(shù)（Functions）
在Python里，函數(shù)是用def關(guān)鍵字后跟一個函數(shù)名稱和一個可選的參數(shù)表列來創(chuàng)建的，可以用關(guān)鍵字return指定返回值。下面讓我們創(chuàng)建和調(diào)用一個最簡單的函數(shù)：
1 2 3 4 | >>> def foo():... return 1>>> foo()1 |
該函數(shù)的函數(shù)體（在Python里將就是多行語句）是強(qiáng)制性的并且通過縮進(jìn)來表明。我們可以通過在函數(shù)名后面添加雙括號來調(diào)用函數(shù)。
2、作用域（Scope）
在Python中，每個函數(shù)都會創(chuàng)建一個作用域。Pythonistas也可能稱函數(shù)擁有它們自己的命名空間（namespace）。這意味著當(dāng)在函數(shù)體里遇到變量名時，Python首先在該函數(shù)的命名空間中查找，Python包含了一些讓我們查看命名空間的函數(shù)。讓我們寫一個簡單的函數(shù)來探查一下local和global作用域的區(qū)別。
1 2 3 4 5 6 7 | >>> a_string = "This is a global variable">>> def foo():... print locals()>>> print globals() # doctest: +ELLIPSIS{..., 'a_strin': 'This ia a global variable'}>>> foo() # 2{} |
內(nèi)建的globals函數(shù)返回一個字典對象，它包含所有Python知道的變量名(為了清楚明了起見，我已經(jīng)忽略了一些Python自動創(chuàng)建的變量)。在#2處我調(diào)用了函數(shù)foo，它將函數(shù)內(nèi)部的local namespace里的內(nèi)容打印了出來。正如我們看到的foo函數(shù)擁有自己的獨立namespace，現(xiàn)在它還是空的。
3、變量解析規(guī)則（variable resolution rules）
當(dāng)然，這并不意味著在函數(shù)內(nèi)部我們不能訪問全局變量。Python的作用域規(guī)則是，變量的創(chuàng)建總會創(chuàng)建一個新的local變量，但是變量的訪問（包括修改）會先查找local作用域然后順著最鄰近的作用域去尋找匹配。因此，如果我們修改foo函數(shù)來讓它打印global變量，結(jié)果就會像我們希望的那樣：
1 2 3 4 5 | >>> a_string = "This is global variable">>> def foo():... print a_string # 1>>> foo()This is a global variable |
在#1處，Python在函數(shù)中尋找一個local變量，但是沒有找到，然后在global變量中找到了一個同名的變量。
另一方面，如果我們嘗試在函數(shù)里給global變量賦值，結(jié)果將不如我們所愿：
1 2 3 4 5 6 7 8 | >>> a_string = 'This is a global variable">>> def foo():... a_string = "test" # 1... print locals()>>> foo(){'a_string': 'test'}>>> a_string # 2'This is a global variable' |
正如我們所見，全局變量可以被訪問到（如果是可變類型，其甚至可以被改變），但是（默認(rèn)情況下）不能被賦值。在函數(shù)內(nèi)部的#1處我們實際上創(chuàng)建了一個新的local變量，它和全局變量擁有相同的名字，它將全局變量給覆蓋了。我們可以通過在foo函數(shù)內(nèi)部打印local namespace來發(fā)現(xiàn)到它已經(jīng)有了一個條目，通過對函數(shù)外部的#2處的輸出結(jié)果我們可以看到，變量a_string的值根本就沒有被改變。
4、變量的生命周期（Variable lifetime）
也要注意到，變量不僅“生活在”一個命名空間里，它們還有生命周期?？紤]下面的代碼：
1 2 3 4 5 6 7 | >>> def foo():... x = 1>>> foo()>>> print x # 1Traceback (most recent call last):...NameError: name 'x' is not defined |
在#1處不僅因為作用域規(guī)則引發(fā)了問題（盡管這是出現(xiàn)了NameError的原因），而且也出于在Python和許多其它語言里的函數(shù)調(diào)用實現(xiàn)的原因。此處，我們沒有任何可用的語法來獲取變量x的值——字面上是不存在的。每次當(dāng)調(diào)用foo函數(shù)時，它的namespace被重新構(gòu)建，并且當(dāng)函數(shù)結(jié)束時被銷毀。
5、函數(shù)的參數(shù)（Function parameters）
Python允許我們向函數(shù)傳遞參數(shù)。參數(shù)名成為了該函數(shù)的local變量。
1 2 3 4 | >>> def foo(x):... print locals()>>> foo(1){'x': 1} |
Python有許多不同的定義和傳遞函數(shù)參數(shù)的方法。要想更詳細(xì)深入地了解請參照the Python documentation on defining functions。這里我展示一個簡版：函數(shù)參數(shù)既可以是強(qiáng)制的位置參數(shù)(positional parameters)或者是命名參數(shù)，參數(shù)的默認(rèn)值是可選的。
1 2 3 4 5 6 7 8 9 10 11 12 | >>> def foo(x, y=0): # 1... return x - y>>> foo(3, 1) # 22>>> foo(3) # 33>>> foo() # 4Traceback (most recent call last):...TypeError: foo() takes at least 1 argument (0 given)>>> foo(y=1, x=3) # 52 |
在#1處我們定義了一個帶有一個位置參數(shù)x和一個命名參數(shù)y的函數(shù)。正如我們看到的，在#2處我們可以通過普通的值傳遞來調(diào)用函數(shù)，即使一個參數(shù)(譯者注：這里指參數(shù)y）在函數(shù)定義里被定義為一個命名參數(shù)。在#3處我們可以看到，我們甚至可以不為命名參數(shù)傳遞任何值就可以調(diào)用函數(shù)——如果foo函數(shù)沒有接收到傳給命名參數(shù)y的值，Python將會用我們聲明的默認(rèn)值0來調(diào)用函數(shù)。當(dāng)然，我們不能漏掉第一個（強(qiáng)制的，定好位置的）參數(shù)——#4以一個異常描述了這種錯誤。
都很清晰和直接，不是嗎？下面變得有點兒讓人疑惑——Python也支持函數(shù)調(diào)用時的命名參數(shù)而不只是在函數(shù)定義時。請看#5處，這里我們用兩個命名參數(shù)調(diào)用函數(shù)，盡管這個函數(shù)是以一個命名和一個位置參數(shù)來定義的。因為我們的參數(shù)有名字，所以我們傳遞的參數(shù)的位置不會產(chǎn)生任何影響。 相反的情形當(dāng)然也是正確的。我們的函數(shù)的一個參數(shù)被定義為一個命名參數(shù)但是我們通過位置傳遞參數(shù)—— #4處的調(diào)用foo(3, 1)將一個3作為第一個參數(shù)傳遞給我們排好序的參數(shù)x并將第二個參數(shù)（整數(shù)1）傳遞給第二個參數(shù)，盡管它被定義為一個命名參數(shù)。
Whoo!這就像用很多話來描述一個非常簡單的概念：函數(shù)的參數(shù)可以有名稱或者位置。
6、內(nèi)嵌函數(shù)（Nested functions）
Python允許創(chuàng)建嵌套函數(shù)，這意味著我們可以在函數(shù)內(nèi)聲明函數(shù)并且所有的作用域和聲明周期規(guī)則也同樣適用。
1 2 3 4 5 6 7 8 | >>> def outer():... x = 1... def inner():... print x # 1... inner() # 2...>>> outer()1 |
這看起來稍顯復(fù)雜，但其行為仍相當(dāng)直接，易于理解?？紤]一下在#1處發(fā)生了什么——Python尋找一個名為x的local變量，失敗了，然后在最鄰近的外層作用域里搜尋，這個作用域是另一個函數(shù)！變量x是函數(shù)outer的local變量，但是和前文提到的一樣，inner函數(shù)擁有對外層作用域的訪問權(quán)限（最起碼有讀和修改的權(quán)限）。在#2處我們調(diào)用了inner函數(shù)。請記住inner也只是一個變量名，它也遵從Python的變量查找規(guī)則——Python首先在outer的作用域里查找之，找到了一個名為inner的local變量。
7、函數(shù)是一等公民（Functions are first class objects in Python）
在Python中，這是一個常識，函數(shù)是和其它任何東西一樣的對象。呃，函數(shù)包含變量，它不是那么的特殊！
1 2 3 4 5 6 | >>> issubclass(int, object) # all objects in Python inherit from a common baseclassTrue>>> def foo():... pass>>> foo.__class__ # 1>>> issubclass(foo.__class__, object)True |
你也許從沒想到過函數(shù)也有屬性，但是在Python中，和其它任何東西一樣，函數(shù)是對象。（如果你發(fā)覺這令你感到困惑，請等一下，知道你了解到在Python中像其它任何東西一樣，class也是對象?。┮苍S正是因為這一點使Python多少有點“學(xué)術(shù)”的意味——在Python中像其它任何值一樣只是常規(guī)的值而已。這意味著你可以將函數(shù)作為參數(shù)傳遞給函數(shù)或者在函數(shù)中將函數(shù)作為返回值返回！如果你從未考慮過這種事情請考慮下如下的合法Python代碼：
1 2 3 4 5 6 7 8 9 10 | >>> def add(x, y):... return x + y>>> def sub(x, y):... return x - y>>> def apply(func, x, y): # 1... return func(x, y) # 2>>> apply(add, 2, 1) # 33>>> apply(sub, 2, 1)1 |
這個例子對你來說可能也不是太奇怪——add和sub是標(biāo)準(zhǔn)的Python函數(shù)，它們都接受兩個值并返回一個計算了的結(jié)果。在#1處你可以看到變量接受一個函數(shù)就像其它任何普通的變量。在#2處我們調(diào)用傳入apply的函數(shù)——在Python里雙括號是調(diào)用操作符，并且調(diào)用變量名包含的值。在#3處你可以看出在Python中將函數(shù)當(dāng)做值進(jìn)行傳遞并沒有任何特殊語法——函數(shù)名就像任何其它變量一樣只是變量標(biāo)簽。
你之前可能見過這種行為——Python將函數(shù)作為參數(shù)經(jīng)常見于像通過為key參數(shù)提供一個函數(shù)來自定義sorted內(nèi)建函數(shù)等操作中。但是，將函數(shù)作為返回值返回會怎樣呢？請考慮：
1 2 3 4 5 6 7 8 9 10 | >>> def outer():... def inner():... print "Inside inner"... return inner # 1...>>> foo = outer() #2>>> foo # doctest:+ELLIPSIS<function inner at 0x...>>>> foo()Inside inner |
這乍看起來有點奇怪。在#1處我返回了變量inner，它碰巧是一個函數(shù)標(biāo)簽。這里沒有特殊語法——我們的函數(shù)返回了inner函數(shù)（調(diào)用outer()函數(shù)并不產(chǎn)生可見的執(zhí)行）。還記得變量的生命周期嗎？每當(dāng)outer函數(shù)被調(diào)用時inner函數(shù)就會重新被定義一次，但是如果inner函數(shù)不被(outer)返回那么當(dāng)超出outer的作用域后，inner將不復(fù)存在了。
在#2處我們可以獲取到返回值，它是我們的inner函數(shù)，它被存儲于一個新的變量foo。我們可以看到，如果我們計算foo，它真的包含inner函數(shù)，我們可以通過使用調(diào)用運(yùn)算符（雙括號，還記得嗎？）來調(diào)用它。這看起來可能有點怪異，但是到目前為止沒有什么難以理解，不是么？挺住，因為接下來的東西將會很怪異。
8、閉包（Closures）
讓我們不從定義而是從另一個代碼示例開始。如果我們將上一個例子稍加修改會怎樣呢？
1 2 3 4 5 6 7 8 | >>> def outer():... x = 1... def inner():... print x # 1... return inner>>> foo = outer()>>> foo.func_closure # doctest: +ELLIPSIS(<cell at 0x...: int object at 0x...>,) |
從上一個例子中我們看到inner是一個由outer返回的函數(shù)，存儲于一個名為foo的變量，我們可以通過foo()調(diào)用它。但是它能運(yùn)行嗎？讓我們先來考慮一下作用域規(guī)則。
一切都依照Python的作用域規(guī)則而運(yùn)行——x是outer函數(shù)了一個local變量。當(dāng)inner在#1處打印x時，Python在inner中尋找一個local變量，沒有找到；然后它在外層作用域即outer函數(shù)中尋找并找到了它。
但是自此處從變量生命周期的角度來看又會如何呢？變量x是函數(shù)outer的local變量，這意味著只有當(dāng)outer函數(shù)運(yùn)行時它才存在。只有當(dāng)outer返回后我們才能調(diào)用inner，因此依照我們關(guān)于Python如何運(yùn)作的模型來看，在我們調(diào)用inner的時候x已經(jīng)不復(fù)存在了，那么某個運(yùn)行時錯誤可能會出現(xiàn)。
事實與我們的預(yù)想并不一致，返回的inner函數(shù)的確正常運(yùn)行。Python支持一種稱為閉包(function closures)的特性，這意味著定義于非全局作用域的inner函數(shù)在定義時記得它們的外層作用域長什么樣。這可以通過查看inner函數(shù)的func_closure屬性來查看，它包含了外層作用域里的變量。
請記住，每次當(dāng)outer函數(shù)被調(diào)用時inner函數(shù)都被重新定義一次。目前x的值沒有改變，因此我們得到的每個inner函數(shù)和其它的inner函數(shù)擁有相同的行為，但是如果我們將它做出一點改變呢？
1 2 3 4 5 6 7 8 9 10 | >>> def outer(x):... def inner():... print x # 1... return inner>>> print1 = outer(1)>>> print2 = outer(2)>>> print1()1>>> print2()2 |
從這個例子中你可以看到closures——函數(shù)記住他們的外層作用域的事實——可以用來構(gòu)建本質(zhì)上有一個硬編碼參數(shù)的自定義函數(shù)。我們沒有將數(shù)字1或者2傳遞給我們的inner函數(shù)但是構(gòu)建了能"記住"其應(yīng)該打印數(shù)字的自定義版本。
closures就是一個強(qiáng)有力的技術(shù)——你甚至想到在某些方面它有點類似于面向?qū)ο蠹夹g(shù)：outer是inner的構(gòu)造函數(shù)，x扮演著一個類似私有成員變量的角色。它的作用有很多，如果你熟悉Python的sorted函數(shù)的key參數(shù)，你可能已經(jīng)寫過一個lambda函數(shù)通過第二項而不是第一項來排序一些列l(wèi)ist。也許你現(xiàn)在可以寫一個itemgetter函數(shù)，它接收一個用于檢索的索引并返回一個函數(shù)，這個函數(shù)適合傳遞給key參數(shù)。
但是讓我們不要用閉包做任何噩夢般的事情！相反，讓我們重新從頭開始來寫一個decorator!
9、裝飾器（Decorators）
一個decorator只是一個帶有一個函數(shù)作為參數(shù)并返回一個替換函數(shù)的閉包。我們將從簡單的開始一直到寫出有用的decorators。
1 2 3 4 5 6 7 8 9 10 11 12 | >>> def outer(some_func):... def inner():... print "before some_func"... ret = some_func() # 1... return ret + 1... return inner>>> def foo():... return 1>>> decorated = outer(foo) # 2>>> decorated()before some_func2 |
請仔細(xì)看我們的decorator實例。我們定義了一個接受單個參數(shù)some_func的名為outer的函數(shù)。在outer內(nèi)部我們定義了一個名為inner的嵌套函數(shù)。inner函數(shù)打印一個字符串然后調(diào)用some_func，在#1處緩存它的返回值。some_func的值可能在每次outer被調(diào)用時不同，但是無論它是什么我們都將調(diào)用它。最終，inner返回some_func的返回值加1，并且我們可以看到，當(dāng)我們調(diào)用存儲于#2處decorated里的返回函數(shù)時我們得到了輸出的文本和一個返回值2而不是我們期望的調(diào)用foo產(chǎn)生的原始值1.
我們可以說decorated變量是foo的一個“裝飾”版本——由foo加上一些東西構(gòu)成。實際上，如果我們寫了一個有用的decorator，我們可能想用裝飾后的版本來替換foo，從而可以得到foo的“增添某些東西”的版本。我們可以不用學(xué)習(xí)任何新語法而做到這一點——重新將包含我們函數(shù)的變量進(jìn)行賦值：
1 2 3 | >>> foo = outer(foo)>>> foo # doctest: +ELLIPSIS<function inner at 0x...> |
現(xiàn)在任何對foo()的調(diào)用都不會得到原始的foo，而是會得到我們經(jīng)過裝飾的版本！領(lǐng)悟到了一些decorator的思想嗎？
10、裝飾器的語法糖--@符號（The @ symbol applies a decorator to a function）
Python 2.4通過在函數(shù)定義前添加一個@符號實現(xiàn)對函數(shù)的包裝。在上面的代碼示例中，我們用一個包裝了的函數(shù)來替換包含函數(shù)的變量來實現(xiàn)了包裝。
1 | >>> add = wrapper(add) |
這一模式任何時候都可以用來包裝任何函數(shù)，但是如果們定義了一個函數(shù)，我們可以用@符號像下面示例那樣包裝它：
1 2 3 | >>> @wrapper... def add(a, b):... return Coordinate(a.x + b.x, a.y + b.y) |
請注意，這種方式和用wrapper函數(shù)的返回值來替換原始變量并沒有任何不同，Python只是增添了一些語法糖(syntactic sugar)讓它看起來更明顯一點。
11、*args and **kwargs
我們已經(jīng)寫了一個有用的decorator，但是它是硬編碼的，它只適用于特定種類的函數(shù)——帶有兩個參數(shù)的函數(shù)。我們函數(shù)內(nèi)部的checker函數(shù)接受了兩個參數(shù)，然后繼續(xù)將參數(shù)閉包里的函數(shù)。如果我們想要一個能包裝任何類型函數(shù)的decorator呢？讓我們實現(xiàn)一個在不改變被包裝函數(shù)的前提下對每一次被包裝函數(shù)的調(diào)用增添一次計數(shù)的包裝器。這意味著這個decorator需要接受所有待包裝的任何函數(shù)并將傳遞給它的任何參數(shù)傳遞給被包裝的函數(shù)來調(diào)用它（被包裝的函數(shù)）。
這種情況很常見，所以Python為這一特性提供了語法支持。請確保閱讀Python Tutorial以了解更多，但是在函數(shù)定義時使用*運(yùn)算符意味著任何傳遞給函數(shù)的額外位置參數(shù)最終以一個*作為前導(dǎo)。因此：
1 2 3 4 5 6 7 8 9 10 | >>> def one(*args):... print args # 1>>> one()()>>> one(1, 2, 3)(1, 2, 3)>>> def two(x, y, *args): # 2... print x, y, args>>> two('a', 'b', 'c')a b ('c') |
第一個函數(shù)one只是簡單的將任何（如果有）傳遞給它的位置參數(shù)打印出來。正如你在#1處見到的，在函數(shù)內(nèi)部我們只是引用了args變量——*args只是表明在函數(shù)定義中位置參數(shù)應(yīng)該保存在變量args中。Python也允許我們指定一些變量并捕獲到任何在args變量里的其它參數(shù)，正如#2處所示。
*運(yùn)算符也可以用于函數(shù)調(diào)用中，這時它也有著類似的意義。在調(diào)用一個函數(shù)時帶有一個以*為前導(dǎo)的變量作為參數(shù)表示這個變量內(nèi)容需要被解析然后用作位置參數(shù)。再一次以實例來說明：
1 2 3 4 5 6 7 | >>> def add(x, y):... return x + y>>> lst = [1, 2]>>> add(lst[0], lst[1]) # 13>>> add(*lst) # 23 |
#1處的代碼抽取出了和#2處相同的參數(shù)——在#2處Python為我們自動解析了參數(shù)，我們也可以像在#1處一樣自己解析出來。這看起來不錯，*args既表示當(dāng)調(diào)用函數(shù)是從一個iterable抽取位置參數(shù)，也表示當(dāng)定義一個函數(shù)是接受任何額外的位置變量。
當(dāng)我們引入**時，事情變得更加復(fù)雜點，與*表示iterables和位置參數(shù)一樣，**表示dictionaries & key/value對。很簡單，不是么？
1 2 3 4 5 6 | >>> def foo(**kwargs):... print kwargs>>> foo(){}>>> foo(x=1, y=2){'y': 2, 'x': 1} |
當(dāng)我們定義一個函數(shù)時我們可以用**kwargs表明所有未捕獲的keyword變量應(yīng)該被存儲在一個名為kwargs的字典中。前面的例子中的args和本例中的kwargs都不是Python語法的一部分，但是在函數(shù)定義時使用這兩個作為變量名時一種慣例。就像*一樣，我們可以在函數(shù)調(diào)用時使用**。
1 2 3 4 5 | >>> dct = {'x': 1, 'y': 2}>>> def bar(x, y):... rturn x + y>>> bar(**dct)3 |
12、更通用的裝飾器（More generic decorators）
用我們掌握的新“武器”我們可以寫一個decorator用來“記錄”函數(shù)的參數(shù)。為了簡單起見，我們將其打印在stdout上：
1 2 3 4 5 | >>> def logger(func):... def inner(*args, **kwargs): # 1... print "Arguments were: %s, %s" % (args, kwargs)... return func(*args, **kwargs) # 2... return inner |
注意到在#1處inner函數(shù)帶有任意數(shù)量的任何類型的參數(shù)，然后在#2處將它們傳遞到被包裝的函數(shù)中。這允許我們包裝或者裝飾任何函數(shù)。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | >>> @logger... def foo1(x, y=1):... return x * y>>> @logger... def foo2():... return 2>>> foo1(5, 4)Arguments were: (5, 4), {}20>>> foo1(1)Arguments were: (1,), {}1>>> foo2()Arguments were: (),{}2 |
對函數(shù)的調(diào)用會產(chǎn)生一個"logging"輸出行，也會輸出一個如我們期望的函數(shù)返回值。
如果你一直跟到了最后一個實例，祝賀你，你已經(jīng)理解了decorators了！你可以用你新掌握的“武器”做更好的事情了。你也可能考慮進(jìn)一步學(xué)習(xí)，Bruce Eckel有一篇關(guān)于decorators的優(yōu)秀文章，他使用對象而不是函數(shù)實現(xiàn)了decorator。你可能會發(fā)現(xiàn)OOP代碼比我們的純函數(shù)版本更具可讀性。Bruce還有一篇后續(xù)文，providing parameters to decorators，用對象實現(xiàn)它可能也比函數(shù)實現(xiàn)更簡單。最后，你也可能會去探查一下內(nèi)建的functoolswraps函數(shù)，它是一個可以用在我們的裝飾器中用來修改函數(shù)的簽名的裝飾器，修改之后d的函數(shù)更像被裝飾的函數(shù)。
以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。
