<p>原文出處： dzone 譯文出處：Wu Cheng（@nullRef） </p>

1. 函數(shù)

在python中吮蛹，函數(shù)通過def關(guān)鍵字著摔、函數(shù)名和可選的參數(shù)列表定義陪腌。通過return關(guān)鍵字返回值楞泼。我們舉例來說明如何定義和調(diào)用一個簡單的函數(shù)：

def foo():
     return 1
foo()
1

方法體（當(dāng)然多行也是一樣的）是必須的闯冷，通過縮進來表示诡右，在方法名的后面加上雙括號()就能夠調(diào)用函數(shù)

2. 作用域

在python中，函數(shù)會創(chuàng)建一個新的作用域。python開發(fā)者可能會說函數(shù)有自己的命名空間摸屠，差不多一個意思。這意味著在函數(shù)內(nèi)部碰到一個變量的時候函數(shù)會優(yōu)先在自己的命名空間里面去尋找粱哼。讓我們寫一個簡單的函數(shù)看一下 本地作用域 和 全局作用域有什么不同：

a_string = "This is a global variable"
def foo():
     print locals()
print globals() # doctest: +ELLIPSIS
{, 'a_string': 'This is a global variable'}
foo() # 2
{}

內(nèi)置的函數(shù)globals返回一個包含所有python解釋器知道的變量名稱的字典（為了干凈和洗的白白的季二，我省略了python自行創(chuàng)建的一些變量）。在#2我調(diào)用了函數(shù) foo 把函數(shù)內(nèi)部本地作用域里面的內(nèi)容打印出來揭措。我們能夠看到胯舷，函數(shù)foo有自己獨立的命名空間，雖然暫時命名空間里面什么都還沒有绊含。

3. 變量解析規(guī)則

當(dāng)然這并不是說我們在函數(shù)里面就不能訪問外面的全局變量桑嘶。在python的作用域規(guī)則里面，創(chuàng)建變量一定會一定會在當(dāng)前作用域里創(chuàng)建一個變量躬充，但是訪問或者修改變量時會先在當(dāng)前作用域查找變量逃顶，沒有找到匹配變量的話會依次向上在閉合的作用域里面進行查看找。所以如果我們修改函數(shù)foo的實現(xiàn)讓它打印全局的作用域里的變量也是可以的：

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

在#1處充甚，python解釋器會嘗試查找變量a_string以政，當(dāng)然在函數(shù)的本地作用域里面是找不到的，所以接著會去上層的作用域里面去查找伴找。但是另一方面盈蛮，假如我們在函數(shù)內(nèi)部給全局變量賦值，結(jié)果卻和我們想的不一樣：

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'

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

4. 變量的生存周期

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

def foo():
     x = 1
foo()
print x # 1
Traceback (most recent call last):
 
NameError: name 'x' is not defined

#1處發(fā)生的錯誤不僅僅是因為作用域規(guī)則導(dǎo)致的（盡管這是拋出了NameError的錯誤的原因）它還和python以及其它很多編程語言中函數(shù)調(diào)用實現(xiàn)的機制有關(guān)十性。在這個地方這個執(zhí)行時間點并沒有什么有效的語法讓我們能夠獲取變量x的值叛溢，因為它這個時候壓根不存在！函數(shù)foo的命名空間隨著函數(shù)調(diào)用開始而開始劲适，結(jié)束而銷毀楷掉。

5. 函數(shù)參數(shù)

python允許我們向函數(shù)傳遞參數(shù)，參數(shù)會變成本地變量存在于函數(shù)內(nèi)部霞势。

def foo(x):
     print locals()
foo(1)
{'x': 1}

在Python里有很多的方式來定義和傳遞參數(shù)烹植，完整版可以查看 python官方文檔。我們這里簡略的說明一下：函數(shù)的參數(shù)可以是必須的位置參數(shù)或者是可選的命名愕贡，默認參數(shù)草雕。

def foo(x, y=0): # 1
     return x - y
