Python——五分鐘了解函數式程式設計與閉包

Python——五分鐘了解函數式程式設計與閉包

函數式程式設計

函數式程式設計這個概念我們可能或多或少都聽說過，剛聽說的時候不明覺厲，覺得這是一個非常黑科技的概念。但是實際上它的含義很樸實，但是延伸出來許多豐富的用法。

在早期程式設計語言還不是很多的時候，我們會将語言分成進階語言與低級語言。比如彙編語言，就是低級語言，幾乎什麼封裝也沒有，做一個指派運算還需要我們手動調用寄存器。而進階語言則從這些面向機器的指令當中抽身出來，轉而面向過程或者是對象。也就是說我們寫代碼面向的是一段計算過程或者是一個計算機當中抽象出來的對象。如果你學過面向對象，你會發現和面向過程相比，面向對象的抽象程度更高了一些，做了更加完善的封裝。

在面向對象之後呢，我們還可以做什麼封裝和抽象呢？這就輪到了函數式程式設計。

函數我們都了解，就是我們定義的一段程式，它的輸入和輸出都是确定的。我們把一段函數寫好，它可以在任何地方進行調用。既然函數這麼好用，那麼能不能把函數也看成是一個變量進行傳回和傳參呢？

OK，這個就是函數式程式設計最直覺的特點。也就是說我們寫的一段函數也可以作為變量，既可以用來指派，還可以用來傳遞，并且還能進行傳回。這樣一來，大大友善了我們的編碼，但是這并不是有利無害的，相反它帶來許多問題，最直覺的問題就是由于函數傳入的參數還可以是另一個函數，這會導緻函數的計算過程變得不可确定，許多超出我們預期的事情都有可能發生。

是以函數式程式設計是有利有弊的，它的确簡化了許多問題，但也産生了許多新的問題，我們在使用的過程當中需要謹慎。

傳入、傳回函數

在我們之前介紹filter、map、reduce以及自定義排序的時候，其實我們已經用到了函數式程式設計的概念了。

比如在我們調用sorted進行排序的時候，如果我們傳入的是一個對象數組，我們希望根據我們制定的字段排序，這個時候我們往往需要傳入一個匿名函數，用來制定排序的字段。其實傳入的匿名函數，其實就是函數式程式設計最直覺的展現了：

sorted(kids, key=lambda x: x['score'])

除此之外，我們還可以傳回一個函數，比如我們來看一個例子：

def delay_sum(nums):

    def sum():

        s = 0

        for i in nums:

            s += i

        return s

    return sum

如果這個時候我們調用delay_sum傳入一串數字，我們會得到什麼？

答案是一個函數，我們可以直接輸出，從列印資訊裡看出這一點：

 delay_sum([1, 3, 4, 2])

.sum at 0x1018659e0>

我們想獲得這個運算結果應該怎麼辦呢？也很簡單，我們用一個變量去接收它，然後執行這個新的變量即可：

 f = delay_sum([1, 3, 4, 2])

 f()

10

這樣做有一個好處是我們可以延遲計算，如果不使用函數式程式設計，那麼我們需要在調用delay_sum這個函數的時候就計算出結果。如果這個運算量很小還好，如果這個運算量很大，就會造成開銷。并且當我們計算出結果來之後，這個結果也許不是立即使用的，可能到很晚才會用到。既然如此，我們傳回一個函數代替了運算，當後面真正需要用到的時候再執行結果，進而延遲了運算。這也是很多計算架構的常用思路，比如spark。

閉包

我們再來回顧一下我們剛才舉的例子，在剛才的delay_sum函數當中，我們内部實作了一個sum函數，我們在這個函數當中調用了delay_sum函數傳入的參數。這種對外部作用域的變量進行引用的内部函數就稱為閉包。

其實這個概念很形象，因為這個函數内部調用的資料對于調用方來說是封閉的，完全是一個黑盒，除非我們檢視源碼，否則我們是不知道它當中資料的來源的。除了不知道來源之外，更重要的是它引用的是外部函數的變量，既然是變量就說明是動态的。也就是說我們可以通過改變某些外部變量的值來改變閉包的運作效果。

這麼說有點拗口，我們來看一個簡單的例子。在Python當中有一個函數叫做math.pow其實就是計算次方的。比如我們要計算x的平方，那麼我們應該這樣寫：

math.pow(x, 2)

但是如果我們目前場景下隻需要計算平方，我們每次都要傳入額外再傳入一個2會顯得非常麻煩，這個時候我們使用閉包，可以簡化操作：

def mypow(num):

    def pw(x):

        return math.pow(x, num)

    return pw

pow2 = mypow(2)

print(pow2(10))

通過閉包，我們把第二個變量給固定了，這樣我們隻需要使用pow2就可以實作原來math.pow(x, 2)的功能了。如果我們突然需求變更需要計算3次方或者是4次方，我們隻需要修改mypow的傳入參數即可，完全不需要修改代碼。

實際上這也是閉包最大的使用場景，我們可以通過閉包實作一些非常靈活的功能，以及通過配置修改一些功能等操作，而不再需要通過代碼寫死。要知道對于工業領域來說，線上的代碼是不能随便變更的，尤其是用戶端，比如apple store或者是安卓商店當中的軟體包，隻有使用者手動更新才會拉取。如果出現問題了，幾乎沒有辦法修改，隻能等使用者手動更新。是以正常操作就是使用一些類似閉包的靈活功能，通過修改配置的方式改變代碼的邏輯。

