python的閉包

❶ 閉包/工廠函數

閉包：python函數的內部的變數離開這個函數就失去了作用域而不復存在
但是嵌套函數可以！

解析： x是屬於fn1函數的，但是在 fn1()調用結束後 我們又加了兩個括弧調用到了fn3，你看他還是能輸出x的值
但嵌套函數只是引用它！不能修改它，要在嵌套函數里修改x的值需要申明nonlocal x

工廠函數：
函數return的時候返回一個函數名

參考： https://www.hu.com/question/20670869 石溪的答案

❷ python閉包問題

defcount():
fs=[]
foriinrange(1,4):
deff(j):
defg():
returnj*j
returng
fs.append(f(i))
#fs=[f(1),f(2),f(3)]=[]
returnfs


f1,f2,f3=count()
#f1,f2,f3=[f(1),f(2),f(3)]
printf1()
printf2()
printf3()

defhellocounter(name):
count=[0]
defcounter():
count[0]+=1
print'Hello,',name,',',str(count[0])+'access!'
returncounter

hello=hellocounter('ma6174')
hello()
hello()
hello()

具體的注釋在代碼里，第一不是閉包的使用方式，第二個是一個合理的閉包使用例子。

如果解決了您的問題請採納！
如果未解決請繼續追問

❸ 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')

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

❹ 一個關於python閉包的問題，內部函數可以獲取外部函數的變數嗎

你可以獲得外部變數，但是不能修改它。我強烈建議，你使用global 將其定義為全局變數，

否則，你自己都搞不清變數的值到底是什麼。個人覺得這是Python設計的很不好的地方，這會導致閉包使用起來很奇怪，而且global也會導致程序的封裝性受到破壞

❺ Python中什麼是閉包

閉包就是能夠讀取其他函數內部變數的函數。例如在javascript中，只有函數內部的子函數才能讀取局部變數，所以閉包可以理解成「定義在一個函數內部的函數「。在本質上，閉包是將函數內部和函數外部連接起來的橋梁。
閉包包含自由（未綁定到特定對象）變數，這些變數不是在這個代碼塊內或者任何全局上下文中定義的，而是在定義代碼塊的環境中定義（局部變數）。「閉包」 一詞來源於以下兩者的結合：要執行的代碼塊（由於自由變數被包含在代碼塊中，這些自由變數以及它們引用的對象沒有被釋放）和為自由變數提供綁定的計算環境（作用域）。在PHP、Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Go、Lua、objective c、swift 以及Java（Java8及以上）等語言中都能找到對閉包不同程度的支持。

❻ python 裝飾器是閉包嗎

如果在一個內嵌函數里，對在外部函數內（但不是在全局作用域）的變數進行引用，那麼內嵌函數就被認為是閉包。
Python中裝飾器重新創建的函數對象引用了外部函數的變數，因此屬於閉包。

❼ 閉包的理解

集合 S 是閉集當且僅當 Cl(S)=S(這里的cl即closure，閉包)。特別的，空集的閉包是空集，X 的閉包是 X。集合的交集的閉包總是集合的閉包的交集的子集(不一定是真子集)。

閉包

在PHP、Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Go、Lua、objective c、swift 以及Java(Java8及以上)等語言中都能找到對閉包不同程度的支持。

❽ 求幫助，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閉包問題求解

因為python具有late binding的機制——閉包中內部函數的值只有在被調用時才會確定，等到f1,f2,f3調用時，此時閉包中f()函數的i已經等於3了，於是所有結果等於9.

如果想得到你要的結果，就得提前把i作為參數傳入，把原先的def f():所在行修改為def f(i=i)即可，其中等號左邊的i是形參，等號右邊的i是for in 循環中對應的i

defcount():
	fs=[]
	foriinrange(1,4):
		deff(i=i):
			returni**2
		fs.append(f)
	returnfs

f1,f2,f3=count()

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

輸出

1
4
9

❿ 這個python題目怎麼寫

無意間，看到這么一道Python面試題：以下代碼將輸出什麼？

def testFun:
temp = [lambda x : i*x for i in range(4)]
return temp
for everyLambda in testFun:
print (everyLambda(2))

腦中默默一想，這還用說么，肯定是：

0
2
4
6

最後一看答案，竟然是：

6
6
6
6

於是帶著懷疑的心態（其實是不服輸，不認錯），打開編輯器，快速一敲，果然是：
懷疑了人生半天，本來還想黑，WTF Python…然後才想通是自己太生疏......
最後發現原因竟是：Python 的閉包的後期綁定導致的 late binding。
這意味著在閉包中的變數是在內部函數被調用的時候被查找，所以當任何testFun 返回的函數被調用，i 的值是在它被調用時的周圍作用域中查找。
也就是說無論哪個返回的函數被調用，for 循環都已經完成了，i 最後的值是 3，因此，每個返回的函數 testFun 的值都是 3。
因此一個等於 2 的值被傳遞進以上代碼，它們將返回一個值 6 （比如：3 x 2）。
究竟如何才能實現出這樣的結果呢？

0
2
4
6

想了想，若能立即綁定參數，或者直接不用閉包總該行吧，用另一種方式避免 i 的改寫。
回憶了之前所學知識，最後醞釀出了四種解決方案。
第一種：創建一個閉包，通過使用默認參數立即綁定它的參數

def testFun:
temp = [lambda x, i=i: i * x for i in range(4)]
return temp
for everyLambda in testFun:
print(everyLambda(2))

第二種：使用functools.partial 函數，把函數的某些參數（不管有沒有默認值）給固定住（也就是相當於設置默認值）

from functools import partial
from operator import mul
def testFun:
return [partial(mul, i) for i in range(4)]
for everyLambda in testFun:
print(everyLambda(2))

第三種：優雅的寫法，直接用生成器

def testFun:
return (lambda x, i=i: i * x for i in range(4))
for everyLambda in testFun:
print(everyLambda(2))

第四種：利用yield的惰性求值的思想

def testFun:
for i in range(4):
yield lambda x: i * x
for everyLambda in testFun:
print(everyLambda(2))

最終運行結果：
有了解決方案後，又陷入了懷疑自己，這個題目究竟是考察的是什麼？是在考面試者閉包相關知識以及Python 的閉包的後期綁定問題么？
若將題目改成：以下代碼輸出的結果是（0,2,4,6）么？如果不是，你將會怎麼做，讓它變成（0,2,4,6）？這樣會不會更有意思點呢？歡迎大家出妙招，看究竟有多少招？（哈哈哈！！！）