foo(3, 1) # 2
2
foo(3) # 3
3
foo() # 4
Traceback (most recent call last):
 
TypeError: foo() takes at least 1 argument (0 given)
foo(y=1, x=3) # 5
2

在#1處我們定義了函數(shù)foo,它有一個位置參數(shù)x和一個命名參數(shù)y。在#2處我們能夠通過常規(guī)的方式來調(diào)用函數(shù)固以，盡管有一個命名參數(shù)墩虹，但參數(shù)依然可以通過位置傳遞給函數(shù)。在調(diào)用函數(shù)的時候憨琳，對于命名參數(shù)y我們也可以完全不管就像#3處所示的一樣诫钓。如果命名參數(shù)沒有接收到任何值的話，python會自動使用聲明的默認值也就是0篙螟。需要注意的是我們不能省略第一個位置參數(shù)x, 否則的話就會像#5處所示發(fā)生錯誤菌湃。

目前還算簡潔清晰吧， 但是接下來可能會有點令人困惑闲擦。python支持函數(shù)調(diào)用時的命名參數(shù)（個人覺得應(yīng)該是命名實參）慢味〕“穑看看#5處的函數(shù)調(diào)用墅冷，我們傳遞的是兩個命名實參，這個時候因為有名稱標識或油，參數(shù)傳遞的順序也就不用在意了寞忿。

當(dāng)然相反的情況也是正確的：函數(shù)的第二個形參是y，但是我們通過位置的方式傳遞值給它顶岸。在#2處的函數(shù)調(diào)用foo(3,1)腔彰，我們把3傳遞給了第一個參數(shù)，把1傳遞給了第二個參數(shù)辖佣，盡管第二個參數(shù)是一個命名參數(shù)霹抛。

桑不起，感覺用了好大一段才說清楚這么一個簡單的概念：函數(shù)的參數(shù)可以有名稱和位置卷谈。這意味著在函數(shù)的定義和調(diào)用的時候會稍稍在理解上有點兒不同杯拐。我們可以給只定義了位置參數(shù)的函數(shù)傳遞命名參數(shù)（實參），反之亦然！如果覺得不夠可以查看官方文檔

6. 嵌套函數(shù)

Python允許創(chuàng)建嵌套函數(shù)端逼。這意味著我們可以在函數(shù)里面定義函數(shù)而且現(xiàn)有的作用域和變量生存周期依舊適用朗兵。

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

這個例子有一點兒復(fù)雜，但是看起來也還行顶滩。想一想在#1發(fā)生了什么：python解釋器需找一個叫x的本地變量余掖，查找失敗之后會繼續(xù)在上層的作用域里面尋找，這個上層的作用域定義在另外一個函數(shù)里面礁鲁。對函數(shù)outer來說盐欺，變量x是一個本地變量，但是如先前提到的一樣仅醇，函數(shù)inner可以訪問封閉的作用域（至少可以讀和修改）找田。在#2處，我們調(diào)用函數(shù)inner着憨，非常重要的一點是墩衙，inner也僅僅是一個遵循python變量解析規(guī)則的變量名，python解釋器會優(yōu)先在outer的作用域里面對變量名inner查找匹配的變量.

7. 函數(shù)是python世界里的一級類對象

顯而易見甲抖，在python里函數(shù)和其他東西一樣都是對象漆改。（此處應(yīng)該大聲歌唱）啊准谚！包含變量的函數(shù)挫剑，你也并不是那么特殊！

issubclass(int, object) # all objects in Python inherit from a common baseclass
True
def foo():
     pass
foo.__class__ # 1
<type 'function'>
issubclass(foo.__class__, object)
True

你也許從沒有想過柱衔，你定義的函數(shù)居然會有屬性樊破。沒辦法，函數(shù)在python里面就是對象唆铐，和其他的東西一樣哲戚，也許這樣描述會太學(xué)院派太官方了點：在python里，函數(shù)只是一些普通的值而已和其他的值一毛一樣艾岂。這就是說你尅一把函數(shù)想?yún)?shù)一樣傳遞給其他的函數(shù)或者說從函數(shù)了里面返回函數(shù)顺少！如果你從來沒有這么想過，那看看下面這個例子：

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) # 3
3
apply(sub, 2, 1)
1

