概述?

本章介紹函數式編程的基本概念。如您僅想學(xué)習 Python 語(yǔ)言的特性，可跳過(guò)本章直接查看 迭代器.

編程語(yǔ)言支持通過(guò)以下幾種方式來(lái)解構具體問(wèn)題：

• 大多數的編程語(yǔ)言都是 過(guò)程式 的，所謂程序就是一連串告訴計算機怎樣處理程序輸入的指令。C、Pascal 甚至 Unix shells 都是過(guò)程式語(yǔ)言。

• 在 聲明式 語(yǔ)言中，你編寫(xiě)一個(gè)用來(lái)描述待解決問(wèn)題的說(shuō)明，并且這個(gè)語(yǔ)言的具體實(shí)現會(huì )指明怎樣高效的進(jìn)行計算。 SQL 可能是你最熟悉的聲明式語(yǔ)言了。 一個(gè) SQL 查詢(xún)語(yǔ)句描述了你想要檢索的數據集，并且 SQL 引擎會(huì )決定是掃描整張表還是使用索引，應該先執行哪些子句等等。

• 面向對象 程序會(huì )操作一組對象。 對象擁有內部狀態(tài)，并能夠以某種方式支持請求和修改這個(gè)內部狀態(tài)的方法。Smalltalk 和 Java 都是面向對象的語(yǔ)言。 C++ 和 Python 支持面向對象編程，但并不強制使用面向對象特性。

• 函數式 編程則將一個(gè)問(wèn)題分解成一系列函數。 理想情況下，函數只接受輸入并輸出結果，對一個(gè)給定的輸入也不會(huì )有影響輸出的內部狀態(tài)。 著(zhù)名的函數式語(yǔ)言有 ML 家族（Standard ML，Ocaml 以及其他變種）和 Haskell。

一些語(yǔ)言的設計者選擇強調一種特定的編程方式。 這通常會(huì )讓以不同的方式來(lái)編寫(xiě)程序變得困難。其他多范式語(yǔ)言則支持幾種不同的編程方式。Lisp，C++ 和 Python 都是多范式語(yǔ)言；使用這些語(yǔ)言，你可以編寫(xiě)主要為過(guò)程式，面向對象或者函數式的程序和函數庫。在大型程序中，不同的部分可能會(huì )采用不同的方式編寫(xiě)；比如 GUI 可能是面向對象的而處理邏輯則是過(guò)程式或者函數式。

在函數式程序里，輸入會(huì )流經(jīng)一系列函數。每個(gè)函數接受輸入并輸出結果。函數式風(fēng)格反對使用帶有副作用的函數，這些副作用會(huì )修改內部狀態(tài)，或者引起一些無(wú)法體現在函數的返回值中的變化。完全不產(chǎn)生副作用的函數被稱(chēng)作“純函數”。消除副作用意味著(zhù)不能使用隨程序運行而更新的數據結構；每個(gè)函數的輸出必須只依賴(lài)于輸入。

Some languages are very strict about purity and don't even have assignment statements such as a=3 or c = a + b, but it's difficult to avoid all side effects, such as printing to the screen or writing to a disk file. Another example is a call to the print() or time.sleep() function, neither of which returns a useful value. Both are called only for their side effects of sending some text to the screen or pausing execution for a second.

函數式風(fēng)格的 Python 程序并不會(huì )極端到消除所有 I/O 或者賦值的程度；相反，他們會(huì )提供像函數式一樣的接口，但會(huì )在內部使用非函數式的特性。比如，函數的實(shí)現仍然會(huì )使用局部變量，但不會(huì )修改全局變量或者有其他副作用。

函數式編程可以被認為是面向對象編程的對立面。對象就像是顆小膠囊，包裹著(zhù)內部狀態(tài)和隨之而來(lái)的能讓你修改這個(gè)內部狀態(tài)的一組調用方法，以及由正確的狀態(tài)變化所構成的程序。函數式編程希望盡可能地消除狀態(tài)變化，只和流經(jīng)函數的數據打交道。在 Python 里你可以把兩種編程方式結合起來(lái)，在你的應用（電子郵件信息，事務(wù)處理）中編寫(xiě)接受和返回對象實(shí)例的函數。

