Python 中的 Decorator(裝飾器) 是對一個函式或者方法的封裝，從而使其可以完成一些與自身功能無關的工作。
預備知識
一切皆物件
在 Python 中，所有的一切都被視為物件，任何的變數、函式、類等都是 object 的子類。因此除了變數之外，函式和類等也可以被指向和傳遞。
>>> def foo():
... pass
...
>>> def Foo():
... pass
...
>>> v = foo
>>> v
<function foo at 0x7f457ecb2b18>
>>> v = Foo
>>> v
<function Foo at 0x7f457ef96848>名稱空間
Python 通過提供 namespace 來實現重名函式/方法、變數等資訊的識別。其大致可以分為三種 namespace，分別為：
- local namespace: 區域性空間，作用範圍為當前函式或者類方法
- global namespace: 全域性空間，作用範圍為當前模組
- build-in namespace: 內建空間，在 Python 直譯器啟動時就已經具有的名稱空間，作用範圍為所有模組。例如：abs，all，chr，cmp，int，str 等內建函式，它們在直譯器啟動時就被自動載入。
當函式/方法、變數等資訊發生重名時，Python 會按照 local namespace -> global namespace -> build-in namespace 的順序搜尋使用者所需元素，並且以第一個找到此元素的 namespace 為準。
>>> # 重寫內建名字空間中的 str 函式
>>> def str(obj):
... print "This is str"
...
>>> str(1)
This is str閉包
閉包（Closure）是詞法閉包（Lexical Closure）的簡稱。簡單地說，閉包就是根據不同的配置資訊得到不同的結果。對閉包的具體定義有很多種說法，大致可以分為兩類：
- 一種說法認為閉包是符合一定條件的函式，比如一些參考資源中這樣定義閉包：閉包是在其詞法上下文中引用了自由變數的函式。
- 另一種說法認為閉包是由函式和與其相關的引用環境組合而成的實體。比如一些參考資源中這樣來定義：在實現深約束時，需要建立一個能顯式表示引用環境的東西，並將它與相關的子程式捆綁在一起，這樣捆綁起來的整體被稱為閉包。
以上兩種定義從某種意義上來說是對立的，一個認為閉包是函式，另一個認為閉包是函式和引用環境組成的整體。閉包確實可以認為就是函式，但第二種說法更確切些。閉包只是在形式和表現上像函式，但實際上不是函式。函式是一些可執行的程式碼，這些程式碼在函式被定義後就確定了，不會在執行時發生變化，所以一個函式只有一個例項。
閉包在執行時可以有多個例項，不同的引用環境和相同的函式組合可以產生不同的例項。所謂引用環境是指在程式執行中的某個點所有處於活躍狀態的約束所組成的集合。其中的約束是指一個變數的名字和其所代表的物件之間的聯絡。那麼為什麼要把引用環境與函式組合起來呢？這主要是因為在支援巢狀作用域的語言中，有時不能簡單直接地確定函式的引用環境。
在 Python 語言中，可以這樣簡單的理解閉包：一個閉包就是呼叫了一個函式 A，這個函式 A 返回了一個函式 B。這個返回的函式 B 就叫做閉包。在呼叫函式 A 的時候傳遞的引數就是對不同引用環境所做的配置。如下示例所示：
>>> def make_adder(addend):
... def adder(augend):
... return augend + addend
... return adder
...
>>> add1 = make_adder(11)
>>> add2 = make_adder(22)
>>> add1(100)
111
>>> add2(100)
122函數語言程式設計
函數語言程式設計指使用一系列的函式解決問題。函式僅接受輸入併產生輸出，不包含任何能影響產生輸出的內部狀態。任何情況下，使用相同的引數呼叫函式始終能產生同樣的結果。
函數語言程式設計就是一種抽象程度很高的程式設計正規化，純粹的函數語言程式設計語言編寫的函式沒有變數，因此，任意一個函式，只要輸入是確定的，輸出就是確定的，這種純函式我們稱之為沒有副作用。而允許使用變數的程式設計語言，由於函式內部的變數狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函式是有副作用的。函數語言程式設計的一個特點就是，允許把函式本身作為引數傳入另一個函式，還允許返回一個函式！
可以認為函數語言程式設計剛好站在了物件導向程式設計的對立面。物件通常包含內部狀態（欄位），和許多能修改這些狀態的函式，程式則由不斷修改狀態構成；函數語言程式設計則極力避免狀態改動，並通過在函式間傳遞資料流進行工作。但這並不是說無法同時使用函數語言程式設計和麵向物件程式設計，事實上，複雜的系統一般會採用物件導向技術建模，但混合使用函式式風格也能體現函式式風格的優點。
高階函式
高階函式即能接受函式作為引數的函式。因為在 Python 中一切皆物件，變數可以指向函式，函式名其實也是指向函式的變數。也就是說，我們可以將函式賦給其他變數，也就可以將函式作為引數傳遞給其他函式。
>>> def add(x, y, f):
... return f(x) + f(y)
...
>>> add(6, -9, abs)
15裝飾器（decorator）
Python 裝飾器的作用就是為已經存在的物件新增額外的功能。例如裝飾器可以用來 引入日誌、新增計時邏輯來檢測效能、給函式加入事務處理 等等。其實總體說起來，裝飾器也就是一個函式，一個用來包裝函式的函式。裝飾器在函式申明完成的時候被呼叫，呼叫之後申明的函式被換成一個被裝飾器裝飾過後的函式。簡單說，本質上，裝飾器就是一個返回函式的高階函式，也是一個閉包。
裝飾器的語法以 @ 開頭，接著是裝飾器要裝飾的函式的申明。
無參裝飾器
先來看一下裝飾器本身沒有引數的情況。例如，我們想要知道一個函式被呼叫時所花的時間，可以採用如下的方式實現：
# Author: Huoty
# Time: 2015-08-12 10:37:10
import time
def foo():
print `in foo()`
# 定義一個計時器，傳入一個函式，並返回另一個附加了計時功能的方法
def timeit(func):
# 定義一個內嵌的包裝函式，給傳入的函式加上計時功能的包裝
def wrapper():
start = time.clock()
func()
end = time.clock()
print `used:`, end - start
# 將包裝後的函式返回
return wrapper
# Script starts from here
foo = timeit(foo)
foo()Python 實現裝飾器的目的就是為了讓程式更加簡潔，上邊的程式碼可以繼續用裝飾器來簡化：
# Author: Huoty
# Time: 2015-08-12 10:37:10
import time
def timeit(func):
def wrapper():
start = time.clock()
func()
end =time.clock()
print `used:`, end - start
return wrapper
@timeit
def foo():
print `in foo()`
# Script starts from here
foo()由上例可以看出，裝飾器 @timeit 的作用等價與 foo = timeit(foo)。被裝飾器裝飾後的執行結果取決於裝飾函式的是想，如果裝飾函式返回被裝飾函式本身，就等於沒有裝飾，如果裝飾函式對被裝飾函式進行了包裝，並返回包裝後的函式，那呼叫函式時執行的就是包裝過的函式。
如果被裝飾的函式帶有引數，則在裝飾器中也應該為包裝函式提供對應的引數。如果被裝飾的函式引數不確定，則可以用如下方式實現：
# Author: Huoty
# Time: 2015-08-12 10:59:11
import time
def log(func):
def wrapper(*args, **kw):
print "call %s." % func.__name__
return func(*args, **kw)
return wrapper
@log
def now():
print time.asctime()
# Script starts from here
now()帶引數裝飾器
裝飾器本身也可以帶引數，但是通常對引數會有一定的要求。由於有引數的裝飾器函式在呼叫時只會使用應用時的引數，而不接收被裝飾的函式做為引數，所以必須在其內部再建立一個函式。如下示例所示：
# Author: Huoty
# Time: 2015-08-12 11:13:30
def deco(arg):
def _deco(func):
def __deco():
print("before %s called [%s]." % (func.__name__, arg))
func()
print(" after %s called [%s]." % (func.__name__, arg))
return __deco
return _deco
@deco("module")
def foo():
print(" foo() called.")
@deco("module2")
def hoo():
print(" hoo() called.")
# Script starts from here
foo()
hoo()上例中的第一個函式 deco 是裝飾器函式，它的引數是用來加強 加強裝飾 的。由於此函式並非被裝飾的函式物件，所以在內部必須至少建立一個接受被裝飾函式的函式，然後返回這個物件（實際上此時等效於 foo=decomaker(arg)(foo)）。
如果裝飾器和被裝飾函式都帶引數，則用如下實現是形式：
def deco(pm):
def _deco(func):
def __deco(*args, **kw):
ret =func(*args, **kw)
print "func result: ", ret
return ret ** pm
return __deco
return _deco
@deco(2)
def foo(x, y, z=1):
return x + y + z
print "deco_func result: %s" % foo(10, 20)輸出：
func result: 31
deco_func result: 961類裝飾器
裝飾器不經可以用來裝飾函式，還可以用來裝飾類。例如給類新增一個類方法：
>>> def bar(obj):
... print type(obj)
...
>>> def inject(cls):
... cls.bar = bar
... return cls
...
>>> @inject
... class Foo(object):
... pass
...
>>> foo = Foo()
>>> foo.bar()
<class `__console__.Foo`>內建裝飾器
內建的裝飾器有三個，分別是 staticmethod、classmethod 和 property，作用分別是把類中定義的例項方法變成靜態方法、類方法和類屬性。由於模組裡可以定義函式，所以靜態方法和類方法的用處並不是太多，除非你想要完全的物件導向程式設計。這三個裝飾器的實現都涉及到 描述符 的概念。
Functools 模組
Python的functools模組主要功能是對函式進行包裝，增加原有函式的功能，起主要內容包括：cmp_to_key, partial, reduce, total_ordering, update_wrapper, wraps。
函式也是一個物件，它有__name__等屬性。以上我們有一個 callin.py 的例子，我們用裝飾器裝飾之後的 now 函式，當我們用 now.__name__ 檢視時，發現它的 __name__ 已經從原來的`now`變成了`wrapper`。因為返回的那個wrapper()函式名字就是`wrapper`，所以，需要把原始函式的name等屬性複製到wrapper()函式中，否則，有些依賴函式簽名的程式碼執行就會出錯。當然，我們可以用wrapper.__name__ = func.__name__來實現，但是我們不必這麼麻煩，用 Python 內建的 functools.wraps 便可實現這樣的功能：
import functools
def log(text):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print(`%s %s():` % (text, func.__name__))
return func(*args, **kw)
return wrapper
return decorator用類實現裝飾器
除了可以用函式來實現裝飾器外，類也可以實現。Python 類有一個 __call__ 方法，它能夠讓物件可呼叫。因此可以用該特性來實現裝飾器。例如實現一個磁碟快取：
import os
import uuid
import glob
import pickle
class DiskCache(object):
_NAMESPACE = uuid.UUID("c875fb30-a8a8-402d-a796-225a6b065cad")
def __init__(self, func):
self._func = func
self.__name__ = func.__name__
self.__module__ = func.__module__
self.__doc__ = func.__doc__
self.cache_path = "/tmp/.diskcache"
def __call__(self, *args, **kw):
params_uuid = uuid.uuid5(self._NAMESPACE, "-".join(map(str, (args, kw))))
key = `{}-{}.cache`.format(self._func.__name__, str(params_uuid))
cache_file = os.path.join(self.cache_path, key)
if not os.path.exists(self.cache_path):
os.makedirs(self.cache_path)
try:
with open(cache_file, `rb`) as f:
val = pickle.load(f)
except:
val = self._func(*args, **kw)
try:
with open(cache_file, `wb`) as f:
pickle.dump(val, f)
except:
pass
return val
def clear_cache(self):
for cache_file in glob.iglob("{}/{}-*".format(self.cache_path, self.__name__)):
os.remove(cache_file)
@DiskCache
def add(x, y):
print "add: %s + %s" % (x, y)
return x, y輸出：
add.clear_cache()
print add(1, 2)
print add(2, 3)
print add(1, 2)
print "cached files:", os.listdir(add.cache_path)
add.clear_cache()
print "cached files:", os.listdir(add.cache_path)本質上，內建的 property 裝飾器也是一個類，只不過它是一個描述符。可以用類似的形式實現一個可快取的 property 裝飾器：
class CachedProperty(object):
def __init__(self, func, name=None, doc=None):
self.__name__ = name or func.__name__
self.__module__ = func.__module__
self.__doc__ = doc or func.__doc__
self.func = func
def __get__(self, obj, type=None):
if obj is None:
return self
value = obj.__dict__.get(self.__name__)
if value is None:
value = self.func(obj)
obj.__dict__[self.__name__] = value
return value
class Foo(object):
@CachedProperty
def foo(self):
print `first calculate`
result = `this is result`
return result
f = Foo()
print f.foo
print f.foo輸出：
first calculate
this is result
this is result多重灌飾
一個函式可以同時被多個裝飾器裝飾。裝飾的初始化在函式定義時完成，初始化順序為離函式定義最近的裝飾器首先被初始化，最遠的則最後被初始化，初始化只進行一次。而裝飾器的執行順序則跟初始化順序相反。
def decorator_a(func):
print "decorator_a"
def wrapper(*args, **kw):
print "call %s in decorator_a" % func.__name__
return func()
return wrapper
def decorator_b(func):
print "decorator_b"
def wrapper(*args, **kw):
print "call %s in decorator_b" % func.__name__
return func()
return wrapper
@decorator_a
@decorator_b
def foo():
print "foo"
print "-"*10
foo()
foo()輸出：
decorator_b
decorator_a
----------
call wrapper in decorator_a
call foo in decorator_b
foo
call wrapper in decorator_a
call foo in decorator_b
foo有以上示例可以看出，離函式定義最近的 decorator_b 裝飾器首先被初始化，在執行時則是裡函式定義最遠的 decorator_a 首先被執行。