Python 里為什么函數(shù)可以返回一個(gè)函數(shù)內(nèi)部定義的函數(shù)

“在Python中，函數(shù)本身也是對象”

10余年的肅寧網(wǎng)站建設(shè)經(jīng)驗(yàn)，針對設(shè)計(jì)、前端、開發(fā)、售后、文案、推廣等六對一服務(wù)，響應(yīng)快，48小時(shí)及時(shí)工作處理。全網(wǎng)營銷推廣的優(yōu)勢是能夠根據(jù)用戶設(shè)備顯示端的尺寸不同，自動調(diào)整肅寧建站的顯示方式，使網(wǎng)站能夠適用不同顯示終端，在瀏覽器中調(diào)整網(wǎng)站的寬度，無論在任何一種瀏覽器上瀏覽網(wǎng)站，都能展現(xiàn)優(yōu)雅布局與設(shè)計(jì)，從而大程度地提升瀏覽體驗(yàn)。成都創(chuàng)新互聯(lián)公司從事“肅寧網(wǎng)站設(shè)計(jì)”,“肅寧網(wǎng)站推廣”以來，每個(gè)客戶項(xiàng)目都認(rèn)真落實(shí)執(zhí)行。

這一本質(zhì)。那不妨慢慢來，從最基本的概念開始，討論一下這個(gè)問題：

1. Python中一切皆對象

這恐怕是學(xué)習(xí)Python最有用的一句話。想必你已經(jīng)知道Python中的list, tuple, dict等內(nèi)置數(shù)據(jù)結(jié)構(gòu)，當(dāng)你執(zhí)行：

alist = [1, 2, 3]

時(shí)，你就創(chuàng)建了一個(gè)列表對象，并且用alist這個(gè)變量引用它：

當(dāng)然你也可以自己定義一個(gè)類:

class House(object):

def __init__(self, area, city):

self.area = area

self.city = city

def sell(self, price):

[...] #other code

return price

然后創(chuàng)建一個(gè)類的對象：

house = House(200, 'Shanghai')

OK，你立馬就在上海有了一套200平米的房子，它有一些屬性(area, city)，和一些方法(__init__, self)：

2. 函數(shù)是第一類對象

和list, tuple, dict以及用House創(chuàng)建的對象一樣，當(dāng)你定義一個(gè)函數(shù)時(shí)，函數(shù)也是對象：

def func(a, b):

return a+b

在全局域，函數(shù)對象被函數(shù)名引用著，它接收兩個(gè)參數(shù)a和b，計(jì)算這兩個(gè)參數(shù)的和作為返回值。

所謂第一類對象，意思是可以用標(biāo)識符給對象命名，并且對象可以被當(dāng)作數(shù)據(jù)處理，例如賦值、作為參數(shù)傳遞給函數(shù)，或者作為返回值return 等

因此，你完全可以用其他變量名引用這個(gè)函數(shù)對象：

add = func

這樣，你就可以像調(diào)用func(1, 2)一樣，通過新的引用調(diào)用函數(shù)了：

print func(1, 2)

print add(1, 2) #the same as func(1, 2)

或者將函數(shù)對象作為參數(shù)，傳遞給另一個(gè)函數(shù)：

def caller_func(f):

return f(1, 2)

if __name__ == "__main__":

print caller_func(func)

可以看到，

函數(shù)對象func作為參數(shù)傳遞給caller_func函數(shù)，傳參過程類似于一個(gè)賦值操作f=func；

于是func函數(shù)對象，被caller_func函數(shù)作用域中的局部變量f引用，f實(shí)際指向了函數(shù)func；cc

當(dāng)執(zhí)行return f(1, 2)的時(shí)候，相當(dāng)于執(zhí)行了return func(1, 2)；

因此輸出結(jié)果為3。

3. 函數(shù)對象 vs 函數(shù)調(diào)用

無論是把函數(shù)賦值給新的標(biāo)識符，還是作為參數(shù)傳遞給新的函數(shù)，針對的都是函數(shù)對象本身，而不是函數(shù)的調(diào)用。

用一個(gè)更加簡單，但從外觀上看，更容易產(chǎn)生混淆的例子來說明這個(gè)問題。例如定義了下面這個(gè)函數(shù)：

def func():

return "hello,world"

然后分別執(zhí)行兩次賦值：

