python閉包與延時求值的簡單介紹

本文目錄一覽：

• 1、Python基礎之閉包
• 2、求幫助，Python閉包和返回函數問題
• 3、python函數的閉包怎麼理解

Python基礎之閉包

一.閉包的定義：

在一個函數的內部，再定義一個函數(內部函數)。這個內部函數引用了外部函數的變量，並且外部函數返回這個內部函數， 我們把這個使用外部函數變量的內部函數稱為 閉包 。

簡而言之， 閉包就是能夠讀取外部函數內的變量的函數。

例如：

形成閉包的兩個條件:

二.閉包的用途

① 可以讀取函數內部的變量

② 將一些變量的值始終保存到內存中

1.讀取函數內部的變量

在一般情況下，在函數外部我們是不能訪問到函數內部的變量的。但是， 有時想要在函數外部能夠訪問到函數內部的變量，那麼就可以使用閉包。

例如:

上面的代碼可以看出，print(a)會拋異常NameError: name ‘a’ is not defined。在函數f1的外面無法訪問它的變量的。

在函數f1裡面定義一個閉包函數就可以訪問到了

例如：

2.將一些變量的值始終保存到內存中

運行結果:

通過上面的輸出結果可以看出閉包保存了外部函數內的變量n1的值1，每次執行閉包都是在n1 = 1 基礎上進行計算的。

三.閉包的缺點

1. 由於閉包會使得函數中的變量都被保存在內存中，會增加 內存消耗 ，所以不能濫用閉包，否則會造成程序的性能問題，可能導致內存泄露

2. 閉包無法改變外部函數局部變量指向的內存地址

3. 返回閉包時，返回函數不要引用任何循環變量，或者後續會發生變化的變量

四.判斷一個函數是否是閉包

判斷一個函數是不是閉包，可以查看它的 closure 屬性。如果該函數是閉包，查看該屬性將會返回一個cell對象組成的tuple。如果我們分別對每個cell對象查看其cell_contents屬性，返回的內容就是閉包引用的自由變量的值。

運行結果:

閉包的__closure__方法，可以展示出閉包儲存了外部函數的兩個變量，cell的內存地址是什麼，在cell裡面儲存的對象類型是int，這個int儲存的內存地址是什麼。

閉包的__closure__方法，可以查看每個cell對象的內容

運行結果:

cell_contents解釋了局部變量在脫離函數後仍然可以在函數之外被訪問的原因，因為變量被存儲在cell_contents中了。

求幫助，Python閉包和返回函數問題

（1）unpack tuple和list, 可以讓函數返回多個值

def count():

return (1, 2, 3) # 或者 return [1, 2, 3]

# 把列表解包，把1 2 3 分別賦值給 a b c

a, b, c = count()

print a, b, c

# 輸出 1, 2, 3

（2）假設你知道Python的dict類型。Python中，在函數中定義一個變量的時候，會在一個隱藏的叫locals的dict裡面插入key-value，其中key是變量名，value是變量值。而引用一個變量的時候，則首先會在這個叫locals的dict裡面，根據變量名作為key，去查對應的值。

var = 1 # 你可以認為這裡進行了 locals[‘var’] = 1 的操作

print var # 在對var變量進行求值的時候，就在locals[‘var’]裡面找var變量對應的值

（3）for循環中，每次循環只是給 `i` 重新綁定值

for i in (1, 2, 3):

print i

print i

# 一次輸入 1 2 3 3

每次`for i in (1, 2, 3)`相當於在`print i`之前，進行了

`locals[‘i’] = 1`

`locals[‘i’] = 2`

`locals[‘i’] = 3`

的操作

所以最後的`print i`再去locals字典裡面找`i`的時候，就變成 3 了。

（4）閉包是 一個函數加上這個函數引用的外部變量

var = 1

def f():

print var

# 這裡的閉包是函數 f 和 f 引用的外部變量 var

def count():

var2 = 2

def f():

print var2

# 這裡的閉包是函數 f 和 f 引用的外部變量 var2