這個例子對你來說應(yīng)該不會很奇怪王浴。add和sub是非常普通的兩個python函數(shù)脆炎，接受兩個值，返回一個計算后的結(jié)果值氓辣。在#1處你們能看到準備接收一個函數(shù)的變量只是一個普通的變量而已秒裕，和其他變量一樣。在#2處我們調(diào)用傳進來的函數(shù)：“()代表著調(diào)用的操作并且調(diào)用變量包含的值钞啸。在#3處几蜻，你們也能看到傳遞函數(shù)并沒有什么特殊的語法癞松。” 函數(shù)的名稱只是很其他變量一樣的表標識符而已入蛆。

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

def outer():
     def inner():
         print "Inside inner"
     return inner # 1
 
foo = outer() #2
foo # doctest:+ELLIPSIS
<function inner at 0x>
foo()
Inside inner

這個例子看起來也許會更加的奇怪哨毁。在#1處我把恰好是函數(shù)標識符的變量inner作為返回值返回出來枫甲。這并沒有什么特殊的語法：”把函數(shù)inner返回出來，否則它根本不可能會被調(diào)用到扼褪∠牖茫“還記得變量的生存周期嗎？每次函數(shù)outer被調(diào)用的時候话浇，函數(shù)inner都會被重新定義脏毯，如果它不被當(dāng)做變量返回的話，每次執(zhí)行過后它將不復(fù)存在幔崖。

在#2處我們捕獲住返回值 – 函數(shù)inner食店，將它存在一個新的變量foo里。我們能夠看到赏寇，當(dāng)對變量foo進行求值吉嫩，它確實包含函數(shù)inner，而且我們能夠?qū)λM行調(diào)用嗅定。初次看起來可能會覺得有點奇怪自娩，但是理解起來并不困難是吧。堅持住渠退，因為奇怪的轉(zhuǎn)折馬上就要來了（嘿嘿嘿嘿忙迁，我笑的并不猥瑣！）

8. 閉包

我們先不急著定義什么是閉包碎乃，先來看看一段代碼姊扔，僅僅是把上一個例子簡單的調(diào)整了一下：

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作為一個函數(shù)被outer返回荠锭，保存在一個變量foo旱眯，并且我們能夠?qū)λM行調(diào)用foo()晨川。不過它會正常的運行嗎证九？我們先來看看作用域規(guī)則。

所有的東西都在python的作用域規(guī)則下進行工作：“x是函數(shù)outer里的一個局部變量共虑。當(dāng)函數(shù)inner在#1處打印x的時候愧怜，python解釋器會在inner內(nèi)部查找相應(yīng)的變量，當(dāng)然會找不到妈拌，所以接著會到封閉作用域里面查找拥坛，并且會找到匹配蓬蝶。

但是從變量的生存周期來看，該怎么理解呢猜惋？我們的變量x是函數(shù)outer的一個本地變量丸氛，這意味著只有當(dāng)函數(shù)outer正在運行的時候才會存在。根據(jù)我們已知的python運行模式著摔，我們沒法在函數(shù)outer返回之后繼續(xù)調(diào)用函數(shù)inner缓窜，在函數(shù)inner被調(diào)用的時候，變量x早已不復(fù)存在谍咆，可能會發(fā)生一個運行時錯誤禾锤。

萬萬沒想到，返回的函數(shù)inner居然能夠正常工作摹察。Python支持一個叫做函數(shù)閉包的特性恩掷，用人話來講就是，嵌套定義在非全局作用域里面的函數(shù)能夠記住它在被定義的時候它所處的封閉命名空間供嚎。這能夠通過查看函數(shù)的func_closure屬性得出結(jié)論黄娘，這個屬性里面包含封閉作用域里面的值（只會包含被捕捉到的值，比如x克滴，如果在outer里面還定義了其他的值寸宏，封閉作用域里面是不會有的)