函數式設計在工作中看起來(lái)是個(gè)奇怪的約束。為什么你要消除對象和副作用呢？不過(guò)函數式風(fēng)格有其理論和實(shí)踐上的優(yōu)點(diǎn)：

• 形式證明。

• 模塊化。

• 組合性。

• 易于調試和測試。

迭代器?

我會(huì )從 Python 的一個(gè)語(yǔ)言特性， 編寫(xiě)函數式風(fēng)格程序的重要基石開(kāi)始說(shuō)起：迭代器。

迭代器是一個(gè)表示數據流的對象；這個(gè)對象每次只返回一個(gè)元素。Python 迭代器必須支持 __next__() 方法；這個(gè)方法不接受參數，并總是返回數據流中的下一個(gè)元素。如果數據流中沒(méi)有元素，__next__() 會(huì )拋出 StopIteration 異常。迭代器未必是有限的；完全有理由構造一個(gè)輸出無(wú)限數據流的迭代器。

內置的 iter() 函數接受任意對象并試圖返回一個(gè)迭代器來(lái)輸出對象的內容或元素，并會(huì )在對象不支持迭代的時(shí)候拋出 TypeError 異常。Python 有幾種內置數據類(lèi)型支持迭代，最常見(jiàn)的就是列表和字典。如果一個(gè)對象能生成迭代器，那么它就會(huì )被稱(chēng)作 iterable。

你可以手動(dòng)試驗迭代器的接口。

>>> L = [1, 2, 3]
>>> it = iter(L)
>>> it  
<...iterator object at ...>
>>> it.__next__()  # same as next(it)
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

Python 有不少要求使用可迭代的對象的地方，其中最重要的就是 for 表達式。在表達式 for X in Y，Y 要么自身是一個(gè)迭代器，要么能夠由 iter() 創(chuàng )建一個(gè)迭代器。以下兩種表達是等價(jià)的:

for i in iter(obj):
    print(i)

for i in obj:
    print(i)

可以用 list() 或 tuple() 這樣的構造函數把迭代器具體化成列表或元組:

>>> L = [1, 2, 3]
>>> iterator = iter(L)
>>> t = tuple(iterator)
>>> t
(1, 2, 3)

序列的解壓操作也支持迭代器：如果你知道一個(gè)迭代器能夠返回 N 個(gè)元素，你可以把他們解壓到有 N 個(gè)元素的元組:

>>> L = [1, 2, 3]
>>> iterator = iter(L)
>>> a, b, c = iterator
>>> a, b, c
(1, 2, 3)

像 max() 和 min() 這樣的內置函數可以接受單個(gè)迭代器參數，然后返回其中最大或者最小的元素。"in" 和 "not in" 操作也支持迭代器：如果能夠在迭代器 iterator 返回的數據流中找到 X 的話(huà)，則``X in iterator`` 為真。很顯然，如果迭代器是無(wú)限的，這么做你就會(huì )遇到問(wèn)題；max() 和 min() 永遠也不會(huì )返回；如果元素 X 也不出現在數據流中，"in" 和 "not in" 操作同樣也永遠不會(huì )返回。

注意你只能在迭代器中順序前進(jìn)；沒(méi)有獲取前一個(gè)元素的方法，除非重置迭代器，或者重新復制一份。迭代器對象可以提供這些額外的功能，但迭代器協(xié)議只明確了 __next__() 方法。函數可能因此而耗盡迭代器的輸出，如果你要對同樣的數據流做不同的操作，你必須重新創(chuàng )建一個(gè)迭代器。

>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
...      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
...     print(key, m[key])
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

>>> L = [('Italy', 'Rome'), ('France', 'Paris'), ('US', 'Washington DC')]
>>> dict(iter(L))
{'Italy': 'Rome', 'France': 'Paris', 'US': 'Washington DC'}

for line in file:
    # do something for each line
    ...

S = {2, 3, 5, 7, 11, 13}
for i in S:
    print(i)

生成器表達式和列表推導式?

迭代器的輸出有兩個(gè)很常見(jiàn)的使用方式，1) 對每一個(gè)元素執行操作，2) 選擇一個(gè)符合條件的元素子集。比如，給定一個(gè)字符串列表，你可能想去掉每個(gè)字符串尾部的空白字符，或是選出所有包含給定子串的字符串。