return f

拿第一個函數 f 來說。在 f 運行的時候，解釋器拿着’var’這個字符串去locals字典裡面找，發現找不到，於是在closure字典裡面找，最後closure字典裡面找，你可以認為就是找closure[‘var’]，然後發現找到對應的值。count裡面的 f 函數同理。

（為了容易理解，我這裡說謊了。實際上 f 壓根沒有closure，count裡面的 f 才有。其實closure壓根不是像locals那樣的字典）

（5）函數定義時，函數只是記錄變量的名字。

要區分什麼是名字，什麼是值。

`i = 1`這裡 i 只是名字，只是一個字符串 ‘i’ 。這句話運行完，locals[‘i’] = 1，就說 i 對應的值是1

def count():

fs = []

for i in range(1, 4):

# 定義一個函數，等價於運行了 locals[‘f’] = 真正生成的函數

# 每次循環，這裡都會重新生成一個函數，然後把重新生成的函數賦值給 locals[‘f’]

def f():

return i * i # 引用了’i’這個名字，但並不是引用了’i’對應的值

# 等價於 locals[‘fs’].append(locals[‘f’])

# f 不是函數，它只是一個名字’f’。f 引用的東西，也就是locals[‘f’]才是真正的函數

fs.append(f)

# 於是這個for循環生成了三個函數，這三個函數是沒有名字的，這個函數運行完後，它們跟’f’這個名字就毛關係都沒有了(是的我說慌了，但可以先不管)

# 把整個列表返回，這個列表包含了三個函數

return fs

# count()返回三個函數的列表，unpack 列表的語法把列表中的三個函數抽出來，重新給他們命名為 f1, f2, f3

# 也就是說，

# locals[‘f1’] = 列表中的第1個函數

# locals[‘f2’] = 列表中的第2個函數

# locals[‘f3’] = 列表中的第3個函數

# 這三個函數跟’f’這個名字現在毛關係都沒有。（其實是有的，但為了說明需要簡化，現在你可以完全不管括號裡面說的話）

f1, f2, f3 = count()

print f1(), f2(), f3()

# 好了我們運行它們，輸入都是 9

# def f():

# return i * i

這是因為 f1 現在對應的函數，裡面引用了 ‘i’ 這個字符串，我們根據 ‘i ‘這個字符串去找它對應的值，先找到 f 當前的locals字典，發現沒有，因為函數定義的時候沒有定義 i 變量。然後再去closure[‘i’]裡面找，因為Python是通過closure字典實現閉包的（就當它是對的好不好），所以我們可以在closure[‘i’]找到值，這個值就是我們上一次運行的時候count函數裡面殘留的locals[‘i’]，而由於for循環三遍之後，locals[‘i’] == 3，所以找到 i 的值就是3。所以最後輸出都是9

python函數的閉包怎麼理解

1. 閉包的概念

首先還得從基本概念說起，什麼是閉包呢？來看下維基上的解釋:

複製代碼代碼如下:

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

….

上面提到了兩個關鍵的地方： 自由變量 和 函數, 這兩個關鍵稍後再說。還是得在贅述下“閉包”的意思，望文知意，可以形象的把它理解為一個封閉的包裹，這個包裹就是一個函數，當然還有函數內部對應的邏輯，包裹裡面的東西就是自由變量，自由變量可以在隨着包裹到處遊盪。當然還得有個前提，這個包裹是被創建出來的。

在通過Python的語言介紹一下，一個閉包就是你調用了一個函數A，這個函數A返回了一個函數B給你。這個返回的函數B就叫做閉包。你在調用函數A的時候傳遞的參數就是自由變量。

舉個例子：

複製代碼代碼如下:

def func(name):

def inner_func(age):

print ‘name:’, name, ‘age:’, age

return inner_func

bb = func(‘the5fire’)

bb(26) # name: the5fire age: 26

這裡面調用func的時候就產生了一個閉包——inner_func,並且該閉包持有自由變量——name，因此這也意味着，當函數func的生命周期結束之後，name這個變量依然存在，因為它被閉包引用了，所以不會被回收。

