Python進階：攜帶狀態的閉包

閉包

在 Python 中，函數也是一個物件。因此，我們在定義函數時，可以再巢狀定義一個函數，並將該巢狀函數傳回，例如：

from math import pow
def make_pow(n):
    def inner_func(x):     # 嵌套定义了 inner_func
        return pow(x, n)   # 注意这里引用了外部函数的 n
    return inner_func      # 返回 inner_func

上面的程式碼中，函數 make_pow 裡面又定義了一個內部函數 inner_func ，然後將該函數傳回。因此，我們可以使用 make_pow 來產生另一個函數：

>> > pow2 = make_pow(2)  # pow2 是一个函数，参数 2 是一个自由变量
>> > pow2
<function inner_func at 0x10271faa0 >
>> > pow2(6)
36.0

我們也注意到，內部函數 inner_func 引用了外在函數 make_pow 的自由變數 n ，這也意味著，當函數 make_pow 的生命週期結束這，變項仍會保存在 inner_func 中，它被 inner_func 所引用。

>> > del make_pow         # 删除 make_pow
>> > pow3 = make_pow(3)
Traceback(most recent call last):
    File "<stdin>", line 1, in < module >
NameError:
    name &#39;make_pow&#39; is not defined
>> > pow2(9)     # pow2 仍可正常调用，自由变量 2 仍保存在 pow2 中
81.0

---|---

像上面這種情況，一個函數返回了一個內部函數，該內部函數引用了外部函數的相關參數和變量，我們把該返回的內部函數稱為閉包（ Closure ）。

在上面的例子中， inner_func 就是一個閉包，它引用了自由變數 n 。

閉包的作用

• 閉包的最大特點就是引用了自由變量，即使生成閉包的環境已經釋放，閉包仍然存在；

• 閉包在運行時可以有多個實例，即使傳入的參數相同，例如：

>> > pow_a = make_pow(2)
>> > pow_b = make_pow(2)
>> > pow_a == pow_b
False

• 利用閉包，我們也可以模擬類別的實例。

這裡構造一個類，用於求一個點到另一個點的距離：

from math import sqrt
class Point(object):
    def __init__(self, x, y):
        self.x, self.y = x, y
    def get_distance(self, u, v):
        distance = sqrt((self.x - u) ** 2 + (self.y - v) ** 2)
        return distance
>> > pt = Point(7, 2)        # 创建一个点
>> > pt.get_distance(10, 6)  # 求到另一个点的距离
5.0

用閉包來實現：

def point(x, y):
    def get_distance(u, v):
        return sqrt((x - u) ** 2 + (y - v) ** 2)
    return get_distance
>> > pt = point(7, 2)
>> > pt(10, 6)
5.0

可以看到，結果是一樣的，但使用閉包實現比使用類別更簡潔。

常見迷思

閉包的概念很簡單，但實現起來卻容易出現一些誤區，例如下面的例子：

def count():
    funcs = []
    for i in [1, 2, 3]:
        def f():
            return i
        funcs.append(f)
    return funcs

在這個例子中，我們在每次 for 循環中創建了一個函數，並將它存到 funcs 中。現在，呼叫上面的函數，你可能會認為回傳結果是 1, 2, 3，事實上卻不是：

>> > f1, f2, f3 = count()
>> > f1()
3
>> > f2()
3
>> > f3()
3

為什麼呢？原因在於上面的函數 f 引用了變數 i ，但函數 f 並非立刻執行，當 for 循環結束時，此時變數 i 的值為3， funcs 裡面的函數所引用的變數為3，而最終結果則全為3。

因此，我們應盡量避免在閉包中引用循環變量，或後續會發生變化的變量。

那上面這種情況該怎麼解決呢？我們可以再建立一個函數，並將循環變數的值傳給該函數，如下：

def count():
    funcs = []
    for i in [1, 2, 3]:
        def g(param):
            f = lambda: param    # 这里创建了一个匿名函数
            return f
        funcs.append(g(i))        # 将循环变量的值传给 g
    return funcs
>> > f1, f2, f3 = count()
>> > f1()
1
>> > f2()
2
>> > f3()
3

小結

• 閉包是攜帶自由變數的函數，即使創建閉包的外部函數的生命週期結束了，閉包所引用的自由變數仍會存在。

• 閉包在運作可以有多個實例。

• 盡量不要在閉包中引用循環變量，或後續會發生變化的變數。

以上就是Python進階：攜帶狀態的閉包的內容，更多相關內容請關注PHP中文網（www.php.cn）！