python閉包的作用
⑴ 閉包的實質是什麼
閉包就是能夠讀取其他函數內部變數的函數。例如在javascript中，只有函數內部的子函數才能讀取局部變數，所以閉包可以理解成「定義在一個函數內部的函數「。在本質上，閉包是將函數內部和函數外部連接起來的橋梁。
集合 S 是閉集當且僅當 Cl(S)=S（這里的cl即closure，閉包）。特別的，空集的閉包是空集，X 的閉包是 X。集合的交集的閉包總是集合的閉包的交集的子集（不一定是真子集）。有限多個集合的並集的閉包和這些集合的閉包的並集相等；零個集合的並集為空集，所以這個命題包含了前面的空集的閉包的特殊情況。無限多個集合的並集的閉包不一定等於這些集合的閉包的並集，但前者一定是後者的父集。
若 A 為包含 S 的 X 的子空間，則 S 在 A 中計算得到的閉包等於 A 和 S 在 X 中計算得到的閉包（Cl_A(S) = A ∩ Cl_X(S））的交集。特別的，S在 A 中是稠密的，當且僅當 A 是 Cl_X(S) 的子集。
⑵ python-嵌套函數中的局部變數
嵌套函數在執行時（而不是在定義時）從父范圍中查找變數。
編譯函數主體，然後驗證「自由」變數（未在函數本身中通過賦值定義），然後將其作為閉包單元綁定到函數，並且代碼使用索引引用每個單元格。pet_function因此具有一個自由變數（cage），然後將其通過一個閉合單元引用，索引為0的閉合本身指向局部變數cage在get_petters功能。
當你實際調用該函數時，該閉包將用於在你調用該函數時查看cage周圍作用域中的值。問題就在這里。在你調用函數時，該函數已經完成了對其結果的計算。將在在執行過程中的一些點局部變數分配各的，和字元串，但在功能的結束，包含了最後一個值。因此，當你調用每個動態返回的函數時，就會得到列印的值。get_petterscage'cow''dog''cat'cage'cat''cat'
解決方法是不依賴閉包。你可以改用部分函數，創建新的函數作用域或將變數綁定為關鍵字parameter的默認值。
部分函數示例，使用functools.partial()：
from functools import partialdef pet_function(cage=None):
print "Mary pets the " + cage.animal + "."yield (animal, partial(gotimes, partial(pet_function, cage=cage)))
創建一個新的范圍示例：
def scoped_cage(cage=None):
def pet_function():
print "Mary pets the " + cage.animal + "."
return pet_functionyield (animal, partial(gotimes, scoped_cage(cage)))
將變數綁定為關鍵字參數的默認值：
def pet_function(cage=cage):
print "Mary pets the " + cage.animal + "."yield (animal, partial(gotimes, pet_function))
無需scoped_cage在循環中定義函數，編譯僅進行一次，而不是在循環的每次迭代中進行。
⑶ 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')
看起來這又是一個牽強的例子，不過也算是實踐了閉包的應用。
⑷ 資料庫中的閉包的意思
閉包是可以包含自由（未綁定）變數的代碼塊；這些變數不是在這個代碼塊或者任何全局上下文中定義的，而是在定義代碼塊的環境中定義。「閉包」 一詞來源於以下兩者的結合：要執行的代碼塊（由於自由變數的存在，相關變數引用沒有釋放）和為自由變數提供綁定的計算環境（作用域）。在 Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby 和 Python 等語言中都能找到對閉包不同程度的支持。
閉包的價值在於可以作為函數對象 或者匿名函數，對於類型系統而言這就意味著不僅要表示數據還要表示代碼。支持閉包的多數語言都將函數作為第一級對象，就是說這些函數可以存儲到變數中、作為參數傳遞給其他函數，最重要的是能夠被函數動態地創建和返回。
⑸ 什麼是Python中的閉包
閉包
1.函數引用
運行結果：
圖解：
相關推薦：《Python視頻教程》
2.什麼是閉包
運行結果：
3.看一個閉包的實際例子：
運行結果：
這個例子中，函數line與變數a,b構成閉包。在創建閉包的時候，我們通過line_conf的參數a,b說明了這兩個變數的取值，這樣，我們就確定了函數的最終形式(y = x + 1和y = 4x + 5)。我們只需要變換參數a,b，就可以獲得不同的直線表達函數。由此，我們可以看到，閉包也具有提高代碼可復用性的作用。
如果沒有閉包，我們需要每次創建直線函數的時候同時說明a,b,x。這樣，我們就需要更多的參數傳遞，也減少了代碼的可移植性。
相關推薦：
Python中的迭代器是什麼
⑹ 求幫助，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