另外再說一點，閉包並不是Python中特有的概念，所有把函數做為一等公民的語言均有閉包的概念。不過像Java這樣以class為一等公民的語言中也可以使用閉包，只是它得用類或接口來實現。

更多概念上的東西可以參考最後的參考鏈接。

2. 為什麼使用閉包

基於上面的介紹，不知道讀者有沒有感覺這個東西和類有點相似，相似點在於他們都提供了對數據的封裝。不同的是閉包本身就是個方法。和類一樣，我們在編程時經常會把通用的東西抽象成類，（當然，還有對現實世界——業務的建模），以復用通用的功能。閉包也是一樣，當我們需要函數粒度的抽象時，閉包就是一個很好的選擇。

在這點上閉包可以被理解為一個只讀的對象，你可以給他傳遞一個屬性，但它只能提供給你一個執行的接口。因此在程序中我們經常需要這樣的一個函數對象——閉包，來幫我們完成一個通用的功能，比如後面會提到的——裝飾器。

3. 使用閉包

第一種場景 ，在python中很重要也很常見的一個使用場景就是裝飾器，Python為裝飾器提供了一個很友好的“語法糖”——@，讓我們可以很方便的使用裝飾器，裝飾的原理不做過多闡述，簡言之你在一個函數func上加上@decorator_func, 就相當於decorator_func(func):

複製代碼代碼如下:

def decorator_func(func):

def wrapper(*args, **kwargs):

return func(*args, **kwargs)

return wrapper

@decorator_func

def func(name):

print ‘my name is’, name

# 等價於

decorator_func(func)

在裝飾器的這個例子中，閉包（wrapper）持有了外部的func這個參數，並且能夠接受外部傳過來的參數，接受過來的參數在原封不動的傳給func，並返回執行結果。

這是個簡單的例子，稍微複雜點可以有多個閉包，比如經常使用的那個LRUCache的裝飾器，裝飾器上可以接受參數@lru_cache(expire=500)這樣。實現起來就是兩個閉包的嵌套:

複製代碼代碼如下:

def lru_cache(expire=5):

# 默認5s超時

def func_wrapper(func):

def inner(*args, **kwargs):

# cache 處理 bala bala bala

return func(*args, **kwargs)

return inner

return func_wrapper

@lru_cache(expire=10*60)

def get(request, pk)

# 省略具體代碼

return response()

不太懂閉包的同學一定得能夠理解上述代碼，這是我們之前面試經常會問到的面試題。

第二個場景 ，就是基於閉包的一個特性——“惰性求值”。這個應用比較常見的是在數據庫訪問的時候，比如說：

複製代碼代碼如下:

# 偽代碼示意

class QuerySet(object):

def __init__(self, sql):

self.sql = sql

self.db = Mysql.connect().corsor() # 偽代碼

def __call__(self):

return db.execute(self.sql)

def query(sql):

return QuerySet(sql)

result = query(“select name from user_app”)

if time now:

print result # 這時才執行數據庫訪問

上面這個不太恰當的例子展示了通過閉包完成惰性求值的功能，但是上面query返回的結果並不是函數，而是具有函數功能的類。有興趣的可以去看看Django的queryset的實現，原理類似。

第三種場景 ， 需要對某個函數的參數提前賦值的情況，當然在Python中已經有了很好的解決訪問 functools.parial,但是用閉包也能實現。

複製代碼代碼如下:

def partial(**outer_kwargs):

def wrapper(func):

def inner(*args, **kwargs):

for k, v in outer_kwargs.items():

kwargs[k] = v

return func(*args, **kwargs)

return inner

return wrapper

@partial(age=15)

def say(name=None, age=None):

print name, age

say(name=”the5fire”)

# 當然用functools比這個簡單多了

# 只需要： functools.partial(say, age=15)(name=’the5fire’)

看起來這又是一個牽強的例子，不過也算是實踐了閉包的應用。