python基礎之閉包

本文轉自博客園alpha_panda的理解Python閉包概念（https://www.cnblogs.com/yssjun/p/9887239.html),簡單做了CSDN下的markdown排版。

概念介紹

維基百科中：

在計算機科學中，閉包（英語：Closure），又稱詞法閉包（Lexical Closure）或函數閉包（function closures），是引用了自由變量的函數。這個被引用的自由變量將和這個函數一同存在，即使已經離開了創造它的環境也不例外。所以，有另一種說法認爲閉包是由函數和與其相關的引用環境組合而成的實體。閉包在運行時可以有多個實例，不同的引用環境和相同的函數組合可以產生不同的實例。

簡單來說就是一個函數定義中引用了函數外定義的變量，並且該函數可以在其定義環境外被執行。這樣的一個函數我們稱之爲閉包。實際上閉包可以看做一種更加廣義的函數概念。因爲其已經不再是傳統意義上定義的函數。

根據我們對編程語言中函數的理解，大概印象中的函數是這樣的：
程序被加載到內存執行時，函數定義的代碼被存放在代碼段中。函數被調用時，會在棧上創建其執行環境，也就是初始化其中定義的變量和外部傳入的形參以便函數進行下一步的執行操作。當函數執行完成並返回函數結果後，函數棧幀便會被銷燬掉。函數中的臨時變量以及存儲的中間計算結果都不會保留。下次調用時唯一發生變化的就是函數傳入的形參可能會不一樣。函數棧幀會重新初始化函數的執行環境。

C++中有static關鍵字，函數中的static關鍵字定義的變量獨立於函數之外，而且會保留函數中值的變化。函數中使用的全局變量也有類似的性質。

但是閉包中引用的函數定義之外的變量是否可以這麼理解呢？但是如果函數中引用的變量既不是全局的，也不是靜態的(python中沒有這個概念)。應該怎麼正確的理解呢？
建議先參考一下我的另一篇博文Python UnboundLocalError和NameError錯誤根源解析，瞭解一下變量可見性和綁定相關的概念非常有必要。

閉包初探

爲了說明閉包中引用的變量的性質，可以看一下下面的這個例子：

def outer_func():
    loc_list = []
    def inner_func(name):
        loc_list.append(len(loc_list) + 1)  # 變量個數
        print '%s loc_list = %s' %(name, loc_list) 
    return inner_func

clo_func_0 = outer_func()
clo_func_0('clo_func_0')
clo_func_0('clo_func_0')
clo_func_0('clo_func_0')
clo_func_1 = outer_func()
clo_func_1('clo_func_1')
clo_func_0('clo_func_0')
clo_func_1('clo_func_1')

程序運行結果

clo_func_0 loc_list = [1]
clo_func_0 loc_list = [1, 2]
clo_func_0 loc_list = [1, 2, 3]
clo_func_1 loc_list = [1]
clo_func_0 loc_list = [1, 2, 3, 4]
clo_func_1 loc_list = [1, 2]

從上面這個簡單的例子應該對閉包有一個直觀的理解了。運行的結果也說明了閉包函數中引用的父函數中local variable既不具有C++中的全局變量的性質也沒有static變量的行爲。

在python中我們稱上面的這個loc_list爲閉包函數inner_func的一個自由變量(free variable)。

If a name is bound in a block, it is a local variable of that block. If a name is bound at the module level, it is a global variable. (The variables of the module code block are local and global.) If a variable is used in a code block but not defined there, it is a free variable.

在這個例子中我們至少可以對閉包中引用的自由變量有如下的認識：

• 閉包中的引用的自由變量只和具體的閉包有關聯，閉包的每個實例引用的自由變量互不干擾。
• 一個閉包實例對其自由變量的修改會被傳遞到下一次該閉包實例的調用。

由於這個概念理解起來並不是那麼的直觀，因此使用的時候很容易掉進陷阱。

閉包陷阱

下面再來看一個例子：

def my_func(*args):
    fs = []
    for i in xrange(3):
        def func():
            return i * i
        fs.append(func)
    return fs

