內建的函式globals返回一個包含所有python直譯器知道的變數名稱的字典.在#2我呼叫了函式 foo 把函式內部本地作用域裡面的內容打印出來。我們能夠看到，函式foo有自己獨立的名稱空間，雖然暫時名稱空間裡面什麼都還沒有。

私信菜鳥007獲取教程！

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

函式引數

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

進群：960410445  即可獲取數十套PDF!

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

巢狀函式

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

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

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

學會了嗎？