Python 高階函數【轉】

標籤：put   序列   完全   mat   實現   abs   callable   min   cti   

函數是Python內建支援的一種封裝，我們通過把大段代碼拆成函數，通過一層一層的函數調用，就可以把複雜任務分解成簡單的任務，這種分解可以稱之為面向過程的程式設計。函數就是面向過程的程式設計的基本單元。

而函數式編程（請注意多了一個“式”字）——Functional Programming，雖然也可以歸結到面向過程的程式設計，但其思想更接近數學計算。

我們首先要搞明白電腦（Computer）和計算（Compute）的概念。

在電腦的層次上，CPU執行的是加減乘除的指令代碼，以及各種條件判斷和跳轉指令，所以，組合語言是最貼近電腦的語言。

而計算則指數學意義上的計算，越是抽象的計算，離電腦硬體越遠。

對應到程式設計語言，就是越低級的語言，越貼近電腦，抽象程度低，執行效率高，比如C語言；越進階的語言，越貼近計算，抽象程度高，執行效率低，比如Lisp語言。

函數式編程就是一種抽象程度很高的編程範式，純粹的函數式程式設計語言編寫的函數沒有變數，因此，任意一個函數，只要輸入是確定的，輸出就是確定的，這種純函數我們稱之為沒有副作用。而允許使用變數的程式設計語言，由於函數內部的變數狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函數是有副作用的。

函數式編程的一個特點就是，允許把函數本身作為參數傳入另一個函數，還允許返回一個函數！

Python對函數式編程提供部分支援。由於Python允許使用變數，因此，Python不是純函數式程式設計語言。

高階函數變數可以指向函數

以Python內建的求絕對值的函數abs()為例，調用該函數用以下代碼：

In [1]: abs(3+4j)Out[1]: 5.0

但是，如果唯寫abs呢？

In [2]: absOut[2]: <function abs>

可見，abs(3+4j)是函數調用，而abs是函數本身。

要獲得函數調用結果，我們可以把結果賦值給變數：

In [3]: x = abs(-10)In [4]: xOut[4]: 10

但是，如果把函數本身賦值給變數呢？

In [5]: f = absIn [6]: fOut[6]: <function abs>

結論：函數本身也可以賦值給變數，即：變數可以指向函數。

如果一個變數指向了一個函數，那麼，可否通過該變數來調用這個函數？用代碼驗證一下：

In [7]: f = absIn [8]: f(-10)Out[8]: 10

成功！說明變數f現在已經指向了abs函數本身。

函數名也是變數

那麼函數名是什麼呢？函數名其實就是指向函數的變數！對於abs()這個函數，完全可以把函數名abs看成變數，它指向一個可以計算絕對值的函數！

如果把abs指向其他對象，會有什麼情況發生？

In [9]: abs = 10In [10]: abs(-10)---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)<ipython-input-10-c432e3f1fd6c> in <module>()----> 1 abs(-10)TypeError: 'int' object is not callable

把abs指向10後，就無法通過abs(-10)調用該函數了！因為abs這個變數已經不指向求絕對值函數了！

當然實際代碼絕對不能這麼寫，這裡是為了說明函數名也是變數。要恢複abs函數，請重啟Python互動環境。

註：由於abs函數實際上是定義在__builtin__模組中的，所以要讓修改abs變數的指向在其它模組也生效，要用__builtin__.abs = 10。

傳入函數

既然變數可以指向函數，函數的參數能接收變數，那麼一個函數就可以接收另一個函數作為參數，這種函數就稱之為高階函數。

一個最簡單的高階函數：

def add(x, y, f):    return f(x) + f(y)

當我們調用add(-5, 6, abs)時，參數x，y和f分別接收-5，6和abs，根據函數定義，我們可以推導計算過程為：

x ==> -5y ==> 6f ==> absf(x) + f(y) ==> abs(-5) + abs(6) ==> 11

用代碼驗證一下：