fs1, fs2, fs3 = my_func()
print fs1()
print fs2()
print fs3()

上面這段代碼可謂是典型的錯誤使用閉包的例子。程序的結果並不是我們想象的結果0，1，4。實際結果全部是4。

這個例子中，my_func返回的並不是一個閉包函數，而是一個包含三個閉包函數的一個list。這個例子中比較特殊的地方就是返回的所有閉包函數均引用父函數中定義的同一個自由變量。

但這裏的問題是爲什麼for循環中的變量變化會影響到所有的閉包函數？尤其是我們上面剛剛介紹的例子中明明說明了同一閉包的不同實例中引用的自由變量互相沒有影響的。而且這個觀點也絕對的正確。

那麼問題到底出在哪裏？應該怎樣正確的分析這個錯誤的根源。

其實問題的關鍵就在於在返回閉包列表fs之前for循環的變量的值已經發生改變了，而且這個改變會影響到所有引用它的內部定義的函數。因爲在函數my_func返回前其內部定義的函數並不是閉包函數，只是一個內部定義的函數。

當然這個內部函數引用的父函數中定義的變量也不是自由變量，而只是當前block中的一個local variable。

def my_func(*args):
    fs = []
    j = 0
    for i in xrange(3):
        def func():
            return j * j
        fs.append(func)
    j = 2
    return fs

上面的這段代碼邏輯上與之前的例子是等價的。這裏或許更好理解一點，因爲在內部定義的函數func實際執行前，對局部變量j的任何改變均會影響到函數func的運行結果。

函數my_func一旦返回，那麼內部定義的函數func便是一個閉包，其中引用的變量j成爲一個只和具體閉包相關的自由變量。後面會分析，這個自由變量存放在Cell對象中。

使用lambda表達式重寫這個例子：

def my_func(*args):
    fs = []
    for i in xrange(3):
        func = lambda : i * i
        fs.append(func)
    return fs

經過上面的分析，我們得出下面一個重要的經驗：返回閉包中不要引用任何循環變量，或者後續會發生變化的變量。

這條規則本質上是在返回閉包前，閉包中引用的父函數中定義變量的值可能會發生不是我們期望的變化。

正確的寫法：

def my_func(*args):
    fs = []
    for i in xrange(3):
        def func(_i = i):
            return _i * _i
        fs.append(func)
    return fs

或者：

def my_func(*args):
    fs = []
    for i in xrange(3):
        func = lambda _i = i : _i * _i
        fs.append(func)
    return fs

正確的做法便是將父函數的local variable賦值給函數的形參。函數定義時，對形參的不同賦值會保留在當前函數定義中，不會對其他函數有影響。

另外注意一點，如果返回的函數中沒有引用父函數中定義的local variable，那麼返回的函數不是閉包函數。

閉包的應用

自由變元可以記錄閉包函數被調用的信息，以及閉包函數的一些計算結果中間值。而且被自由變量記錄的值，在下次調用閉包函數時依舊有效。

根據閉包函數中引用的自由變量的一些特性，閉包的應用場景還是比較廣泛的。後面會有文章介紹其應用場景之一——單例模式，限於篇幅，此處以裝飾器爲例介紹一下閉包的應用。

如果我們想對一個函數或者類進行修改重定義，最簡單的方法就是直接修改其定義。但是這種做法的缺點也是顯而易見的：

• 可能看不到函數或者類的定義
• 會破壞原來的定義，導致原來對類的引用不兼容
• 如果多人想在原來的基礎上定製自己函數，很容易衝突

使用閉包可以相對簡單的解決上面的問題，下面看一個例子：

def func_dec(func):
   def wrapper(*args):
       if len(args) == 2:
           func(*args)
       else:
           print 'Error! Arguments = %s'%list(args)
   return wrapper

@func_dec
def add_sum(*args):
   print sum(args)

# add_sum = func_dec(add_sum)
args = range(1,3)
add_sum(*args)

對於上面的這個例子，並沒有破壞add_sum函數的定義，只不過是對其進行了一層簡單的封裝。如果看不到函數的定義，也可以對函數對象進行封裝，達到相同的效果(即上面註釋掉的13行)，而且裝飾器是可以疊加使用的。