除此之外閉包還有一個用處是可以暫存變量或者是運作時的環境。

舉個例子，我們來看下面這段代碼：

def step(x=0):

    x += 5

    return x

這是沒有使用閉包的函數，不管我們調用多少次，答案都是5，執行完x+=5之後的結果并不會被儲存起來，當函數傳回了，這個暫存的值也就被抛棄了。那如果我希望每次調用都是依據上次調用的結果，也就是說我們每次修改的操作都能儲存起來，而不是丢棄呢？

這個時候就需要使用閉包了：

def test(x=0):

    def step():

        nonlocal x

        x += 5

        return x

    return step

t = test()

t()

 5

 10

也就是說我們的x的值被存儲起來了，每次修改都會累計，而不是丢棄。這裡需要注意一點，我們用到了一個新的關鍵字叫做nonlocal，這是Python3當中獨有的關鍵字，用來申明目前的變量x不是局部變量，這樣Python解釋器就會去全局變量當中去尋找這個x，這樣就能關聯上test方法當中傳入的參數x。Python2官方已經不更新了，不推薦使用。

由于在Python當中也是一切都是對象，如果我們把閉包外層的函數看成是一個類的話，其實閉包和類差別就不大了，我們甚至可以給閉包傳回的函數關聯函數，這樣幾乎就是一個對象了。來看一個例子：

def student():

    name = 'xiaoming'

    def stu():

        return name

    def set_name(value):

        nonlocal name

        name = value

    stu.set_name = set_name

    return stu

stu = student()

stu.set_name('xiaohong')

print(stu())

最後運算的結果是xiaohong，因為我們調用set_name改變了閉包外部的值。這樣當然是可以的，但是一般情況下我們并不會用到它。和寫一個class相比，通過閉包的方法運算速度會更快。原因比較隐蔽，是因為閉包當中沒有self指針，進而節省了大量的變量的通路和運算，是以計算的速度要快上一些。但是閉包搞出來的僞對象是不能使用繼承、派生等方法的，而且和正常的用法格格不入，是以我們知道有這樣的方法就可以了，現實中并不會用到。

閉包的坑

閉包雖然好用，但是不小心的話也是很容易踩坑的，下面介紹幾個常見的坑點。

閉包不能直接通路外部變量

這一點我們剛才已經提到了，在閉包當中我們不能直接通路外部的變量的，必須要通過nonlocal關鍵字進行标注，否則的話是會報錯的。

def test():

    n = 0

    def t():

        n += 5

        return n

    return t

比如這樣的話，就會報錯：

閉包當中不能使用循環變量

閉包有一個很大的問題就是不能使用循環變量，這個坑藏得很深，因為單純從代碼的邏輯上來看是發現不了的。也就是說邏輯上沒問題的代碼，運作的時候往往會出乎我們的意料，這需要我們對底層的原理有深刻地了解才能發現，比如我們來看一個例子：

def test(x):

    fs = []

    for i in range(3):

        def f():

            return x + i

        fs.append(f)

    return fs

fs = test(3)

for f in fs:

    print(f())

在上面這個例子當中，我們使用了for循環來建立了3個閉包，我們使用fs存儲這三個閉包并進行傳回。然後我們通過調用test，來獲得了這3個閉包，然後我們進行了調用。

這個邏輯看起來應該沒有問題，按照道理，這3個閉包是通過for循環建立的，并且在閉包當中我們用到了循環變量i。那按照我們的想法，最終輸出的結果應該是[3, 4, 5]，但是很遺憾，最後我們得到的結果是[5, 5, 5]。

看起來很奇怪吧，其實一點也不奇怪，因為循環變量i并不是在建立閉包的時候就set好的。而是當我們執行閉包的時候，我們再去尋找這個i對應的取值，顯然當我們運作閉包的時候，循環已經執行完了，此時的i停在了2。是以這3個閉包的執行結果都是2+3也就是5。這個坑是由Python解釋器當中對于閉包執行的邏輯導緻的，我們編寫的邏輯是對的，但是它并不按照我們的邏輯來，是以這一點要千萬注意，如果忘記了，想要通過debug查找出來會很難。

總結

雖然從表面上閉包存在一些問題和坑點，但是它依然是我們經常使用的Python進階特性，并且它也是很多其他進階用法的基礎。是以我們了解和學會閉包是非常有必要的，千萬不能因噎廢食。

其實并不隻是閉包，很多高度抽象的特性都或多或少的有這樣的問題。因為當我們進行抽象的時候，我們固然簡化了代碼，增加了靈活度，但與此同時我們也讓學習曲線變得陡峭，帶來了更多我們需要了解和記住的内容。本質上這也是一個trade-off，好用的特性需要付出代碼，易學易用的往往意味着比較死闆不夠靈活。對于這個問題，我們需要保持心态，不過好在初看時也許有些難以了解，但總體來說閉包還是比較簡單的，我相信對你們來說一定不成問題。

原文位址

https://www.cnblogs.com/techflow/p/12651679.html