原文出處： dzone 譯文出處：Wu Cheng（@nullRef）

搞定裝飾器需要你了解一些函數式編程的概念，當然還有理解在python中定義和調用函數相關語法的一些特點。我沒法讓裝飾器變得簡單，但是通過一步步的剖析，我也許能夠讓你在理解裝飾器的時候更自信一點。

函數

在python中，函數通過def關鍵字、函數名和可選的參數列表定義。通過return關鍵字返回值。我們舉例來說明如何定義和調用一個簡單的函數：

def foo():
    return 1
foo()

作用域

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

a_string="This is a global variable"
def foo():
    print locals()

print globals()
#{..., 'a_string': 'This is a global variable'}
foo()#2
#{}

內置的函數globals返回一個包含所有python解釋器知道的變量名稱的字典.在#2我調用了函數 foo 把函數內部本地作用域里面的內容打印出來。我們能夠看到，函數foo有自己獨立的命名空間，雖然暫時命名空間里面什么都還沒有。

變量解析規則

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

a_string="This is a global variable"
def foo():
    print a_string #1
foo()
#This is a global variable

在#1處，python解釋器會嘗試查找變量a_string，當然在函數的本地作用域里面是找不到的，所以接著會去上層的作用域里面去查找。
但是另一方面，假如我們在函數內部給全局變量賦值，結果卻和我們想的不一樣：

a_string="This is a global variable"
def foo():
    a_string="test" #1
    print locals()

foo()
#{'a_string': 'test'}
print(a_string) #2
#This is a global variable

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

變量生存周期

值得注意的一個點是，變量不僅是生存在一個個的命名空間內，他們都有自己的生存周期，請看下面這個例子：

def foo():
    x=1
    print(x)

foo()
print(x)#1
#NameError: name 'x' is not defined

在#1處發生的錯誤不僅僅是因為作用域規則導致的盡管這是拋出了NameError的錯誤的原因）它還和python以及其它很多編程語言中函數調用實現的機制有關。在這個地方這個執行時間點并沒有什么有效的語法讓我們能夠獲取變量x的值，因為它這個時候壓根不存在！函數foo的命名空間隨著函數調用開始而開始，結束而銷毀。

函數參數

python允許我們向函數傳遞參數，參數會變成本地變量存在于函數內部。

def foo(x):
    print locals()

foo(x)
#{'x': 1}

嵌套函數

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

def outer():
    x=1
    def inner():
        print x #1
    return inner() #2

outer()

想一想在#1發生了什么：python解釋器需找一個叫x的本地變量，查找失敗之后會繼續在上層的作用域里面尋找，這個上層的作用域定義在另外一個函數里面。對函數outer來說，變量x是一個本地變量，但是如先前提到的一樣，函數inner可以訪問封閉的作用域（至少可以讀和修改）。在#2處，我們調用函數inner，非常重要的一點是，inner也僅僅是一個遵循python變量解析規則的變量名，python解釋器會優先在outer的作用域里面對變量名inner查找匹配的變量.

函數是python世界里的一級類對象

顯而易見，在python里函數和其他東西一樣都是對象。

print(issubclass(int, object))

def foo():
    pass
print(foo.__class__)
print(issubclass(foo.__class__,object))

你也許從沒有想過，你定義的函數居然會有屬性。沒辦法，函數在python里面就是對象，和其他的東西一樣，也許這樣描述會太學院派太官方了點：在python里，函數只是一些普通的值而已和其他的值一模一樣。這就是說你尅一把函數想參數一樣傳遞給其他的函數或者說從函數了里面返回函數！如果你從來沒有這么想過，那看看下面這個例子：

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

print(apply(add,3,4)) #3
print(apply(sub,5,2))

這個例子對你來說應該不會很奇怪。add和sub是非常普通的兩個python函數，接受兩個值，返回一個計算后的結果值。在#1處你們能看到準備接收一個函數的變量只是一個普通的變量而已，和其他變量一樣。在#2處我們調用傳進來的函數：“()代表著調用的操作并且調用變量包含的值。在#3處，你們也能看到傳遞函數并沒有什么特殊的語法?！?函數的名稱只是很其他變量一樣的表標識符而已。

你們也許看到過這樣的行為：“python把頻繁要用的操作變成函數作為參數進行使用，像通過傳遞一個函數給內置排序函數的key參數從而來自定義排序規則。那把函數當做返回值回事這樣的情況呢：

def outer():
    def inner():
        print "inside inner"
    return inner #1

foo=outer() #2
print(foo)

foo() 

這個例子看起來也許會更加的奇怪。在#1處我把恰好是函數標識符的變量inner作為返回值返回出來。這并沒有什么特殊的語法：”把函數inner返回出來，否則它根本不可能會被調用到?！斑€記得變量的生存周期嗎？每次函數outer被調用的時候，函數inner都會被重新定義，如果它不被當做變量返回的話，每次執行過后它將不復存在。

在#2處我們捕獲住返回值 – 函數inner，將它存在一個新的變量foo里。我們能夠看到，當對變量foo進行求值，它確實包含函數inner，而且我們能夠對他進行調用。初次看起來可能會覺得有點奇怪，但是理解起來并不困難是吧。

閉包

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

def outer():
    x = 1
    def inner():
        print(x) #1
    return  inner
foo=outer()
print(foo.func_closure)

在上一個例子中我們了解到，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會是同樣的邏輯，假如我們稍微改動一下呢？

def outer(x):
   def inner():
       print(x)
   return inner

print(outer(1))
print(outer(2))

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

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

裝飾器