ref1 = func #將函數(shù)對象賦值給ref1

ref2 = func() #調(diào)用函數(shù)，將函數(shù)的返回值("hello,world"字符串)賦值給ref2

很多初學(xué)者會混淆這兩種賦值，通過Python內(nèi)建的type函數(shù)，可以查看一下這兩次賦值的結(jié)果：

In [4]: type(ref1)

Out[4]: function

In [5]: type(ref2)

Out[5]: str

可以看到，ref1引用了函數(shù)對象本身，而ref2則引用了函數(shù)的返回值。通過內(nèi)建的callable函數(shù)，可以進(jìn)一步驗(yàn)證ref1是可調(diào)用的，而ref2是不可調(diào)用的：

In [9]: callable(ref1)

Out[9]: True

In [10]: callable(ref2)

Out[10]: False

傳參的效果與之類似。

4. 閉包LEGB法則

所謂閉包，就是將組成函數(shù)的語句和這些語句的執(zhí)行環(huán)境打包在一起時(shí)，得到的對象

聽上去的確有些復(fù)雜，還是用一個(gè)栗子來幫助理解一下。假設(shè)我們在foo.py模塊中做了如下定義：

#foo.py

filename = "foo.py"

def call_func(f):

return f() #如前面介紹的，f引用一個(gè)函數(shù)對象，然后調(diào)用它

在另一個(gè)func.py模塊中，寫下了這樣的代碼：

#func.py

import foo #導(dǎo)入foo.py

filename = "func.py"

def show_filename():

return "filename: %s" % filename

if __name__ == "__main__":

print foo.call_func(show_filename) #注意：實(shí)際發(fā)生調(diào)用的位置，是在foo.call_func函數(shù)中

當(dāng)我們用python func.py命令執(zhí)行func.py時(shí)輸出結(jié)果為：

chiyu@chiyu-PC:~$ python func.py

filename:func.py

很顯然show_filename()函數(shù)使用的filename變量的值，是在與它相同環(huán)境(func.py模塊)中定義的那個(gè)。盡管foo.py模塊中也定義了同名的filename變量，而且實(shí)際調(diào)用show_filename的位置也是在foo.py的call_func內(nèi)部。

而對于嵌套函數(shù)，這一機(jī)制則會表現(xiàn)的更加明顯：閉包將會捕捉內(nèi)層函數(shù)執(zhí)行所需的整個(gè)環(huán)境：

#enclosed.py

import foo

def wrapper():

filename = "enclosed.py"

def show_filename():

return "filename: %s" % filename

print foo.call_func(show_filename) #輸出：filename: enclosed.py

實(shí)際上，每一個(gè)函數(shù)對象，都有一個(gè)指向了該函數(shù)定義時(shí)所在全局名稱空間的__globals__屬性：

#show_filename inside wrapper

#show_filename.__globals__

{

'__builtins__': module '__builtin__' (built-in), #內(nèi)建作用域環(huán)境

'__file__': 'enclosed.py',

'wrapper': function wrapper at 0x7f84768b6578, #直接外圍環(huán)境

'__package__': None,

'__name__': '__main__',

'foo': module 'foo' from '/home/chiyu/foo.pyc', #全局環(huán)境

'__doc__': None

}

當(dāng)代碼執(zhí)行到show_filename中的return "filename: %s" % filename語句時(shí)，解析器按照下面的順序查找filename變量：

Local - 本地函數(shù)(show_filename)內(nèi)部，通過任何方式賦值的，而且沒有被global關(guān)鍵字聲明為全局變量的filename變量；

Enclosing - 直接外圍空間(上層函數(shù)wrapper)的本地作用域，查找filename變量(如果有多層嵌套，則由內(nèi)而外逐層查找，直至最外層的函數(shù))；

Global - 全局空間(模塊enclosed.py)，在模塊頂層賦值的filename變量；

Builtin - 內(nèi)置模塊(__builtin__)中預(yù)定義的變量名中查找filename變量；

在任何一層先找到了符合要求的filename變量，則不再向更外層查找。如果直到Builtin層仍然沒有找到符合要求的變量，則拋出NameError異常。這就是變量名解析的：LEGB法則。

總結(jié)：

閉包最重要的使用價(jià)值在于：封存函數(shù)執(zhí)行的上下文環(huán)境；