>>> add(-5, 6, abs)11

編寫高階函數，就是讓函數的參數能夠接收別的函數。

內建高階函數map/reduce

Python內建了map()和reduce()函數。

如果你讀過Google的那篇大名鼎鼎的論文“MapReduce: Simplified Data Processing on Large Clusters”，你就能大概明白map/reduce的概念。

我們先看map。map()函數接收兩個參數，一個是函數，一個是序列，map將傳入的函數依次作用到序列的每個元素，並把結果作為新的list返回。

舉例說明，比如我們有一個函數f(x)=x2，要把這個函數作用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()實現如下：

現在，我們用Python代碼實現：

>>> def f(x):...     return x * x...>>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])[1, 4, 9, 16, 25, 36, 49, 64, 81]

map()傳入的第一個參數是f，即函數對象本身。

你可能會想，不需要map()函數，寫一個迴圈，也可以計算出結果：

L = []for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:    L.append(f(n))print L

的確可以，但是，從上面的迴圈代碼，能一眼看明白“把f(x)作用在list的每一個元素並把結果產生一個新的list”嗎？

所以，map()作為高階函數，事實上它把運算規則抽象了，因此，我們不但可以計算簡單的f(x)=x2，還可以計算任意複雜的函數，比如，把這個list所有數字轉為字串：

>>> map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])['1', '2', '3', '4', '5', '6', '7', '8', '9']

只需要一行代碼。

再看reduce的用法。reduce把一個函數作用在一個序列[x1, x2, x3...]上，這個函數必須接收兩個參數，reduce把結果繼續和序列的下一個元素做累積計算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方說對一個序列求和，就可以用reduce實現：

>>> def add(x, y):...     return x + y...>>> reduce(add, [1, 3, 5, 7, 9])25

當然求和運算可以直接用Python內建函數sum()，沒必要動用reduce。

但是如果要把序列[1, 3, 5, 7, 9]變換成整數13579，reduce就可以派上用場：

>>> def fn(x, y):...     return x * 10 + y...>>> reduce(fn, [1, 3, 5, 7, 9])13579

Python 3裡,reduce()函數已經被從全域名字空間裡移除了,它現在被放置在fucntools模組裡 用的話要先引
入

>>> def fn(x, y):...     return x * 10 + y... >>> reduce(fn, [1, 3, 5, 7, 9])Traceback (most recent call last):  File "<input>", line 1, in <module>    reduce(fn, [1, 3, 5, 7, 9])NameError: name 'reduce' is not defined>>> from functools import reduce>>> reduce(fn, [1, 3, 5, 7, 9])13579

這個例子本身沒多大用處，但是，如果考慮到字串str也是一個序列，對上面的例子稍加改動，配合map()，我們就可以寫出把str轉換為int的函數：

>>> def char2num(s):...     kw = {...         '0': 0,...         '1': 1,...         '2': 2,...         '3': 3,...         '4': 4,...         '5': 5,...         '6': 6,...         '7': 7,...         '8': 8,...         '9': 9...         }...     return kw[s]... >>> map(char2num, '13579')<map object at 0x7fb480263a90>>>> reduce(fn, map(char2num, '13579'))13579>>> 

整理成一個str2int的函數就是：

def str2int(s):    def fn(x, y):        return x * 10 + y    def char2num(s):        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]    return reduce(fn, map(char2num, s))

還可以用lambda函數進一步簡化成：

def char2num(s):    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]def str2int(s):    return reduce(lambda x,y: x*10+y, map(char2num, s))

也就是說，假設Python沒有提供int()函數，你完全可以自己寫一個把字串轉化為整數的函數，而且只需要幾行代碼！

lambda函數的用法在後面介紹。

練習

利用map()函數，把使用者輸入的不規範的英文名字，變為首字母大寫，其他小寫規範名字。輸入：[‘adam‘, ‘LISA‘, ‘barT‘]，輸出：[‘Adam‘, ‘Lisa‘, ‘Bart‘]。

