在Python語言中，可以在函數(shù)中定義函數(shù)。 這種在函數(shù)中嵌套定義的函數(shù)也叫內(nèi)部函數(shù)。我們來看下面的代碼：
我們擁有十載網(wǎng)頁設(shè)計和網(wǎng)站建設(shè)經(jīng)驗，從網(wǎng)站策劃到網(wǎng)站制作，我們的網(wǎng)頁設(shè)計師為您提供的解決方案。為企業(yè)提供網(wǎng)站設(shè)計、網(wǎng)站制作、微信開發(fā)、小程序制作、手機網(wǎng)站制作、H5開發(fā)、等業(yè)務(wù)。無論您有什么樣的網(wǎng)站設(shè)計或者設(shè)計方案要求，我們都將富于創(chuàng)造性的提供專業(yè)設(shè)計服務(wù)并滿足您的需求。
上述代碼中，定義了函數(shù)greet，在函數(shù)greet內(nèi)部又定義了一個函數(shù)inner_func, 并調(diào)用該函數(shù)打印了一串字符。
我們可以看到，內(nèi)部函數(shù)inner_func的定義和使用與普通函數(shù)基本相同。需要注意的是變量的作用域，在上述代碼中，函數(shù)參數(shù)name對于全局函數(shù)greet是局部變量，對內(nèi)部函數(shù)inner_func來說則是非局部變量。內(nèi)部函數(shù)對于非局部變量的訪問規(guī)則類似于標(biāo)準(zhǔn)的外部函數(shù)訪問全局變量。
從這個例子我們還可以看到內(nèi)部函數(shù)的一個作用，就是通過定義內(nèi)部函數(shù)的方式將一些功能隱藏起來，防止外部直接調(diào)用。常見的場景是，在一個復(fù)雜邏輯的函數(shù)中，將一些小的任務(wù)定義成內(nèi)部函數(shù)，然后由這個外層函數(shù)使用，這樣可以使代碼更為清晰，易于維護。這些內(nèi)部函數(shù)只會在這個外層函數(shù)中使用，不能被其他函數(shù)或模塊使用。
在Python語言中, 函數(shù)也是對象，它可以被創(chuàng)建、賦值給變量，或者作為函數(shù)的返回值。我們來看下面這個例子。
在上述代碼中，在函數(shù)gen_greet內(nèi)部定義了inner_func函數(shù)，并返回了一個inner_func函數(shù)對象。外部函數(shù)gen_greet返回了一個函數(shù)對象，所以像gen_greet這樣的函數(shù)也叫工廠函數(shù)。
在內(nèi)部函數(shù)inner_func中，使用了外部函數(shù)的傳參greet_words（非局部變量），以及函數(shù)的參數(shù)name（局部變量），來打印一個字符串。
接下來，調(diào)用gen_greet("Hello")創(chuàng)建一個函數(shù)對象say_hello，緊接著調(diào)用say_hello("Mr. Zhang")，輸出的結(jié)果為：Hello, Mr. Zhang！
同樣的，調(diào)用gen_greet("Hi")創(chuàng)建一個函數(shù)對象say_hi，調(diào)用say_hello("Mr. Zhang")，輸出的結(jié)果為：Hi，Tony！
我們可以發(fā)現(xiàn)，gen_greet返回的函數(shù)對象具有記憶功能，它能夠把所需使用的非局部變量保存下來，用于后續(xù)被調(diào)用的時候使用。這種保存了非局部變量的函數(shù)對象被稱作閉包（closure）。
那么閉包是如何實現(xiàn)的呢？其實并不復(fù)雜，函數(shù)對象中有一個屬性__closure__，它就是在創(chuàng)建函數(shù)對象時用來保存這些非局部變量的。
__closure__屬性是一個元組或者None類型。在上述代碼中，我們可以通過下面方式查看：
函數(shù)的嵌套所實現(xiàn)的功能大都可以通過定義類的方式來實現(xiàn)，而且類是更加面向?qū)ο蟮拇a編寫方式。
嵌套函數(shù)的一個主要用途是實現(xiàn)函數(shù)的裝飾器。我們看下面的代碼：
在上述代碼中，logger函數(shù)返回函數(shù)with_logging，with_logging則是打印了函數(shù)func的名稱及傳入的參數(shù)，然后調(diào)用func, 并將參數(shù)傳遞給func。其中的@wraps(func)語句用于復(fù)制函數(shù)func的名稱、注釋文檔、參數(shù)列表等等，使得with_logging函數(shù)具有被裝飾的函數(shù)func相同的屬性。
代碼中接下來用@logger對函數(shù)power_func進行修飾，它的作用等同于下面的代碼:
可見，裝飾器@符其實就是上述代碼的精簡寫法。
通過了解了嵌套函數(shù)和閉包的工作原理，我們在使用過程中就能夠更加得心應(yīng)手了。
1. 閉包的概念
首先還得從基本概念說起，什么是閉包呢？來看下維基上的解釋:
復(fù)制代碼代碼如下:
在計算機科學(xué)中，閉包（Closure）是詞法閉包（Lexical Closure）的簡稱，是引用了自由變量的函數(shù)。這個被引用的自由變量將和這個函數(shù)一同存在，即使已經(jīng)離開了創(chuàng)造它的環(huán)境也不例外。所以，有另一種說法認(rèn)為閉包是由函數(shù)和與其相關(guān)的引用環(huán)境組合而成的實體。閉包在運行時可以有多個實例，不同的引用環(huán)境和相同的函數(shù)組合可以產(chǎn)生不同的實例。
....
上面提到了兩個關(guān)鍵的地方： 自由變量 和 函數(shù), 這兩個關(guān)鍵稍后再說。還是得在贅述下“閉包”的意思，望文知意，可以形象的把它理解為一個封閉的包裹，這個包裹就是一個函數(shù)，當(dāng)然還有函數(shù)內(nèi)部對應(yīng)的邏輯，包裹里面的東西就是自由變量，自由變量可以在隨著包裹到處游蕩。當(dāng)然還得有個前提，這個包裹是被創(chuàng)建出來的。
在通過Python的語言介紹一下，一個閉包就是你調(diào)用了一個函數(shù)A，這個函數(shù)A返回了一個函數(shù)B給你。這個返回的函數(shù)B就叫做閉包。你在調(diào)用函數(shù)A的時候傳遞的參數(shù)就是自由變量。
舉個例子：
復(fù)制代碼代碼如下:
def func(name):
def inner_func(age):
print 'name:', name, 'age:', age
return inner_func
bb = func('the5fire')
bb(26) # name: the5fire age: 26
這里面調(diào)用func的時候就產(chǎn)生了一個閉包——inner_func,并且該閉包持有自由變量——name，因此這也意味著，當(dāng)函數(shù)func的生命周期結(jié)束之后，name這個變量依然存在，因為它被閉包引用了，所以不會被回收。
另外再說一點，閉包并不是Python中特有的概念，所有把函數(shù)做為一等公民的語言均有閉包的概念。不過像Java這樣以class為一等公民的語言中也可以使用閉包，只是它得用類或接口來實現(xiàn)。
更多概念上的東西可以參考最后的參考鏈接。
2. 為什么使用閉包
基于上面的介紹，不知道讀者有沒有感覺這個東西和類有點相似，相似點在于他們都提供了對數(shù)據(jù)的封裝。不同的是閉包本身就是個方法。和類一樣，我們在編程時經(jīng)常會把通用的東西抽象成類，（當(dāng)然，還有對現(xiàn)實世界——業(yè)務(wù)的建模），以復(fù)用通用的功能。閉包也是一樣，當(dāng)我們需要函數(shù)粒度的抽象時，閉包就是一個很好的選擇。
在這點上閉包可以被理解為一個只讀的對象，你可以給他傳遞一個屬性，但它只能提供給你一個執(zhí)行的接口。因此在程序中我們經(jīng)常需要這樣的一個函數(shù)對象——閉包，來幫我們完成一個通用的功能，比如后面會提到的——裝飾器。
3. 使用閉包
第一種場景 ，在python中很重要也很常見的一個使用場景就是裝飾器，Python為裝飾器提供了一個很友好的“語法糖”——@，讓我們可以很方便的使用裝飾器，裝飾的原理不做過多闡述，簡言之你在一個函數(shù)func上加上@decorator_func, 就相當(dāng)于decorator_func(func):
復(fù)制代碼代碼如下:
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這個參數(shù)，并且能夠接受外部傳過來的參數(shù)，接受過來的參數(shù)在原封不動的傳給func，并返回執(zhí)行結(jié)果。
這是個簡單的例子，稍微復(fù)雜點可以有多個閉包，比如經(jīng)常使用的那個LRUCache的裝飾器，裝飾器上可以接受參數(shù)@lru_cache(expire=500)這樣。實現(xiàn)起來就是兩個閉包的嵌套:
復(fù)制代碼代碼如下:
def lru_cache(expire=5):
# 默認(rèn)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()
不太懂閉包的同學(xué)一定得能夠理解上述代碼，這是我們之前面試經(jīng)常會問到的面試題。
第二個場景 ，就是基于閉包的一個特性——“惰性求值”。這個應(yīng)用比較常見的是在數(shù)據(jù)庫訪問的時候，比如說：
復(fù)制代碼代碼如下:
# 偽代碼示意
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 # 這時才執(zhí)行數(shù)據(jù)庫訪問
上面這個不太恰當(dāng)?shù)睦诱故玖送ㄟ^閉包完成惰性求值的功能，但是上面query返回的結(jié)果并不是函數(shù)，而是具有函數(shù)功能的類。有興趣的可以去看看Django的queryset的實現(xiàn)，原理類似。
第三種場景 ， 需要對某個函數(shù)的參數(shù)提前賦值的情況，當(dāng)然在Python中已經(jīng)有了很好的解決訪問 functools.parial,但是用閉包也能實現(xiàn)。
復(fù)制代碼代碼如下:
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")
# 當(dāng)然用functools比這個簡單多了
# 只需要： functools.partial(say, age=15)(name='the5fire')
看起來這又是一個牽強的例子，不過也算是實踐了閉包的應(yīng)用。
Python中的閉包不是一個簡單一說就能明白的概念，這個是需要在深入學(xué)習(xí)當(dāng)中理解的。在一些語言中，函數(shù)中可以嵌套定義另外一個，如果內(nèi)部函數(shù)引用了外部函數(shù)的變量，就會產(chǎn)生閉包。閉包是可以用在一個函數(shù)與一組私有的變量之間創(chuàng)建關(guān)聯(lián)關(guān)系。在給定函數(shù)中被多次調(diào)用的，這些私有變量能夠保持持久性；
例子：
def make_printer(msg):
def printer():
print msg # 夾帶私貨（外部變量）
return printer # 返回的是函數(shù)，帶私貨的函數(shù)
說人話就是當(dāng)某個函數(shù)被當(dāng)成對象返回的時候，夾帶了外部變量，就形成了一個閉包。還是不懂的話，去黑馬程序員論壇，有視頻也有文字教學(xué)。找不到對話框直接問就好了
結(jié)果：
結(jié)果：
1，匿名函數(shù)能夠完成基本的簡單功能，當(dāng)作為實參時，傳遞的是函數(shù)的引用，只有功能
2，普通函數(shù)能夠完成較為復(fù)雜的功能，當(dāng)作為實參時，傳遞的是函數(shù)的引用，只有功能
3，閉包能夠完成較為復(fù)雜的功能，當(dāng)作為實參時，傳遞的是這個閉包中的函數(shù)以及數(shù)據(jù)，所以是功能+數(shù)據(jù)
4，實例對象能夠完成較為復(fù)雜的功能，當(dāng)作為實參時，傳遞的是這個很多功能以及很多數(shù)據(jù)，所以是功能+數(shù)據(jù)
閉包?
1.函數(shù)引用
運行結(jié)果：
圖解：
相關(guān)推薦：《Python視頻教程》
2.什么是閉包
運行結(jié)果：
3.看一個閉包的實際例子：
運行結(jié)果：
這個例子中，函數(shù)line與變量a,b構(gòu)成閉包。在創(chuàng)建閉包的時候，我們通過line_conf的參數(shù)a,b說明了這兩個變量的取值，這樣，我們就確定了函數(shù)的最終形式(y = x + 1和y = 4x + 5)。我們只需要變換參數(shù)a,b，就可以獲得不同的直線表達(dá)函數(shù)。由此，我們可以看到，閉包也具有提高代碼可復(fù)用性的作用。
如果沒有閉包，我們需要每次創(chuàng)建直線函數(shù)的時候同時說明a,b,x。這樣，我們就需要更多的參數(shù)傳遞，也減少了代碼的可移植性。
相關(guān)推薦：
Python中的迭代器是什么
（1）unpack tuple和list, 可以讓函數(shù)返回多個值
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）假設(shè)你知道Python的dict類型。Python中，在函數(shù)中定義一個變量的時候，會在一個隱藏的叫l(wèi)ocals的dict里面插入key-value，其中key是變量名，value是變量值。而引用一個變量的時候，則首先會在這個叫l(wèi)ocals的dict里面，根據(jù)變量名作為key，去查對應(yīng)的值。
var = 1 # 你可以認(rèn)為這里進行了 locals['var'] = 1 的操作
print var # 在對var變量進行求值的時候，就在locals['var']里面找var變量對應(yīng)的值
（3）for循環(huán)中，每次循環(huán)只是給 `i` 重新綁定值
for i in (1, 2, 3):
print i
print i
# 一次輸入 1 2 3 3
每次`for i in (1, 2, 3)`相當(dāng)于在`print i`之前，進行了
`locals['i'] = 1`
`locals['i'] = 2`
`locals['i'] = 3`
的操作
所以最后的`print i`再去locals字典里面找`i`的時候，就變成 3 了。
（4）閉包是 一個函數(shù)加上這個函數(shù)引用的外部變量
var = 1
def f():
print var
# 這里的閉包是函數(shù) f 和 f 引用的外部變量 var
def count():
var2 = 2
def f():
print var2
# 這里的閉包是函數(shù) f 和 f 引用的外部變量 var2
return f
拿第一個函數(shù) f 來說。在 f 運行的時候，解釋器拿著'var'這個字符串去locals字典里面找，發(fā)現(xiàn)找不到，于是在closure字典里面找，最后closure字典里面找，你可以認(rèn)為就是找closure['var']，然后發(fā)現(xiàn)找到對應(yīng)的值。count里面的 f 函數(shù)同理。
（為了容易理解，我這里說謊了。實際上 f 壓根沒有closure，count里面的 f 才有。其實closure壓根不是像locals那樣的字典）
（5）函數(shù)定義時，函數(shù)只是記錄變量的名字。
要區(qū)分什么是名字，什么是值。
`i = 1`這里 i 只是名字，只是一個字符串 'i' 。這句話運行完，locals['i'] = 1，就說 i 對應(yīng)的值是1
def count():
fs = []
for i in range(1, 4):
# 定義一個函數(shù)，等價于運行了 locals['f'] = 真正生成的函數(shù)
# 每次循環(huán)，這里都會重新生成一個函數(shù)，然后把重新生成的函數(shù)賦值給 locals['f']
def f():
return i * i # 引用了'i'這個名字，但并不是引用了'i'對應(yīng)的值
# 等價于 locals['fs'].append(locals['f'])
# f 不是函數(shù)，它只是一個名字'f'。f 引用的東西，也就是locals['f']才是真正的函數(shù)
fs.append(f)
# 于是這個for循環(huán)生成了三個函數(shù)，這三個函數(shù)是沒有名字的，這個函數(shù)運行完后，它們跟'f'這個名字就毛關(guān)系都沒有了(是的我說慌了，但可以先不管)
# 把整個列表返回，這個列表包含了三個函數(shù)
return fs
# count()返回三個函數(shù)的列表，unpack 列表的語法把列表中的三個函數(shù)抽出來，重新給他們命名為 f1, f2, f3
# 也就是說，
# locals['f1'] = 列表中的第1個函數(shù)
# locals['f2'] = 列表中的第2個函數(shù)
# locals['f3'] = 列表中的第3個函數(shù)
# 這三個函數(shù)跟'f'這個名字現(xiàn)在毛關(guān)系都沒有。（其實是有的，但為了說明需要簡化，現(xiàn)在你可以完全不管括號里面說的話）
f1, f2, f3 = count()
print f1(), f2(), f3()
# 好了我們運行它們，輸入都是 9
# def f():
# return i * i
這是因為 f1 現(xiàn)在對應(yīng)的函數(shù)，里面引用了 'i' 這個字符串，我們根據(jù) 'i '這個字符串去找它對應(yīng)的值，先找到 f 當(dāng)前的locals字典，發(fā)現(xiàn)沒有，因為函數(shù)定義的時候沒有定義 i 變量。然后再去closure['i']里面找，因為Python是通過closure字典實現(xiàn)閉包的（就當(dāng)它是對的好不好），所以我們可以在closure['i']找到值，這個值就是我們上一次運行的時候count函數(shù)里面殘留的locals['i']，而由于for循環(huán)三遍之后，locals['i'] == 3，所以找到 i 的值就是3。所以最后輸出都是9
重慶分公司
重慶分公司