潛在的問題

但閉包的缺點也是很明顯的，那就是經過裝飾器裝飾的函數或者類不再是原來的函數或者類了。這也是使用裝飾器改變函數或者類的行爲與直接修改定義最根本的差別。

實際應用的時候一定要注意這一點，下面看一個使用裝飾器導致的一個很隱蔽的問題。

def counter(cls):
    obj_list = []
    def wrapper(*args, **kwargs):
        new_obj = cls(*args, **kwargs)
        obj_list.append(new_obj)
        print "class:%s'object number is %d" % (cls.__name__, len(obj_list))
        return new_obj
    return wrapper

@counter
class my_cls(object):
    STATIC_MEM = 'This is a static member of my_cls'
    def __init__(self, *args, **kwargs):
        print self, args, kwargs
        print my_cls.STATIC_MEM

這個例子中我們嘗試使用裝飾器來統計一個類創建的對象數量。當我們創建my_cls的對象時，會發現something is wrong!

Traceback (most recent call last):
  File "G:\Cnblogs\Alpha Panda\Main.py", line 360, in <module>
    my_cls(1,2, key = 'shijun')
  File "G:\Cnblogs\Alpha Panda\Main.py", line 347, in wrapper
    new_obj = cls(*args, **kwargs)
  File "G:\Cnblogs\Alpha Panda\Main.py", line 358, in __init__
    print my_cls.STATIC_MEM
AttributeError: 'function' object has no attribute 'STATIC_MEM'

如果對裝飾器不是特別的瞭解，可能會對這個錯誤感到詫異。經過裝飾器修飾後，我們定義的類my_cls已經成爲一個函數。

my_cls.__name__ == 'wrapper' and type(my_cls) is types.FunctionType

my_cls被裝飾器counter修飾，等價於 my_cls = counter(my_cls)。

顯然在上面的例子中，my_cls.STATIC_MEM是錯誤的，正確的用法是self.STATIC_MEM。

對象中找不到屬性的話，會到類空間中尋找，因此被裝飾器修飾的類的靜態屬性是可以通過其對象進行訪問的。雖然my_cls已經不是類，但是其調用返回的值卻是被裝飾之前的類的對象。

該問題同樣適用於staticmethod。那麼有沒有方法得到原來的類呢？當然可以，my_cls().__class__便是被裝飾之前的類的定義。

那有沒有什麼方法能讓我們還能通過my_cls來訪問類的靜態屬性，答案是肯定的。

def counter(cls):
    obj_list = []
    @functools.wraps(cls)
    def wrapper(*args, **kwargs):
        ... ...
    return wrapper

改寫裝飾器counter的定義，主要是對wrapper使用functools進行了一次包裹更新，使經過裝飾的my_cls看起來更像裝飾之前的類或者函數。該過程的主要原理就是將被裝飾類或者函數的部分屬性直接賦值到裝飾之後的對象。如WRAPPER_ASSIGNMENTS（name, module and doc, ）和WRAPPER_UPDATES（dict）等。但是該過程不會改變wrapper是函數這樣一個事實。

閉包的實現

本着會用加理解的原則，可以從應用層的角度來稍微深入的理解一下閉包的實現。畢竟要先會用python麼，如果一切都從源碼中學習，那成本的確有點高。

def outer_func():
    loc_var = "local variable"
    def inner_func():
        return loc_var
    return inner_func

import dis
dis.dis(outer_func)
clo_func = outer_func()
print clo_func()
dis.dis(clo_func)

爲了更加清楚理解上述過程，我們先嚐試給出outer_func.func_code中的部分屬性：

• outer_func.func_code.co_consts： (None, ‘local variable’, <code object inner_func at 025F7770, file “G:\Cnblogs\Alpha Panda\Main.py”, line 207>)
• outer_func.func_code.co_cellvars：(‘loc_var’,)
• outer_func.func_code.co_varnames：(‘inner_func’,)