列表推導式和生成器表達時(shí)（簡(jiǎn)寫(xiě)："listcomps" 和 "genexps"）讓這些操作更加簡(jiǎn)明，這個(gè)形式借鑒自函數式程序語(yǔ)言 Haskell（https://www.haskell.org/）。你可以用以下代碼去掉一個(gè)字符串流中的所有空白字符:

line_list = ['  line 1\n', 'line 2  \n', ...]

# Generator expression -- returns iterator
stripped_iter = (line.strip() for line in line_list)

# List comprehension -- returns list
stripped_list = [line.strip() for line in line_list]

你可以加上條件語(yǔ)句 "if" 來(lái)選取特定的元素:

stripped_list = [line.strip() for line in line_list
                 if line != ""]

通過(guò)列表推導式，你會(huì )獲得一個(gè) Python 列表；stripped_list 就是一個(gè)包含所有結果行的列表，并不是迭代器。 生成器表達式會(huì )返回一個(gè)迭代器，它在必要的時(shí)候計算結果，避免一次性生成所有的值。 這意味著(zhù)，如果迭代器返回一個(gè)無(wú)限數據流或者大量的數據，列表推導式就不太好用了。 這種情況下生成器表達式會(huì )更受青睞。

生成器表達式兩邊使用圓括號 ("()") ，而列表推導式則使用方括號 ("[]")。生成器表達式的形式為:

( expression for expr in sequence1
             if condition1
             for expr2 in sequence2
             if condition2
             for expr3 in sequence3 ...
             if condition3
             for exprN in sequenceN
             if conditionN )

再次說(shuō)明，列表推導式只有兩邊的括號不一樣（方括號而不是圓括號）。

這些生成用于輸出的元素會(huì )成為 expression 的后繼值。其中 if 語(yǔ)句是可選的；如果給定的話(huà) expression 只會(huì )在符合條件時(shí)計算并加入到結果中。

生成器表達式總是寫(xiě)在圓括號里面，不過(guò)也可以算上調用函數時(shí)用的括號。如果你想即時(shí)創(chuàng )建一個(gè)傳遞給函數的迭代器，可以這么寫(xiě):

obj_total = sum(obj.count for obj in list_all_objects())

其中 for...in 語(yǔ)句包含了將要遍歷的序列。這些序列并不必須同樣長(cháng)，因為它們會(huì )從左往右開(kāi)始遍歷，而 不是 同時(shí)執行。對每個(gè) sequence1 中的元素，sequence2 會(huì )從頭開(kāi)始遍歷。sequence3 會(huì )對每個(gè) sequence1 和 sequence2 的元素對開(kāi)始遍歷。

換句話(huà)說(shuō)，列表推導式器是和下面的 Python 代碼等價(jià):

for expr1 in sequence1:
    if not (condition1):
        continue   # Skip this element
    for expr2 in sequence2:
        if not (condition2):
            continue   # Skip this element
        ...
        for exprN in sequenceN:
            if not (conditionN):
                continue   # Skip this element

            # Output the value of
            # the expression.

這說(shuō)明，如果有多個(gè) for...in 語(yǔ)句而沒(méi)有 if 語(yǔ)句，輸出結果的長(cháng)度就是所有序列長(cháng)度的乘積。如果你的兩個(gè)列表長(cháng)度為3，那么輸出的列表長(cháng)度就是9:

>>> seq1 = 'abc'
>>> seq2 = (1, 2, 3)
>>> [(x, y) for x in seq1 for y in seq2]  
[('a', 1), ('a', 2), ('a', 3),
 ('b', 1), ('b', 2), ('b', 3),
 ('c', 1), ('c', 2), ('c', 3)]

為了不讓 Python 語(yǔ)法變得含糊，如果 expression 會(huì )生成元組，那這個(gè)元組必須要用括號括起來(lái)。下面第一個(gè)列表推導式語(yǔ)法錯誤，第二個(gè)則是正確的:

# Syntax error
[x, y for x in seq1 for y in seq2]
# Correct
[(x, y) for x in seq1 for y in seq2]

生成器?

生成器是一類(lèi)用來(lái)簡(jiǎn)化編寫(xiě)迭代器工作的特殊函數。普通的函數計算并返回一個(gè)值，而生成器返回一個(gè)能返回數據流的迭代器。