記住，每次函數(shù)outer被調(diào)用的時候偿曙，函數(shù)inner都會被重新定義〉現(xiàn)在變量x的值不會變化，所以每次返回的函數(shù)inner會是同樣的邏輯望忆，假如我們稍微改動一下呢罩阵？

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

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

閉包單獨拿出來就是一個非常強大的功能歉备， 在某些方面傅是，你也許會把它當(dāng)做一個類似于面向?qū)ο蟮募夹g(shù)：outer像是給inner服務(wù)的構(gòu)造器，x像一個私有變量蕾羊。使用閉包的方式也有很多：你如果熟悉python內(nèi)置排序方法的參數(shù)key喧笔，你說不定已經(jīng)寫過一個lambda方法在排序一個列表的列表的時候基于第二個元素而不是第一個。現(xiàn)在你說不定也可以寫一個itemgetter方法龟再，接收一個索引值來返回一個完美的函數(shù)书闸，傳遞給排序函數(shù)的參數(shù)key。

不過利凑，我們現(xiàn)在不會用閉包做這么low的事(⊙o⊙)…浆劲！相反嫌术，讓我們再爽一次，寫一個高大上的裝飾器!

9. 裝飾器

裝飾器其實就是一個閉包牌借，把一個函數(shù)當(dāng)做參數(shù)然后返回一個替代版函數(shù)度气。我們一步步從簡到繁來瞅瞅：

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_func
2

仔細看看上面這個裝飾器的例子。們定義了一個函數(shù)outer膨报，它只有一個some_func的參數(shù)蚯嫌，在他里面我們定義了一個嵌套的函數(shù)inner。inner會打印一串字符串丙躏，然后調(diào)用some_func择示，在#1處得到它的返回值。在outer每次調(diào)用的時候some_func的值可能會不一樣晒旅，但是不管some_func的之如何栅盲，我們都會調(diào)用它。最后废恋，inner返回some_func() + 1的值 – 我們通過調(diào)用在#2處存儲在變量decorated里面的函數(shù)能夠看到被打印出來的字符串以及返回值2谈秫，而不是期望中調(diào)用函數(shù)foo得到的返回值1。

我們可以認為變量decorated是函數(shù)foo的一個裝飾版本鱼鼓，一個加強版本拟烫。事實上如果打算寫一個有用的裝飾器的話，我們可能會想愿意用裝飾版本完全取代原先的函數(shù)foo迄本，這樣我們總是會得到我們的”加強版“foo硕淑。想要達到這個效果，完全不需要學(xué)習(xí)新的語法嘉赎，簡單地賦值給變量foo就行了：

foo = outer(foo)
foo # doctest: +ELLIPSIS
<function inner at 0x>

現(xiàn)在置媳，任何怎么調(diào)用都不會牽扯到原先的函數(shù)foo，都會得到新的裝飾版本的foo公条，現(xiàn)在我們還是來寫一個有用的裝飾器拇囊。

想象我們有一個庫，這個庫能夠提供類似坐標的對象靶橱，也許它們僅僅是一些x和y的坐標對寥袭。不過可惜的是這些坐標對象不支持數(shù)學(xué)運算符，而且我們也不能對源代碼進行修改关霸，因此也就不能直接加入運算符的支持传黄。我們將會做一系列的數(shù)學(xué)運算，所以我們想要能夠?qū)蓚€坐標對象進行合適加減運算的函數(shù)谒拴，這些方法很容易就能寫出：

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.x, a.y - b.y)
one = Coordinate(100, 200)
two = Coordinate(300, 200)
add(one, two)
Coord: {'y': 400, 'x': 400}

如果不巧我們的加減函數(shù)同時也需要一些邊界檢查的行為那該怎么辦呢尝江？搞不好你只能夠?qū)φ淖鴺藢ο筮M行加減操作，任何返回的值也都應(yīng)該是正的坐標英上。所以現(xiàn)在的期望是這樣：

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}。與其給每個方法都加上參數(shù)和返回值邊界檢查的邏輯苍日，我們來寫一個邊界檢查的裝飾器惭聂！