>>> def capitalizeMore(nameList):...     return map(lambda x: x.capitalize(), nameList)...     ... >>> for i in capitalizeMore(['adam', 'LISA', 'barT']):...     print(i)...     ... AdamLisaBart>>> 

Python提供的sum()函數可以接受一個list並求和，請編寫一個prod()函數，可以接受一個list並利用reduce()求積。

>>> def prod(x, y):...     return x * y... >>> reduce(prod, [2, 4, 5, 7, 12])3360

filter

Python內建的filter()函數用於過濾序列。

和map()類似，filter()也接收一個函數和一個序列。和map()不同的時，filter()把傳入的函數依次作用於每個元素，然後根據傳回值是True還是False決定保留還是丟棄該元素。

例如，在一個list中，刪掉偶數，只保留奇數，可以這麼寫：

def is_odd(n):    return n % 2 == 1filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])# 結果: [1, 5, 9, 15]

把一個序列中的Null 字元串刪掉，可以這麼寫：

def not_empty(s):    return s and s.strip()filter(not_empty, ['A', '', 'B', None, 'C', '  '])# 結果: ['A', 'B', 'C']

可見用filter()這個高階函數，關鍵在於正確實現一個“篩選”函數。

練習

請嘗試用filter()刪除1~100的素數。

>>> import math>>> def is_sqr(x):...     r = int(math.sqrt(x))...     return r*r == x... >>> filter(is_sqr, range(1, 101))<filter object at 0x7fb4802ec4a8>>>> list(filter(is_sqr, range(1, 101)))[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

sorted排序演算法

排序也是在程式中經常用到的演算法。無論使用冒泡排序還是快速排序，排序的核心是比較兩個元素的大小。如果是數字，我們可以直接比較，但如果是字串或者兩個dict呢？直接比較數學上的大小是沒有意義的，因此，比較的過程必須通過函數抽象出來。通常規定，對於兩個元素x和y，如果認為x < y，則返回-1，如果認為x == y，則返回0，如果認為x > y，則返回1，這樣，排序演算法就不用關心具體的比較過程，而是根據比較結果直接排序。

Python內建的sorted()函數就可以對list進行排序：

>>> sorted([36, 5, 12, 9, 21])[5, 9, 12, 21, 36]

此外，sorted()函數也是一個高階函數，它還可以接收一個比較函數來實現自訂的排序。比如，如果要倒序排序，我們就可以自訂一個reversed_cmp函數：

def reversed_cmp(x, y):    if x > y:        return -1    if x < y:        return 1    return 0

傳入自訂的比較函數reversed_cmp，就可以實現倒序排序：

>>> sorted([36, 5, 12, 9, 21], reversed_cmp)[36, 21, 12, 9, 5]

我們再看一個字串排序的例子：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'])['Credit', 'Zoo', 'about', 'bob']

預設情況下，對字串排序，是按照ASCII的大小比較的，由於‘Z‘ < ‘a‘，結果，大寫字母Z會排在小寫字母a的前面。

現在，我們提出排序應該忽略大小寫，按照字母序排序。要實現這個演算法，不必對現有代碼大加改動，只要我們能定義出忽略大小寫比較演算法就可以：

def cmp_ignore_case(s1, s2):    u1 = s1.upper()    u2 = s2.upper()    if u1 < u2:        return -1    if u1 > u2:        return 1    return 0

忽略大小寫來比較兩個字串，實際上就是先把字串都變成大寫（或者都變成小寫），再比較。

這樣，我們給sorted傳入上述比較函數，即可實現忽略大小寫排序：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)['about', 'bob', 'Credit', 'Zoo']

從上述例子可以看出，高階函數的抽象能力是非常強大的，而且，核心代碼可以保持得非常簡潔。

參考

• 慕課網教程筆記
• 廖雪峰老師網站

  ---恢複內容結束---

Python 高階函數【轉】