裝飾器其實就是一個閉包，把一個函數當做參數然后返回一個替代版函數。我們一步步從簡到繁來瞅瞅：

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
print(decorated())

仔細看看上面這個裝飾器的例子。們定義了一個函數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就行了：

foo=outer(foo)
print(foo)

現在，任何怎么調用都不會牽扯到原先的函數foo，都會得到新的裝飾版本的foo，現在我們還是來寫一個有用的裝飾器。

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

class Coordinate(object):
    def __init__(self,x,y):
        self.x=x
        self.y=y

    def __repr__(self):
        return "Coord:"+str(self.__dict__)

def add(a,b):
    return Coordinate(a.x+b.x,a.y+b.y)
def sub(a,b):
    return Coordinate(a.x-b.y,a.x-b.y)
one=Coordinate(100,200)
two=Coordinate(300,200)

print(add(one,two))

如果不巧我們的加減函數同時也需要一些邊界檢查的行為那該怎么辦呢？搞不好你只能夠對正的坐標對象進行加減操作，任何返回的值也都應該是正的坐標。所以現在的期望是這樣：

one = Coordinate(100, 200)
two = Coordinate(300, 200)
three = Coordinate(-100, -100)
sub(one, two)
Coord: {'y': 0, 'x': -200}
add(one, three)
Coord: {'y': 100, 'x': 0}

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

class Coordinate(object):
    def __init__(self,x,y):
        self.x=x
        self.y=y

    def __repr__(self):
        return "Coord:"+str(self.__dict__)

def wrapper(func):
    def checker(a,b):
        if a.x<0 or a.y<0:
            a=Coordinate(a.x if a.x > 0 else 0,a.y if a.y >0 else 0)
        if b.x<0 or b.y<0:
            b=Coordinate(b.x if b.x > 0 else 0,b.y if b.y >0 else 0)
        ret=func(a,b)
        if ret.x <0 or ret.y<0:
            ret=Coordinate(ret.x if ret.x >0 else 0,ret.y if ret.y >0 else 0)
        return  ret
    return checker

def add(a,b):
    return Coordinate(a.x+b.x,a.y+b.y)
def sub(a,b):
    return Coordinate(a.x-b.y,a.x-b.y)
add=wrapper(add)
sub=wrapper(sub)
one=Coordinate(100,200)
two=Coordinate(300,200)
three=Coordinate(-200,-100)

在這個例子中，它能夠對函數的輸入參數和返回值做一些非常有用的檢查和格式化工作，將負值的x和 y替換成0。

顯而易見，通過這樣的方式，我們的代碼變得更加簡潔：將邊界檢查的邏輯隔離到單獨的方法中，然后通過裝飾器包裝的方式應用到我們需要進行檢查的地方。另外一種方式通過在計算方法的開始處和返回值之前調用邊界檢查的方法也能夠達到同樣的目的。但是不可置否的是，使用裝飾器能夠讓我們以最少的代碼量達到坐標邊界檢查的目的。事實上，如果我們是在裝飾自己定義的方法的話，我們能夠讓裝飾器應用的更加有逼格。

使用 @ 標識符將裝飾器應用到函數

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

add = wrapper(add)

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

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

@wrapper
def sub(a,b):
    return Coordinate(a.x-b.y,a.x-b.y)

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

*args and **kwargs

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

非常巧合的是Python正好有支持這個特性的語法,當定義函數的時候使用了，意味著那些通過位置傳遞的參數將會被放在帶有前綴的變量中， 所以：

def one(*args):
    print(args) #1

one()
#()
one(1,2,3)
#(1,2,3)
def two(x,y,*args):
    print(x,y,args) #2

two('a','b','c')
#('a', 'b', ('c',))

第一個函數one只是簡單地講任何傳遞過來的位置參數全部打印出來而已，你們能夠看到，在代碼#1處我們只是引用了函數內的變量args, *args僅僅只是用在函數定義的時候用來表示位置參數應該存儲在變量args里面。Python允許我們制定一些參數并且通過args捕獲其他所有剩余的未被捕捉的位置參數，就像#2處所示的那樣。
操作符在函數被調用的時候也能使用。意義基本是一樣的。當調用一個函數的時候，一個用標志的變量意思是變量里面的內容需要被提取出來然后當做位置參數被使用。同樣的，來看個例子：

def add(x,y):
    return  x+y

lst=[1,2]
print(add(lst[0],lst[1]))#1
print(add(*lst))#2

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

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

def foo(**kwargs):
    print( kwargs)

foo()
#{}
foo(x=1,y=2)
#{'y': 2, 'x': 1}

當我們定義一個函數的時候，我們能夠用kwargs來表明，所有未被捕獲的關鍵字參數都應該存儲在kwargs的字典中。args和 kwargs并不是python語法的一部分。但在定義函數的時候，使用這樣的變量名算是一個不成文的約定。和一樣，我們同樣可以在定義或者調用函數的時候使用*。

dct={'x':1,'y':2}
def bar(x,y):
    return x+y

print(bar(**dct))

更通用的裝飾器

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

def logger():
    def inner(*args,**kwargs):
        print("Arguments were:%s,%s" %(args,kwargs))
        return func(*args,**kwargs)
    return inner

請注意我們的函數inner，它能夠接受任意數量和類型的參數并把它們傳遞給被包裝的方法，這讓我們能夠用這個裝飾器來裝飾任何方法。

@logger
def foo1(x,y=1):
    return x*y
@logger
def foo2():
    return 2

print(foo1(5,4))
#Arguments were:(5, 4),{}
#20
print(foo1(1))
#Arguments were:(2,),{}
#1
print(foo2())
#Arguments were:(),{}
#2