閉包在其捕捉的執(zhí)行環(huán)境(def語句塊所在上下文)中，也遵循LEGB規(guī)則逐層查找，直至找到符合要求的變量，或者拋出異常。

5. 裝飾器語法糖(syntax sugar)

那么閉包和裝飾器又有什么關(guān)系呢？

上文提到閉包的重要特性：封存上下文，這一特性可以巧妙的被用于現(xiàn)有函數(shù)的包裝，從而為現(xiàn)有函數(shù)更加功能。而這就是裝飾器。

還是舉個(gè)例子，代碼如下：

#alist = [1, 2, 3, ..., 100] -- 1+2+3+...+100 = 5050

def lazy_sum():

return reduce(lambda x, y: x+y, alist)

我們定義了一個(gè)函數(shù)lazy_sum，作用是對alist中的所有元素求和后返回。alist假設(shè)為1到100的整數(shù)列表：

alist = range(1, 101)

但是出于某種原因，我并不想馬上返回計(jì)算結(jié)果，而是在之后的某個(gè)地方，通過顯示的調(diào)用輸出結(jié)果。于是我用一個(gè)wrapper函數(shù)對其進(jìn)行包裝：

def wrapper():

alist = range(1, 101)

def lazy_sum():

return reduce(lambda x, y: x+y, alist)

return lazy_sum

lazy_sum = wrapper() #wrapper() 返回的是lazy_sum函數(shù)對象

if __name__ == "__main__":

lazy_sum() #5050

這是一個(gè)典型的Lazy Evaluation的例子。我們知道，一般情況下，局部變量在函數(shù)返回時(shí)，就會被垃圾回收器回收，而不能再被使用。但是這里的alist卻沒有，它隨著lazy_sum函數(shù)對象的返回被一并返回了(這個(gè)說法不準(zhǔn)確，實(shí)際是包含在了lazy_sum的執(zhí)行環(huán)境中，通過__globals__)，從而延長了生命周期。

當(dāng)在if語句塊中調(diào)用lazy_sum()的時(shí)候，解析器會從上下文中(這里是Enclosing層的wrapper函數(shù)的局部作用域中)找到alist列表，計(jì)算結(jié)果，返回5050。

當(dāng)你需要動態(tài)的給已定義的函數(shù)增加功能時(shí)，比如：參數(shù)檢查，類似的原理就變得很有用：

def add(a, b):

return a+b

這是很簡單的一個(gè)函數(shù)：計(jì)算a+b的和返回，但我們知道Python是 動態(tài)類型+強(qiáng)類型 的語言，你并不能保證用戶傳入的參數(shù)a和b一定是兩個(gè)整型，他有可能傳入了一個(gè)整型和一個(gè)字符串類型的值：

In [2]: add(1, 2)

Out[2]: 3

In [3]: add(1.2, 3.45)

Out[3]: 4.65

In [4]: add(5, 'hello')

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

/home/chiyu/ipython-input-4-f2f9e8aa5eae in module()

---- 1 add(5, 'hello')

/home/chiyu/ipython-input-1-02b3d3d6caec in add(a, b)

1 def add(a, b):

---- 2 return a+b

TypeError: unsupported operand type(s) for +: 'int' and 'str'

于是，解析器無情的拋出了一個(gè)TypeError異常。

動態(tài)類型：在運(yùn)行期間確定變量的類型，python確定一個(gè)變量的類型是在你第一次給他賦值的時(shí)候；

強(qiáng)類型：有強(qiáng)制的類型定義，你有一個(gè)整數(shù)，除非顯示的類型轉(zhuǎn)換，否則絕不能將它當(dāng)作一個(gè)字符串(例如直接嘗試將一個(gè)整型和一個(gè)字符串做+運(yùn)算)；

因此，為了更加優(yōu)雅的使用add函數(shù)，我們需要在執(zhí)行+運(yùn)算前，對a和b進(jìn)行參數(shù)檢查。這時(shí)候裝飾器就顯得非常有用：

import logging

logging.basicConfig(level = logging.INFO)

def add(a, b):

return a + b

def checkParams(fn):

def wrapper(a, b):

if isinstance(a, (int, float)) and isinstance(b, (int, float)): #檢查參數(shù)a和b是否都為整型或浮點(diǎn)型

return fn(a, b) #是則調(diào)用fn(a, b)返回計(jì)算結(jié)果