毫無(wú)疑問(wèn)，你已經(jīng)對如何在 Python 和 C 中調用普通函數很熟悉了，這時(shí)候函數會(huì )獲得一個(gè)創(chuàng )建局部變量的私有命名空間。當函數到達 return 表達式時(shí)，局部變量會(huì )被銷(xiāo)毀然后把返回給調用者。之后調用同樣的函數時(shí)會(huì )創(chuàng )建一個(gè)新的私有命名空間和一組全新的局部變量。但是，如果在退出一個(gè)函數時(shí)不扔掉局部變量會(huì )如何呢？如果稍后你能夠從退出函數的地方重新恢復又如何呢？這就是生成器所提供的；他們可以被看成可恢復的函數。

這里有簡(jiǎn)單的生成器函數示例:

>>> def generate_ints(N):
...    for i in range(N):
...        yield i

任何包含了 yield 關(guān)鍵字的函數都是生成器函數；Python 的 bytecode 編譯器會(huì )在編譯的時(shí)候檢測到并因此而特殊處理。

當你調用一個(gè)生成器函數，它并不會(huì )返回單獨的值，而是返回一個(gè)支持生成器協(xié)議的生成器對象。當執行 yield 表達式時(shí)，生成器會(huì )輸出 i 的值，就像 return 表達式一樣。yield 和 return 最大的區別在于，到達 yield 的時(shí)候生成器的執行狀態(tài)會(huì )掛起并保留局部變量。在下一次調用生成器 __next__() 方法的時(shí)候，函數會(huì )恢復執行。

這里有一個(gè) generate_ints() 生成器的示例:

>>> gen = generate_ints(3)
>>> gen  
<generator object generate_ints at ...>
>>> next(gen)
0
>>> next(gen)
1
>>> next(gen)
2
>>> next(gen)
Traceback (most recent call last):
  File "stdin", line 1, in <module>
  File "stdin", line 2, in generate_ints
StopIteration

同樣，你可以寫(xiě)出 for i in generate_ints(5)，或者 a, b, c = generate_ints(3)。

在生成器函數里面，return value 會(huì )觸發(fā)從 __next__() 方法拋出 StopIteration(value) 異常。一旦拋出這個(gè)異常，或者函數結束，處理數據的過(guò)程就會(huì )停止，生成器也不會(huì )再生成新的值。

