函數式編程
函數是Python內建支持的一種封裝，我們通過把大段代碼拆成函數，通過一層一層的函數調用，就可以把復雜任務分解成簡單的任務，這種分解可以稱之為面向過程的程序設計。函數就是面向過程的程序設計的基本單元。
而函數式編程（請注意多了一個“式”字）——Functional Programming，雖然也可以歸結到面向過程的程序設計，但其思想更接近數學計算。
我們首先要搞明白計算機（Computer）和計算（Compute）的概念。
在計算機的層次上，CPU執行的是加減乘除的指令代碼，以及各種條件判斷和跳轉指令，所以，匯編語言是最貼近計算機的語言。
而計算則指數學意義上的計算，越是抽象的計算，離計算機硬件越遠。
對應到編程語言，就是越低級的語言，越貼近計算機，抽象程度低，執行效率高，比如C語言；越高級的語言，越貼近計算，抽象程度高，執行效率低，比如Lisp語言。
函數式編程就是一種抽象程度很高的編程范式，純粹的函數式編程語言編寫的函數沒有變量，因此，任意一個函數，只要輸入是確定的，輸出就是確定的，這種純函數我們稱之為沒有副作用。而允許使用變量的程序設計語言，由於函數內部的變量狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函數是有副作用的。
函數式編程的一個特點就是，允許把函數本身作為參數傳入另一個函數，還允許返回一個函數！
Python對函數式編程提供部分支持。由於Python允許使用變量，因此，Python不是純函數式編程語言。
高階函數
高階函數英文叫Higher-order function。什么是高階函數？我們以實際代碼為例子，一步一步深入概念。
變量可以指向函數
以Python內置的求絕對值的函數abs()為例，調用該函數用以下代碼：
>>> abs(-10) 10 但是，如果只寫abs呢？
>>> abs
<built-in function abs> 可見，abs(-10)是函數調用，而abs是函數本身。
要獲得函數調用結果，我們可以把結果賦值給變量：
>>> x = abs(-10) >>> x 10 但是，如果把函數本身賦值給變量呢？
>>> f = abs
>>> f
<built-in function abs> 結論：函數本身也可以賦值給變量，即：變量可以指向函數。
如果一個變量指向了一個函數，那么，可否通過該變量來調用這個函數？用代碼驗證一下：
>>> f = abs >>> f(-10) 10 成功！說明變量f現在已經指向了abs函數本身。直接調用abs()函數和調用變量f()完全相同。
函數名也是變量
那么函數名是什么呢？函數名其實就是指向函數的變量！對於abs()這個函數，完全可以把函數名abs看成變量，它指向一個可以計算絕對值的函數！
如果把abs指向其他對象，會有什么情況發生？
>>> abs = 10
>>> abs(-10)
Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'int' object is not callable 把abs指向10后，就無法通過abs(-10)調用該函數了！因為abs這個變量已經不指向求絕對值函數而是指向一個整數10！
當然實際代碼絕對不能這么寫，這里是為了說明函數名也是變量。要恢復abs函數，請重啟Python交互環境。
注：由於abs函數實際上是定義在import builtins模塊中的，所以要讓修改abs變量的指向在其它模塊也生效，要用import builtins; builtins.abs = 10。
傳入函數
既然變量可以指向函數，函數的參數能接收變量，那么一個函數就可以接收另一個函數作為參數，這種函數就稱之為高階函數。
一個最簡單的高階函數：
def add(x, y, f): return f(x) + f(y) 當我們調用add(-5, 6, abs)時，參數x，y和f分別接收-5，6和abs，根據函數定義，我們可以推導計算過程為：
x = -5 y = 6 f = abs f(x) + f(y) ==> abs(-5) + abs(6) ==> 11 return 11 用代碼驗證一下：
>>> add(-5, 6, abs) 11 編寫高階函數，就是讓函數的參數能夠接收別的函數。
小結
把函數作為參數傳入，這樣的函數稱為高階函數，函數式編程就是指這種高度抽象的編程范式。
map/reduce
Python內建了map()和reduce()函數。
如果你讀過Google的那篇大名鼎鼎的論文“MapReduce: Simplified Data Processing on Large Clusters”，你就能大概明白map/reduce的概念。
我們先看map。map()函數接收兩個參數，一個是函數，一個是Iterable，map將傳入的函數依次作用到序列的每個元素，並把結果作為新的Iterator返回。
舉例說明，比如我們有一個函數f(x)=x2，要把這個函數作用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()實現如下：
現在，我們用Python代碼實現：
>>> def f(x): ... return x * x ... >>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> list(r) [1, 4, 9, 16, 25, 36, 49, 64, 81] map()傳入的第一個參數是f，即函數對象本身。由於結果r是一個Iterator，Iterator是惰性序列，因此通過list()函數讓它把整個序列都計算出來並返回一個list。
你可能會想，不需要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所有數字轉為字符串：
>>> 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實現：
>>> from functools import 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就可以派上用場：
>>> from functools import reduce >>> def fn(x, y): ... return x * 10 + y ... >>> reduce(fn, [1, 3, 5, 7, 9]) 13579 這個例子本身沒多大用處，但是，如果考慮到字符串str也是一個序列，對上面的例子稍加改動，配合map()，我們就可以寫出把str轉換為int的函數：
>>> from functools import reduce >>> 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] ... >>> reduce(fn, map(char2num, '13579')) 13579 整理成一個str2int的函數就是：
from functools import reduce 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函數進一步簡化成：
from functools import reduce 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函數的用法在后面介紹。
filter
Python內建的filter()函數用於過濾序列。
和map()類似，filter()也接收一個函數和一個序列。和map()不同的是，filter()把傳入的函數依次作用於每個元素，然后根據返回值是True還是False決定保留還是丟棄該元素。
例如，在一個list中，刪掉偶數，只保留奇數，可以這么寫：
def is_odd(n): return n % 2 == 1 list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])) # 結果: [1, 5, 9, 15] 把一個序列中的空字符串刪掉，可以這么寫：
def not_empty(s): return s and s.strip() list(filter(not_empty, ['A', '', 'B', None, 'C', ' '])) # 結果: ['A', 'B', 'C'] 可見用filter()這個高階函數，關鍵在於正確實現一個“篩選”函數。
注意到filter()函數返回的是一個Iterator，也就是一個惰性序列，所以要強迫filter()完成計算結果，需要用list()函數獲得所有結果並返回list。
sorted
排序算法
排序也是在程序中經常用到的算法。無論使用冒泡排序還是快速排序，排序的核心是比較兩個元素的大小。如果是數字，我們可以直接比較，但如果是字符串或者兩個dict呢？直接比較數學上的大小是沒有意義的，因此，比較的過程必須通過函數抽象出來。
Python內置的sorted()函數就可以對list進行排序：
>>> sorted([36, 5, -12, 9, -21]) [-21, -12, 5, 9, 36] 此外，sorted()函數也是一個高階函數，它還可以接收一個key函數來實現自定義的排序，例如按絕對值大小排序：
>>> sorted([36, 5, -12, 9, -21], key=abs) [5, 9, -12, -21, 36] key指定的函數將作用於list的每一個元素上，並根據key函數返回的結果進行排序。對比原始的list和經過key=abs處理過的list：
list = [36, 5, -12, 9, -21] keys = [36, 5, 12, 9, 21] 然后sorted()函數按照keys進行排序，並按照對應關系返回list相應的元素：
keys排序結果 => [5, 9, 12, 21, 36] | | | | | 最終結果 => [5, 9, -12, -21, 36] 我們再看一個字符串排序的例子：
>>> sorted(['bob', 'about', 'Zoo', 'Credit']) ['Credit', 'Zoo', 'about', 'bob'] 默認情況下，對字符串排序，是按照ASCII的大小比較的，由於'Z' < 'a'，結果，大寫字母Z會排在小寫字母a的前面。
現在，我們提出排序應該忽略大小寫，按照字母序排序。要實現這個算法，不必對現有代碼大加改動，只要我們能用一個key函數把字符串映射為忽略大小寫排序即可。忽略大小寫來比較兩個字符串，實際上就是先把字符串都變成大寫（或者都變成小寫），再比較。
這樣，我們給sorted傳入key函數，即可實現忽略大小寫的排序：
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) ['about', 'bob', 'Credit', 'Zoo'] 要進行反向排序，不必改動key函數，可以傳入第三個參數reverse=True：
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) ['Zoo', 'Credit', 'bob', 'about'] 從上述例子可以看出，高階函數的抽象能力是非常強大的，而且，核心代碼可以保持得非常簡潔。
小結
sorted()也是一個高階函數。用sorted()排序的關鍵在於實現一個映射函數。
返回函數
函數作為返回值
高階函數除了可以接受函數作為參數外，還可以把函數作為結果值返回。
我們來實現一個可變參數的求和。通常情況下，求和的函數是這樣定義的：
def calc_sum(*args): ax = 0 for n in args: ax = ax + n return ax 但是，如果不需要立刻求和，而是在后面的代碼中，根據需要再計算怎么辦？可以不返回求和的結果，而是返回求和的函數：
def lazy_sum(*args): def sum(): ax = 0 for n in args: ax = ax + n return ax return sum 當我們調用lazy_sum()時，返回的並不是求和結果，而是求和函數：
>>> f = lazy_sum(1, 3, 5, 7, 9) >>> f <function lazy_sum.<locals>.sum at 0x101c6ed90> 調用函數f時，才真正計算求和的結果：
>>> f() 25 在這個例子中，我們在函數lazy_sum中又定義了函數sum，並且，內部函數sum可以引用外部函數lazy_sum的參數和局部變量，當lazy_sum返回函數sum時，相關參數和變量都保存在返回的函數中，這種稱為“閉包（Closure）”的程序結構擁有極大的威力。
請再注意一點，當我們調用lazy_sum()時，每次調用都會返回一個新的函數，即使傳入相同的參數：
>>> f1 = lazy_sum(1, 3, 5, 7, 9) >>> f2 = lazy_sum(1, 3, 5, 7, 9) >>> f1==f2 False f1()和f2()的調用結果互不影響。
閉包
注意到返回的函數在其定義內部引用了局部變量args，所以，當一個函數返回了一個函數后，其內部的局部變量還被新函數引用，所以，閉包用起來簡單，實現起來可不容易。
另一個需要注意的問題是，返回的函數並沒有立刻執行，而是直到調用了f()才執行。我們來看一個例子：
def count(): fs = [] for i in range(1, 4): def f(): return i*i fs.append(f) return fs f1, f2, f3 = count() 在上面的例子中，每次循環，都創建了一個新的函數，然后，把創建的3個函數都返回了。
你可能認為調用f1()，f2()和f3()結果應該是1，4，9，但實際結果是：
>>> f1() 9 >>> f2() 9 >>> f3() 9 全部都是9！原因就在於返回的函數引用了變量i，但它並非立刻執行。等到3個函數都返回時，它們所引用的變量i已經變成了3，因此最終結果為9。
返回閉包時牢記的一點就是：返回函數不要引用任何循環變量，或者后續會發生變化的變量。
如果一定要引用循環變量怎么辦？方法是再創建一個函數，用該函數的參數綁定循環變量當前的值，無論該循環變量后續如何更改，已綁定到函數參數的值不變：
def count(): def f(j): def g(): return j*j return g fs = [] for i in range(1, 4): fs.append(f(i)) # f(i)立刻被執行，因此i的當前值被傳入f() return fs 再看看結果：
>>> f1, f2, f3 = count() >>> f1() 1 >>> f2() 4 >>> f3() 9 缺點是代碼較長，可利用lambda函數縮短代碼。
小結
一個函數可以返回一個計算結果，也可以返回一個函數。
返回一個函數時，牢記該函數並未執行，返回函數中不要引用任何可能會變化的變量。
匿名函數
當我們在傳入函數時，有些時候，不需要顯式地定義函數，直接傳入匿名函數更方便。
在Python中，對匿名函數提供了有限支持。還是以map()函數為例，計算f(x)=x2時，除了定義一個f(x)的函數外，還可以直接傳入匿名函數：
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])) [1, 4, 9, 16, 25, 36, 49, 64, 81] 通過對比可以看出，匿名函數lambda x: x * x實際上就是：
def f(x): return x * x 關鍵字lambda表示匿名函數，冒號前面的x表示函數參數。
匿名函數有個限制，就是只能有一個表達式，不用寫return，返回值就是該表達式的結果。
用匿名函數有個好處，因為函數沒有名字，不必擔心函數名沖突。此外，匿名函數也是一個函數對象，也可以把匿名函數賦值給一個變量，再利用變量來調用該函數：
>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28> >>> f(5) 25 同樣，也可以把匿名函數作為返回值返回，比如：
def build(x, y): return lambda: x * x + y * y 小結
Python對匿名函數的支持有限，只有一些簡單的情況下可以使用匿名函數。
偏函數
Python的functools模塊提供了很多有用的功能，其中一個就是偏函數（Partial function）。要注意，這里的偏函數和數學意義上的偏函數不一樣。
在介紹函數參數的時候，我們講到，通過設定參數的默認值，可以降低函數調用的難度。而偏函數也可以做到這一點。舉例如下：
int()函數可以把字符串轉換為整數，當僅傳入字符串時，int()函數默認按十進制轉換：
>>> int('12345') 12345 但int()函數還提供額外的base參數，默認值為10。如果傳入base參數，就可以做N進制的轉換：
>>> int('12345', base=8) 5349 >>> int('12345', 16) 74565 假設要轉換大量的二進制字符串，每次都傳入int(x, base=2)非常麻煩，於是，我們想到，可以定義一個int2()的函數，默認把base=2傳進去：
def int2(x, base=2): return int(x, base) 這樣，我們轉換二進制就非常方便了：
>>> int2('1000000') 64 >>> int2('1010101') 85 functools.partial就是幫助我們創建一個偏函數的，不需要我們自己定義int2()，可以直接使用下面的代碼創建一個新的函數int2：
>>> import functools >>> int2 = functools.partial(int, base=2) >>> int2('1000000') 64 >>> int2('1010101') 85 所以，簡單總結functools.partial的作用就是，把一個函數的某些參數給固定住（也就是設置默認值），返回一個新的函數，調用這個新函數會更簡單。
注意到上面的新的int2函數，僅僅是把base參數重新設定默認值為2，但也可以在函數調用時傳入其他值：
>>> int2('1000000', base=10) 1000000 最后，創建偏函數時，實際上可以接收函數對象、*args和**kw這3個參數，當傳入：
int2 = functools.partial(int, base=2) 實際上固定了int()函數的關鍵字參數base，也就是：
int2('10010')
相當於：
kw = { 'base': 2 } int('10010', **kw) 當傳入：
max2 = functools.partial(max, 10) 實際上會把10作為*args的一部分自動加到左邊，也就是：
max2(5, 6, 7)
相當於：
args = (10, 5, 6, 7)
max(*args)
結果為10。
小結
當函數的參數個數太多，需要簡化時，使用functools.partial可以創建一個新的函數，這個新函數可以固定住原函數的部分參數，從而在調用時更簡單。