#否則通過logging記錄錯(cuò)誤信息，并友好退出

logging.warning("variable 'a' and 'b' cannot be added")

return

return wrapper #fn引用add，被封存在閉包的執(zhí)行環(huán)境中返回

if __name__ == "__main__":

#將add函數(shù)對象傳入，fn指向add

#等號左側(cè)的add，指向checkParams的返回值wrapper

add = checkParams(add)

add(3, 'hello') #經(jīng)過類型檢查，不會計(jì)算結(jié)果，而是記錄日志并退出

注意checkParams函數(shù)：

首先看參數(shù)fn，當(dāng)我們調(diào)用checkParams(add)的時(shí)候，它將成為函數(shù)對象add的一個(gè)本地(Local)引用；

在checkParams內(nèi)部，我們定義了一個(gè)wrapper函數(shù)，添加了參數(shù)類型檢查的功能，然后調(diào)用了fn(a, b)，根據(jù)LEGB法則，解釋器將搜索幾個(gè)作用域，并最終在(Enclosing層)checkParams函數(shù)的本地作用域中找到fn；

注意最后的return wrapper，這將創(chuàng)建一個(gè)閉包，fn變量(add函數(shù)對象的一個(gè)引用)將會封存在閉包的執(zhí)行環(huán)境中，不會隨著checkParams的返回而被回收；

當(dāng)調(diào)用add = checkParams(add)時(shí)，add指向了新的wrapper對象，它添加了參數(shù)檢查和記錄日志的功能，同時(shí)又能夠通過封存的fn，繼續(xù)調(diào)用原始的add進(jìn)行+運(yùn)算。

因此調(diào)用add(3, 'hello')將不會返回計(jì)算結(jié)果，而是打印出日志：

chiyu@chiyu-PC:~$ python func.py

WARNING:root:variable 'a' and 'b' cannot be added

有人覺得add = checkParams(add)這樣的寫法未免太過麻煩，于是python提供了一種更優(yōu)雅的寫法，被稱為語法糖：

@checkParams

def add(a, b):

return a + b

這只是一種寫法上的優(yōu)化，解釋器仍然會將它轉(zhuǎn)化為add = checkParams(add)來執(zhí)行。

6. 回歸問題

def addspam(fn):

def new(*args):

print "spam,spam,spam"

return fn(*args)

return new

@addspam

def useful(a,b):

print a**2+b**2

首先看第二段代碼：

@addspam裝飾器，相當(dāng)于執(zhí)行了useful = addspam(useful)。在這里題主有一個(gè)理解誤區(qū)：傳遞給addspam的參數(shù)，是useful這個(gè)函數(shù)對象本身，而不是它的一個(gè)調(diào)用結(jié)果；

再回到addspam函數(shù)體：

return new 返回一個(gè)閉包，fn被封存在閉包的執(zhí)行環(huán)境中，不會隨著addspam函數(shù)的返回被回收；

而fn此時(shí)是useful的一個(gè)引用，當(dāng)執(zhí)行return fn(*args)時(shí)，實(shí)際相當(dāng)于執(zhí)行了return useful(*args)；

最后附上一張代碼執(zhí)行過程中的引用關(guān)系圖，希望能幫助你理解：

Kotlin 委托函數(shù)之lazy

Kotlin 標(biāo)準(zhǔn)庫為幾種有用的委托提供了工廠方法。

lazy() 是接受一個(gè) lambda 并返回一個(gè) Lazy T 實(shí)例的函數(shù)，返回的實(shí)例可以作為實(shí)現(xiàn)延遲屬性的委托.

從示例中可以看出,

修飾延遲屬性只能使用 val ,說明延遲屬性只能修飾不變的變量,它沒有對應(yīng)的set函數(shù),只有g(shù)et函數(shù).

點(diǎn)開 lazy 方法,跳轉(zhuǎn)到 LazyJVM.kt 文件.

lazy 最后調(diào)用的是 SynchronizedLazyImpl 類中的相關(guān)方法.

當(dāng)訪問字段變量的時(shí)候,最終調(diào)用就是對應(yīng)的 get 方法.

當(dāng) _value 有值時(shí),則直接返回, 當(dāng) _value 沒有值時(shí),通過調(diào)用傳入的 lambda 函數(shù),得到 lambda 函數(shù)的返回值作為 _value 的值返回.