def wrapper(func):
     def checker(a, b): # 1
         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
add = wrapper(add)
sub = wrapper(sub)
sub(one, two)
Coord: {'y': 0, 'x': 0}
add(one, three)
Coord: {'y': 200, 'x': 100}

這個裝飾器能想先前的裝飾器例子一樣進行工作，返回一個經(jīng)過修改的函數(shù)相恃，但是在這個例子中辜纲，它能夠?qū)瘮?shù)的輸入?yún)?shù)和返回值做一些非常有用的檢查和格式化工作，將負值的x和 y替換成0拦耐。

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

10. 使用 @ 標識符將裝飾器應(yīng)用到函數(shù)

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

add = wrapper(add)

這種方式能夠在任何時候?qū)θ我夥椒ㄟM行包裝盈简。但是如果我們自定義一個方法，我們可以使用@進行裝飾：

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

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

11. *args and **kwargs

我們已經(jīng)完成了一個有用的裝飾器先匪，但是由于硬編碼的原因它只能應(yīng)用在一類具體的方法上种吸，這類方法接收兩個參數(shù)，傳遞給閉包捕獲的函數(shù)呀非。如果我們想實現(xiàn)一個能夠應(yīng)用在任何方法上的裝飾器要怎么做呢坚俗？再比如，如果我們要實現(xiàn)一個能應(yīng)用在任何方法上的類似于計數(shù)器的裝飾器岸裙，不需要改變原有方法的任何邏輯猖败。這意味著裝飾器能夠接受擁有任何簽名的函數(shù)作為自己的被裝飾方法，同時能夠用傳遞給它的參數(shù)對被裝飾的方法進行調(diào)用降允。

非常巧合的是Python正好有支持這個特性的語法恩闻。可以閱讀 Python Tutorial 獲取更多的細節(jié)剧董。當(dāng)定義函數(shù)的時候使用了幢尚，意味著那些通過位置傳遞的參數(shù)將會被放在帶有前綴的變量中破停， 所以：

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允許我們制定一些參數(shù)并且通過args捕獲其他所有剩余的未被捕捉的位置參數(shù)，就像#2處所示的那樣理茎。

*操作符在函數(shù)被調(diào)用的時候也能使用黑界。意義基本是一樣的。當(dāng)調(diào)用一個函數(shù)的時候皂林，一個用*標志的變量意思是變量里面的內(nèi)容需要被提取出來然后當(dāng)做位置參數(shù)被使用朗鸠。同樣的，來看個例子：

def add(x, y):
     return x + y
lst = [1,2]
add(lst[0], lst[1]) # 1
3
add(*lst) # 2
3

#1處的代碼和#2處的代碼所做的事情其實是一樣的础倍，在#2處烛占，python為我們所做的事其實也可以手動完成。這也不是什么壞事著隆，args要么是表示調(diào)用方法大的時候額外的參數(shù)可以從一個可迭代列表中取得扰楼，要么就是定義方法的時候標志這個方法能夠接受任意的位置參數(shù)。接下來提到的會稍多更復(fù)雜一點美浦，代表著鍵值對的餐宿字典弦赖，和所代表的意義相差無幾，也很簡單對不對：

def foo(**kwargs):
     print kwargs
foo()
{}
foo(x=1, y=2)
{'y': 2, 'x': 1}

當(dāng)我們定義一個函數(shù)的時候浦辨，我們能夠用kwargs來表明蹬竖，所有未被捕獲的關(guān)鍵字參數(shù)都應(yīng)該存儲在kwargs的字典中。如前所訴流酬，argshe kwargs并不是python語法的一部分币厕，但在定義函數(shù)的時候，使用這樣的變量名算是一個不成文的約定芽腾。和一樣旦装，我們同樣可以在定義或者調(diào)用函數(shù)的時候使用*。

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

12. 更通用的裝飾器

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

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

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

@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