你可以手動(dòng)編寫(xiě)自己的類(lèi)來(lái)達到生成器的效果，把生成器的所有局部變量作為實(shí)例的成員變量存儲起來(lái)。比如，可以這么返回一個(gè)整數列表：把 self.count 設為0，然后通過(guò) count`()。然而，對于一個(gè)中等復雜程度的生成器，寫(xiě)出一個(gè)相應的類(lèi)可能會(huì )相當繁雜。

包含在 Python 庫中的測試套件 Lib/test/test_generators.py 里有很多非常有趣的例子。這里是一個(gè)用生成器實(shí)現樹(shù)的遞歸中序遍歷示例。:

# A recursive generator that generates Tree leaves in in-order.
def inorder(t):
    if t:
        for x in inorder(t.left):
            yield x

        yield t.label

        for x in inorder(t.right):
            yield x

另外兩個(gè) test_generators.py 中的例子給出了 N 皇后問(wèn)題（在 NxN 的棋盤(pán)上放置 N 個(gè)皇后，任何一個(gè)都不能吃掉另一個(gè)），以及馬的遍歷路線(xiàn)（在NxN 的棋盤(pán)上給馬找出一條不重復的走過(guò)所有格子的路線(xiàn)）的解。

val = (yield i)

def counter(maximum):
    i = 0
    while i < maximum:
        val = (yield i)
        # If value provided, change counter
        if val is not None:
            i = val
        else:
            i += 1

>>> it = counter(10)  
>>> next(it)  
0
>>> next(it)  
1
>>> it.send(8)  
8
>>> next(it)  
9
>>> next(it)  
Traceback (most recent call last):
  File "t.py", line 15, in <module>
    it.next()
StopIteration

內置函數?

我們可以看看迭代器常常用到的函數的更多細節。

Python 內置的兩個(gè)函數 map() 和 filter() 復制了生成器表達式的兩個(gè)特性:

map(f, iterA, iterB, ...) 返回一個(gè)遍歷序列的迭代器

f(iterA[0], iterB[0]), f(iterA[1], iterB[1]), f(iterA[2], iterB[2]), ....

>>>

>>> def upper(s):
...     return s.upper()

>>>

>>> list(map(upper, ['sentence', 'fragment']))
['SENTENCE', 'FRAGMENT']
>>> [upper(s) for s in ['sentence', 'fragment']]
['SENTENCE', 'FRAGMENT']

你當然也可以用列表推導式達到同樣的效果。

filter(predicate, iter) 返回一個(gè)遍歷序列中滿(mǎn)足指定條件的元素的迭代器，和列表推導式的功能相似。 predicate （謂詞）是一個(gè)在特定條件下返回真值的函數；要使用函數 filter()，謂詞函數必須只能接受一個(gè)參數。

>>> def is_even(x):
...     return (x % 2) == 0

>>> list(filter(is_even, range(10)))
[0, 2, 4, 6, 8]

這也可以寫(xiě)成列表推導式:

>>> list(x for x in range(10) if is_even(x))
[0, 2, 4, 6, 8]

enumerate(iter, start=0) 計數可迭代對象中的元素，然后返回包含每個(gè)計數（從 start 開(kāi)始）和元素兩個(gè)值的元組。:

>>> for item in enumerate(['subject', 'verb', 'object']):
...     print(item)
(0, 'subject')
(1, 'verb')
(2, 'object')

enumerate() 常常用于遍歷列表并記錄達到特定條件時(shí)的下標:

f = open('data.txt', 'r')
for i, line in enumerate(f):
    if line.strip() == '':
        print('Blank line at line #%i' % i)

sorted(iterable, key=None, reverse=False) 會(huì )將 iterable 中的元素收集到一個(gè)列表中，然后排序并返回結果。其中 key 和 reverse 參數會(huì )傳遞給所創(chuàng )建列表的 sort() 方法。:

>>> import random
>>> # Generate 8 random numbers between [0, 10000)
>>> rand_list = random.sample(range(10000), 8)
>>> rand_list  
[769, 7953, 9828, 6431, 8442, 9878, 6213, 2207]
>>> sorted(rand_list)  
[769, 2207, 6213, 6431, 7953, 8442, 9828, 9878]
>>> sorted(rand_list, reverse=True)  
[9878, 9828, 8442, 7953, 6431, 6213, 2207, 769]

（對排序更詳細的討論可參見(jiàn) 排序指南。）

內置函數 any(iter) 和 all(iter) 會(huì )查看一個(gè)可迭代對象內容的邏輯值。any() 在可迭代對象中任意一個(gè)元素為真時(shí)返回 True，而 all() 在所有元素為真時(shí)返回 True:

>>> any([0, 1, 0])
True
>>> any([0, 0, 0])
False
>>> any([1, 1, 1])
True
>>> all([0, 1, 0])
False
>>> all([0, 0, 0])
False
>>> all([1, 1, 1])
True

zip(iterA, iterB, ...) 從每個(gè)可迭代對象中選取單個(gè)元素組成列表并返回:

zip(['a', 'b', 'c'], (1, 2, 3)) =>
  ('a', 1), ('b', 2), ('c', 3)

它并不會(huì )在內存創(chuàng )建一個(gè)列表并因此在返回前而耗盡輸入的迭代器；相反，只有在被請求的時(shí)候元組才會(huì )創(chuàng )建并返回。（這種行為的技術(shù)術(shù)語(yǔ)叫惰性計算，參見(jiàn) lazy evaluation.）

這個(gè)迭代器設計用于長(cháng)度相同的可迭代對象。如果可迭代對象的長(cháng)度不一致，返回的數據流的長(cháng)度會(huì )和最短的可迭代對象相同

zip(['a', 'b'], (1, 2, 3)) =>
  ('a', 1), ('b', 2)

然而，你應該避免這種情況，因為所有從更長(cháng)的迭代器中取出的元素都會(huì )被丟棄。這意味著(zhù)之后你也無(wú)法冒著(zhù)跳過(guò)被丟棄元素的風(fēng)險來(lái)繼續使用這個(gè)迭代器。

itertools 模塊?

itertools 模塊包含很多常用的迭代器以及用來(lái)組合迭代器的函數。本節會(huì )用些小的例子來(lái)介紹這個(gè)模塊的內容。

這個(gè)模塊里的函數大致可以分為幾類(lèi)：

• 從已有的迭代器創(chuàng )建新的迭代器的函數。

• 接受迭代器元素作為參數的函數。

• 選取部分迭代器輸出的函數。

• 給迭代器輸出分組的函數。

itertools.count() =>
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...
itertools.count(10) =>
  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ...
itertools.count(10, 5) =>
  10, 15, 20, 25, 30, 35, 40, 45, 50, 55, ...

itertools.cycle([1, 2, 3, 4, 5]) =>
  1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...

itertools.repeat('abc') =>
  abc, abc, abc, abc, abc, abc, abc, abc, abc, abc, ...
itertools.repeat('abc', 5) =>
  abc, abc, abc, abc, abc

itertools.chain(['a', 'b', 'c'], (1, 2, 3)) =>
  a, b, c, 1, 2, 3

itertools.islice(range(10), 8) =>
  0, 1, 2, 3, 4, 5, 6, 7
itertools.islice(range(10), 2, 8) =>
  2, 3, 4, 5, 6, 7
itertools.islice(range(10), 2, 8, 2) =>
  2, 4, 6

itertools.tee( itertools.count() ) =>
   iterA, iterB

where iterA ->
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...

and   iterB ->
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...

itertools.starmap(os.path.join,
                  [('/bin', 'python'), ('/usr', 'bin', 'java'),
                   ('/usr', 'bin', 'perl'), ('/usr', 'bin', 'ruby')])
=>
  /bin/python, /usr/bin/java, /usr/bin/perl, /usr/bin/ruby

itertools.filterfalse(is_even, itertools.count()) =>
  1, 3, 5, 7, 9, 11, 13, 15, ...

def less_than_10(x):
    return x < 10

itertools.takewhile(less_than_10, itertools.count()) =>
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9

itertools.takewhile(is_even, itertools.count()) =>
  0

itertools.dropwhile(less_than_10, itertools.count()) =>
  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ...

itertools.dropwhile(is_even, itertools.count()) =>
  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...

itertools.compress([1, 2, 3, 4, 5], [True, True, False, False, True]) =>
   1, 2, 5

itertools.combinations([1, 2, 3, 4, 5], 2) =>
  (1, 2), (1, 3), (1, 4), (1, 5),
  (2, 3), (2, 4), (2, 5),
  (3, 4), (3, 5),
  (4, 5)

itertools.combinations([1, 2, 3, 4, 5], 3) =>
  (1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 3, 4), (1, 3, 5), (1, 4, 5),
  (2, 3, 4), (2, 3, 5), (2, 4, 5),
  (3, 4, 5)

itertools.permutations([1, 2, 3, 4, 5], 2) =>
  (1, 2), (1, 3), (1, 4), (1, 5),
  (2, 1), (2, 3), (2, 4), (2, 5),
  (3, 1), (3, 2), (3, 4), (3, 5),
  (4, 1), (4, 2), (4, 3), (4, 5),
  (5, 1), (5, 2), (5, 3), (5, 4)

itertools.permutations([1, 2, 3, 4, 5]) =>
  (1, 2, 3, 4, 5), (1, 2, 3, 5, 4), (1, 2, 4, 3, 5),
  ...
  (5, 4, 3, 2, 1)

itertools.permutations('aba', 3) =>
  ('a', 'b', 'a'), ('a', 'a', 'b'), ('b', 'a', 'a'),
  ('b', 'a', 'a'), ('a', 'a', 'b'), ('a', 'b', 'a')

itertools.combinations_with_replacement([1, 2, 3, 4, 5], 2) =>
  (1, 1), (1, 2), (1, 3), (1, 4), (1, 5),
  (2, 2), (2, 3), (2, 4), (2, 5),
  (3, 3), (3, 4), (3, 5),
  (4, 4), (4, 5),
  (5, 5)

city_list = [('Decatur', 'AL'), ('Huntsville', 'AL'), ('Selma', 'AL'),
             ('Anchorage', 'AK'), ('Nome', 'AK'),
             ('Flagstaff', 'AZ'), ('Phoenix', 'AZ'), ('Tucson', 'AZ'),
             ...
            ]

def get_state(city_state):
    return city_state[1]

itertools.groupby(city_list, get_state) =>
  ('AL', iterator-1),
  ('AK', iterator-2),
  ('AZ', iterator-3), ...

where
iterator-1 =>
  ('Decatur', 'AL'), ('Huntsville', 'AL'), ('Selma', 'AL')
iterator-2 =>
  ('Anchorage', 'AK'), ('Nome', 'AK')
iterator-3 =>
  ('Flagstaff', 'AZ'), ('Phoenix', 'AZ'), ('Tucson', 'AZ')

functools 模塊?

Python 2.5 中的 functools 模塊包含了一些高階函數。 高階函數 接受一個(gè)或多個(gè)函數作為輸入，返回新的函數。 這個(gè)模塊中最有用的工具是 functools.partial() 函數。

對于用函數式風(fēng)格編寫(xiě)的程序，有時(shí)你會(huì )希望通過(guò)給定部分參數，將已有的函數構變形稱(chēng)新的函數?？紤]一個(gè) Python 函數 f(a, b, c)；你希望創(chuàng )建一個(gè)和 f(1, b, c) 等價(jià)的新函數 g(b, c)；也就是說(shuō)你給定了 f() 的一個(gè)參數的值。這就是所謂的“部分函數應用”。

partial() 接受參數 (function, arg1, arg2, ..., kwarg1=value1, kwarg2=value2)。它會(huì )返回一個(gè)可調用的對象，所以你能夠直接調用這個(gè)結果以使用給定參數的 function。

這里有一個(gè)很小但很現實(shí)的例子:

import functools

def log(message, subsystem):
    """Write the contents of 'message' to the specified subsystem."""
    print('%s: %s' % (subsystem, message))
    ...

server_log = functools.partial(log, subsystem='server')
server_log('Unable to open socket')

functools.reduce(func, iter, [initial_value]) 持續地在可迭代對象的所有元素上執行操作，因此它不能夠用在無(wú)限的可迭代對象上。func 必須是一個(gè)接受兩個(gè)元素并返回一個(gè)值的函數。functools.reduce() 接受迭代器返回的前兩個(gè)元素 A 和 B 并計算 func(A, B) 。然后它會(huì )請求第三個(gè)元素，C，計算 func(func(A, B), C)，然后把這個(gè)結果再和第四個(gè)元素組合并返回，如此繼續下去直到消耗整個(gè)可迭代對象。如果輸入的可迭代對象完全不返回任何值，TypeError 異常就會(huì )拋出。如果提供了初值(initial value)，它會(huì )被用作起始值，也就是先計算 func(initial_value, A) 。:

>>> import operator, functools
>>> functools.reduce(operator.concat, ['A', 'BB', 'C'])
'ABBC'
>>> functools.reduce(operator.concat, [])
Traceback (most recent call last):
  ...
TypeError: reduce() of empty sequence with no initial value
>>> functools.reduce(operator.mul, [1, 2, 3], 1)
6
>>> functools.reduce(operator.mul, [], 1)
1

如果你在 functools.reduce() 中使用 operator.add()，你就會(huì )把可迭代對象中的所有元素加起來(lái).這種情況非常常見(jiàn), 所以 Python 有一個(gè)特殊的內置函數 sum():

>>> import functools, operator
>>> functools.reduce(operator.add, [1, 2, 3, 4], 0)
10
>>> sum([1, 2, 3, 4])
10
>>> sum([])
0

不過(guò), 對于很多使用 functools.reduce() 的情形, 使用明顯的 for 循環(huán)會(huì )更清晰:

import functools
# Instead of:
product = functools.reduce(operator.mul, [1, 2, 3], 1)

# You can write:
product = 1
for i in [1, 2, 3]:
    product *= i

一個(gè)相關(guān)的函數是 itertools.accumulate(iterable, func=operator.add) 。它執行同樣的計算, 不過(guò)相對于只返回最終結果，accumulate() 會(huì )返回一個(gè)迭代器來(lái)輸出所有中間結果:

itertools.accumulate([1, 2, 3, 4, 5]) =>
  1, 3, 6, 10, 15

itertools.accumulate([1, 2, 3, 4, 5], operator.mul) =>
  1, 2, 6, 24, 120

小函數和 lambda 表達式?

編寫(xiě)函數式風(fēng)格程序時(shí)，你會(huì )經(jīng)常需要很小的函數，作為謂詞函數或者以某種方式來(lái)組合元素。

如果合適的 Python 內置的或者其他模塊中的函數，你就一點(diǎn)也不需要定義新的函數:

stripped_lines = [line.strip() for line in lines]
existing_files = filter(os.path.exists, file_list)

如果不存在你需要的函數，你就必須自己編寫(xiě)。一個(gè)編寫(xiě)小函數的方式是使用 lambda 表達式。lambda 接受一組參數以及組合這些參數的表達式，它會(huì )創(chuàng )建一個(gè)返回表達式值的匿名函數:

adder = lambda x, y: x+y

print_assign = lambda name, value: name + '=' + str(value)

另一種替代方案就是通常的使用 def 語(yǔ)句來(lái)定義函數:

def adder(x, y):
    return x + y

def print_assign(name, value):
    return name + '=' + str(value)

哪一種更受青睞呢？這是一個(gè)風(fēng)格問(wèn)題；我通常的做法是避免使用 lambda。

我這么偏好的一個(gè)原因是，lambda 能夠定義的函數非常受限。函數的結果必須能夠作為單獨的表達式來(lái)計算，這意味著(zhù)你不能使用多路 if... elif... else 比較，或者 try... except 語(yǔ)句。如果你嘗試在 lambda 語(yǔ)句中做太多事情，你最終會(huì )把表達式過(guò)于復雜以至于難以閱讀。你能快速的說(shuō)出下面的代碼做了什么事情嗎？:

import functools
total = functools.reduce(lambda a, b: (0, a[1] + b[1]), items)[1]

你可以弄明白，不過(guò)要花上時(shí)間來(lái)理清表達式來(lái)搞清楚發(fā)生了什么。使用一個(gè)簡(jiǎn)短的嵌套的 def 語(yǔ)句可以讓情況變得更好:

import functools
def combine(a, b):
    return 0, a[1] + b[1]

total = functools.reduce(combine, items)[1]

如果我僅僅使用一個(gè) for 循環(huán)會(huì )更好:

total = 0
for a, b in items:
    total += b

或者使用內置的 sum() 和一個(gè)生成器表達式:

total = sum(b for a, b in items)

許多使用 functools.reduce() 的情形可以更清晰地寫(xiě)成 for 循環(huán)的形式。

Fredrik Lundh 曾經(jīng)建議以下一組規則來(lái)重構 lambda 的使用:

1. 寫(xiě)一個(gè) lambda 函數。

2. 寫(xiě)一句注釋來(lái)說(shuō)明這個(gè) lambda 究竟干了什么。

3. 研究一會(huì )這個(gè)注釋?zhuān)缓笙氤鲆粋€(gè)抓住注釋本質(zhì)的名字。

4. 用這個(gè)名字，把這個(gè) lambda 改寫(xiě)成 def 語(yǔ)句。

5. 把注釋去掉。

我非常喜歡這些規則，不過(guò)你完全有權利爭辯這種消除 lambda 的風(fēng)格是不是更好。

修訂記錄和致謝?

作者要感謝以下人員對本文各種草稿給予的建議，更正和協(xié)助：Ian Bicking,Nick Coghlan, Nick Efford, Raymond Hettinger, Jim Jewett, Mike Krell,Leandro Lameiro, Jussi Salmela, Collin Winter, Blake Winton。

0.1 版: 2006 年 6 月 30 日發(fā)布。

0.11 版: 2006 年 7 月 1 日發(fā)布。 修正拼寫(xiě)錯誤。

0.2 版: 2006 年 7 月 10 日發(fā)布。 將 genexp 與 listcomp 兩節合二為一。 修正拼寫(xiě)錯誤。

0.21 版: 加入了 tutor 郵件列表中建議的更多參考文件。

0.30 版: 添加了有關(guān) functional 模塊的小節，由 Collin Winter 撰寫(xiě)；添加了有關(guān) operator 模塊的簡(jiǎn)短小節；其他少量修改。

參考文獻?