深入了解Python閉包概念

閉包并不隻是一個Python中的概念，在函數式程式設計語言中應用較為廣泛。了解python中的閉包一方面是能夠正确的使用閉包，另一方面可以好好體會和思考閉包的設計思想。

1.概念介紹

首先看一下維基上對閉包的解釋：

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

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

根據我們對程式設計語言中函數的了解，大概印象中的函數是這樣的：

程式被加載到記憶體執行時，函數定義的代碼被存放在代碼段中。函數被調用時，會在棧上建立其執行環境，也就是初始化其中定義的變量和外部傳入的形參以便函數進行下一步的執行操作。當函數執行完成并傳回函數結果後，函數棧幀便會被銷毀掉。函數中的臨時變量以及存儲的中間計算結果都不會保留。下次調用時唯一發生變化的就是函數傳入的形參可能會不一樣。函數棧幀會重新初始化函數的執行環境。

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

但是閉包中引用的函數定義之外的變量是否可以這麼了解呢？但是如果函數中引用的變量既不是全局的，也不是靜态的(python中沒有這個概念)。應該怎麼正确的了解呢？

2.閉包初探

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

ef 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.

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

閉包中的引用的自由變量隻和具體的閉包有關聯，閉包的每個執行個體引用的自由變量互不幹擾。

一個閉包執行個體對其自由變量的修改會被傳遞到下一次該閉包執行個體的調用。

由于這個概念了解起來并不是那麼的直覺，是以使用的時候很容易掉進陷阱。

3.閉包陷阱

下面先來看一個例子：

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，那麼傳回的函數不是閉包函數。

4.閉包的應用

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

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

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

可能看不到函數或者類的定義

會破壞原來的定義，導緻原來對類的引用不相容

如果多人想在原來的基礎上定制自己函數，很容易沖突

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

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行)，而且裝飾器是可以疊加使用的。

4.1 潛在的問題

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

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

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是函數這樣一個事實。

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

5.閉包的實作

本着會用加了解的原則，可以從應用層的角度來稍微深入的了解一下閉包的實作。畢竟要先會用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.