由此,實(shí)現(xiàn)懶加載的功能.

lazy 函數(shù)主要有3中模式

延遲屬性的值,只允許一個(gè)線程中修改,其他線程只能使用該線程修改的值.

允許多個(gè)線程在同一時(shí)刻進(jìn)入初始化階段,但是只有一個(gè)線程可以修改成功.

線程不安全.

Python中的lazy property

我們都知道，在Python的類中， dict 保存了一個(gè)對象所有的屬性，如下面的例子，我們建立了一個(gè)Circle的對象，對象的字典中保存著半徑這個(gè)k-v值:

對于類中的方法，我們有時(shí)候希望它可以像屬性一樣被調(diào)用，這時(shí)候我們通常給類的方法添加@property修飾符:

但是這么做，雖然area可以當(dāng)作一個(gè)屬性訪問，但是并不是真正的變成了一個(gè)屬性，同時(shí)，我們每次調(diào)用circle.area，都會從頭到尾執(zhí)行一遍函數(shù)，我們來看下面的例子：

輸出為：

可以發(fā)現(xiàn)，每次執(zhí)行circle.area，整個(gè)函數(shù)流程都會被執(zhí)行一次的，同時(shí)area也沒有真正變成對象的屬性， dict 中并沒有area。

那么我們有沒有辦法把一個(gè)類中的函數(shù)真正變成對象的屬性，同時(shí)只有在第一次調(diào)用時(shí)進(jìn)行一次計(jì)算，而之后每次調(diào)用不會重復(fù)計(jì)算呢？這就是Python中的lazy property。本文介紹兩種方法。一種是使用python描述符，另一種是使用python修飾符。

輸出為：

可以看到，area只在第一次調(diào)用時(shí)計(jì)算了一次，同時(shí)在調(diào)用以后area變成了對象的一個(gè)屬性，同時(shí)值并不隨半徑的變化而變化。

輸出為：

可以看到，area只在第一次調(diào)用時(shí)計(jì)算了一次，同時(shí)在調(diào)用以后area變成了對象的一個(gè)屬性，同時(shí)值并不隨半徑的變化而變化。

函數(shù)的括號

1、不帶括號時(shí)，調(diào)用的是這個(gè)函數(shù)本身

2、帶括號（此時(shí)必須傳入需要的參數(shù)），調(diào)用的是函數(shù)的return結(jié)果

函數(shù) lazy_sum

函數(shù)調(diào)用 lazy_sum()

函數(shù)調(diào)用的結(jié)果? f = lazy_sum()

結(jié)果是一個(gè)函數(shù)? f

繼續(xù)調(diào)用函數(shù)? ?f()

括號：

小括號( ) ：代表tuple元組數(shù)據(jù)類型，元組是一種不可變序列。創(chuàng)建方法很簡單，大多時(shí)候都是用小括號括起來的。

tup=(1,2,3)

tup

(1,2,3)

()#空元組

()

55,#一個(gè)值的元組

(55,)

Python 元組遍歷排序操作方法 有對元組操作的更詳細(xì)講解。

python中的中括號[ ] ：代表list列表數(shù)據(jù)類型，列表是一種可變的序列。其創(chuàng)建方法即簡單又特別，像下面一樣：

list('python')

['p','y','t','h','o','n']

如果想創(chuàng)建一個(gè)空的列表，或是一個(gè)值的列表其方法同元組創(chuàng)建，只要使用不同括號即可。 Pyhton列表list操作 講解更適合新手深入認(rèn)識什么是列表。

python大括號{ }花括號： 代表dict字典數(shù)據(jù)類型，字典是由鍵對值組組成。冒號':'分開鍵和值，逗號','隔開組。用大括號創(chuàng)建的方法如下：

dic={'jon':'boy','lili':'girl'}

dic

{'lili':'girl','jon':'boy'}

新聞標(biāo)題：lazy函數(shù)python lazy y
本文網(wǎng)址：http://m.rwnh.cn/article10/hiigdo.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供定制網(wǎng)站、動態(tài)網(wǎng)站、外貿(mào)網(wǎng)站建設(shè)、域名注冊、定制開發(fā)、網(wǎng)站制作

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時(shí)間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時(shí)需注明來源： 創(chuàng)新互聯(lián)