嘗試反彙編上面這個簡單清晰的閉包例子，得到下面的結果：

 0 LOAD_CONST               1 ('local variable')　　　# 將outer_func.func_code.co_consts[1]放到棧頂
STORE_DEREF              0 (loc_var)　　　　　　　　# 將棧頂元素存放到cell對象的slot 0 
           6 LOAD_CLOSURE             0 (loc_var)　　　　　　　　# 將outer_func.func_code.co_cellvars[0]對象的索引放到棧頂
BUILD_TUPLE              1　　　　　　　　　　　　　　# 將棧頂1個元素取出，創建元組並將元組壓入棧中
LOAD_CONST              2 (<code object inner_func at 02597770, file "G:\Cnblogs\Alpha Panda\Main.py", line 207>)　# 將outer_func.func_code.co_consts[2]放到棧頂
MAKE_CLOSURE            0　　　　　　　　　　　　　　# 創建閉包，此時棧頂是閉包函數代碼段的入口，棧頂下面則是函數的free variables，也就是本例中的'local variable ',將閉包壓入棧頂
STORE_FAST              0 (inner_func)　　　　　　 # 將棧頂存放入outer_func.func_code.co_varnames[0]
           21 LOAD_FAST               0 (inner_func)　　　　　　 # 將outer_func.func_code.co_varnames[0]的引用放入棧頂
RETURN_VALUE 　　　　　　　　　　　　　　　　　　　　　 # Returns with TOS to the caller of the function.

local variable
           0 LOAD_DEREF               0 (loc_var)　　　　　　　　 # 將cell對象中的slot 0對象的引用壓入棧頂
RETURN_VALUE       　　　　　　　　　　　　　　　　　　　# Returns with TOS to the caller of the function

這個結果中，我們反彙編了外層函數及其返回的閉包函數(爲了便於查看，修改了部分行號)。從對上面兩個函數的反彙編的註釋可以大致瞭解閉包實現的步驟。

python閉包中引用的自由變量實際存放在一個Cell對象中，當自由變元被閉包引用時，便將Cell中存放的自由變量的引用放入棧頂。

本例中Cell對象及其存放的自由變量分別爲：

clo_func.func_closure[0]    #Cell Object
clo_func.func_closure[0].cell_contents == 'local variable'    # Free Variable

閉包實現的一個關鍵的地方是Cell Object，下面是官方給出的解釋：

“Cell” objects are used to implement variables referenced by multiple scopes. For each such variable, a cell object is created to store the value; the local variables of each stack frame that references the value contains a reference to the cells from outer scopes which also use that variable. When the value is accessed, the value contained in the cell is used instead of the cell object itself. This de-referencing of the cell object requires support from the generated byte-code; these are not automatically de-referenced when accessed. Cell objects are not likely to be useful elsewhere.

好了，限於篇幅就先介紹到這裏。重要的是理解的基礎上靈活的應用解決實際的問題並避免陷阱，希望本文能讓你對閉包有一個不一樣的認識。

總結：

1. 閉包是嵌套定義的內部函數引用了外部變量且被返回。
2. 閉包中的引用的自由變量只和具體的閉包有關聯，閉包的每個實例引用的自由變量互不干擾。
3. 一個閉包實例對其自由變量的修改會被傳遞到下一次該閉包實例的調用。
4. 在函數外部函數返回前其內部定義的函數並不是閉包函數，只是一個內部定義的函數。
5. 返回閉包中不要引用任何循環變量，或者後續會發生變化的變量。

補充 詳細博文請點擊：

• 在內函數中想修改閉包變量（外函數綁定給內函數的局部變量）的時候：
  • 在python3中，可以用nonlocal 關鍵字聲明 一個變量， 表示這個變量不是局部變量空間的變量，需要向上一層變量空間找這個變量。
  • 在python2中，沒有nonlocal這個關鍵字，我們可以把閉包變量改成可變類型數據進行修改，比如列表。
• 使用閉包的過程中，一旦外函數被調用一次返回了內函數的引用，雖然每次調用內函數，是開啓一個函數執行過後消亡，但是閉包變量實際上只有一份，每次開啓內函數都在使用同一份閉包變量