一些語言的設(shè)計者選擇強調(diào)一種特定的編程方式。 這通常會讓以不同的方式來編寫程序變得困難。其他多范式語言則支持幾種不同的編程方式。Lisp，C++ 和 Python 都是多范式語言；使用這些語言，你可以編寫主要為過程式，面向?qū)ο蠡蛘吆瘮?shù)式的程序和函數(shù)庫。在大型程序中，不同的部分可能會采用不同的方式編寫；比如 GUI 可能是面向?qū)ο蟮亩幚磉壿媱t是過程式或者函數(shù)式。

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

有些語言對純潔性要求非常嚴格，甚至沒有諸如``a=3``或``c = a + b``之類的賦值語句，但很難避免所有的副作用，如打印到屏幕上或?qū)懙酱疟P文件之類的副作用。另一個例子是調(diào)用 print() 或 time.sleep() 函數(shù)，它們都沒有返回一個有用的值。這兩個函數(shù)被調(diào)用只是為了它們的副作用，即向屏幕發(fā)送一些文本或暫停執(zhí)行一秒鐘。

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

函數(shù)式編程可以被認為是面向?qū)ο缶幊痰膶α⒚妗ο缶拖袷穷w小膠囊，包裹著內(nèi)部狀態(tài)和隨之而來的能讓你修改這個內(nèi)部狀態(tài)的一組調(diào)用方法，以及由正確的狀態(tài)變化所構(gòu)成的程序。函數(shù)式編程希望盡可能地消除狀態(tài)變化，只和流經(jīng)函數(shù)的數(shù)據(jù)打交道。在 Python 里你可以把兩種編程方式結(jié)合起來，在你的應(yīng)用（電子郵件信息，事務(wù)處理）中編寫接受和返回對象實例的函數(shù)。

函數(shù)式設(shè)計在工作中看起來是個奇怪的約束。為什么你要消除對象和副作用呢？不過函數(shù)式風格有其理論和實踐上的優(yōu)點：

• 形式證明。

• 模塊化。

• 組合性。

• 易于調(diào)試和測試。

形式證明

一個理論上的優(yōu)點是，構(gòu)造數(shù)學證明來說明函數(shù)式程序是正確的相對更容易些。

很長時間，研究者們對尋找證明程序正確的數(shù)學方法都很感興趣。這和通過大量輸入來測試，并得出程序的輸出基本正確，或者閱讀一個程序的源代碼然后得出代碼看起來沒問題不同；相反，這里的目標是一個嚴格的證明，證明程序?qū)λ锌赡艿妮斎攵寄芙o出正確的結(jié)果。

證明程序正確性所用到的技術(shù)是寫出 不變量，也就是對于輸入數(shù)據(jù)和程序中的變量永遠為真的特性。然后對每行代碼，你說明這行代碼執(zhí)行前的不變量 X 和 Y 以及執(zhí)行后稍有不同的不變量 X’ 和 Y’ 為真。如此一直到程序結(jié)束，這時候在程序的輸出上，不變量應(yīng)該會與期望的狀態(tài)一致。

函數(shù)式編程之所以要消除賦值，是因為賦值在這個技術(shù)中難以處理；賦值可能會破壞賦值前為真的不變量，卻并不產(chǎn)生任何可以傳遞下去的新的不變量。

不幸的是，證明程序的正確性很大程度上是經(jīng)驗性質(zhì)的，而且和 Python 軟件無關(guān)。即使是微不足道的程序都需要幾頁長的證明；一個中等復(fù)雜的程序的正確性證明會非常龐大，而且，極少甚至沒有你日常所使用的程序（Python 解釋器，XML 解析器，瀏覽器）的正確性能夠被證明。即使你寫出或者生成一個證明，驗證證明也會是一個問題；里面可能出了差錯，而你錯誤地相信你證明了程序的正確性。

模塊化

函數(shù)式編程的一個更實用的優(yōu)點是，它強制你把問題分解成小的方面。因此程序會更加模塊化。相對于一個進行了復(fù)雜變換的大型函數(shù)，一個小的函數(shù)更明確，更易于編寫, 也更易于閱讀和檢查錯誤。

易于調(diào)試和測試

測試和調(diào)試函數(shù)式程序相對來說更容易。

調(diào)試很簡單是因為函數(shù)通常都很小而且清晰明確。當程序無法工作的時候，每個函數(shù)都是一個可以檢查數(shù)據(jù)是否正確的接入點。你可以通過查看中間輸入和輸出迅速找到出錯的函數(shù)。

測試更容易是因為每個函數(shù)都是單元測試的潛在目標。在執(zhí)行測試前，函數(shù)并不依賴于需要重現(xiàn)的系統(tǒng)狀態(tài)；相反，你只需要給出正確的輸入，然后檢查輸出是否和期望的結(jié)果一致。

組合性

當你編寫函數(shù)式風格的程序時，你會寫出很多帶有不同輸入和輸出的函數(shù)。其中一些不可避免地會局限于特定的應(yīng)用，但其他的卻可以廣泛的用在程序中。舉例來說，一個接受文件夾目錄返回所有文件夾中的 XML 文件的函數(shù)； 或是一個接受文件名，然后返回文件內(nèi)容的函數(shù)，都可以應(yīng)用在很多不同的場合。

久而久之你會形成一個個人工具庫。通常你可以重新組織已有的函數(shù)來組成新的程序，然后為當前的工作寫一些特殊的函數(shù)。

迭代器

我會從 Python 的一個語言特性， 編寫函數(shù)式風格程序的重要基石開始說起：迭代器。

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

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

你可以手動試驗迭代器的接口。

 
 
 
 

  
  
  
  
>>> 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 "", line 1, in 
  
  
  
  
StopIteration
  
  
  
  
>>>
 
 
 
 

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

 
 
 
 

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

  
  
  
  
for i in obj:
  
  
  
  
 print(i)
 
 
 
 

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

 
 
 
 

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

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

 
 
 
 

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

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

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

支持迭代器的數(shù)據(jù)類型

我們已經(jīng)知道列表和元組支持迭代器。實際上，Python 中的任何序列類型，比如字符串，都自動支持創(chuàng)建迭代器。

對字典調(diào)用 iter() 會返回一個遍歷字典的鍵的迭代器:

 
 
 
 

  
  
  
  
>>> 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
 
 
 
 

注意從 Python 3.7 開始，字典的遍歷順序一定和輸入順序一樣。先前的版本并沒有明確這一點，所以不同的實現(xiàn)可能不一致。

對字典使用 iter() 總是會遍歷鍵，但字典也有返回其他迭代器的方法。如果你只遍歷值或者鍵/值對，你可以明確地調(diào)用 values() 或 items() 方法得到合適的迭代器。

dict() 構(gòu)造函數(shù)可以接受一個迭代器，然后返回一個有限的 (key, value) 元組的數(shù)據(jù)流:

 
 
 
 

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

文件也可以通過調(diào)用 readline() 來遍歷，直到窮盡文件中所有的行。這意味著你可以像這樣讀取文件中的每一行:

 
 
 
 

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

集合可以從可遍歷的對象獲取內(nèi)容，也可以讓你遍歷集合的元素:

 
 
 
 

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

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

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

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

 
 
 
 

  
  
  
  
>>> line_list = [' line 1\n', 'line 2 \n', ' \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]
 
 
 
 

你可以加上條件語句 "if" 來選取特定的元素:

 
 
 
 

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

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

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

 
 
 
 

  
  
  
  
( 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 )
 
 
 
 

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

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

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

 
 
 
 

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

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

換句話說，列表推導式器是和下面的 Python 代碼等價:

 
 
 
 

  
  
  
  
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.
 
 
 
 

這說明，如果有多個 for...in 語句而沒有 if 語句，輸出結(jié)果的長度就是所有序列長度的乘積。如果你的兩個列表長度為3，那么輸出的列表長度就是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 語法變得含糊，如果 expression 會生成元組，那這個元組必須要用括號括起來。下面第一個列表推導式語法錯誤，第二個則是正確的:

 
 
 
 

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

生成器

生成器是一類用來簡化編寫迭代器工作的特殊函數(shù)。普通的函數(shù)計算并返回一個值，而生成器返回一個能返回數(shù)據(jù)流的迭代器。

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

這里有簡單的生成器函數(shù)示例:

 
 
 
 

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

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

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

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

 
 
 
 

  
  
  
  
>>> gen = generate_ints(3)
  
  
  
  
>>> gen 
  
  
  
  

  
  
  
  
>>> next(gen)
  
  
  
  
0
  
  
  
  
>>> next(gen)
  
  
  
  
1
  
  
  
  
>>> next(gen)
  
  
  
  
2
  
  
  
  
>>> next(gen)
  
  
  
  
Traceback (most recent call last):
  
  
  
  
 File "stdin", line 1, in 
  
  
  
  
 File "stdin", line 2, in generate_ints
  
  
  
  
StopIteration
 
 
 
 

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

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

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

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

 
 
 
 

  
  
  
  
# 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
 
 
 
 

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

向生成器傳遞值

在 Python 2.4 及之前的版本中，生成器只產(chǎn)生輸出。一旦調(diào)用生成器的代碼創(chuàng)建一個迭代器，就沒有辦法在函數(shù)恢復(fù)執(zhí)行的時候向它傳遞新的信息。你可以設(shè)法實現(xiàn)這個功能，讓生成器引用一個全局變量或者一個調(diào)用者可以修改的可變對象，但是這些方法都很繁雜。

在 Python 2.5 里有一個簡單的將值傳遞給生成器的方法。yield 變成了一個表達式，返回一個可以賦給變量或執(zhí)行操作的值:

 
 
 
 

  
  
  
  
val = (yield i)
 
 
 
 

我建議你在處理 yield 表達式返回值的時候， 總是 兩邊寫上括號，就像上面的例子一樣。括號并不總是必須的，但是比起記住什么時候需要括號，寫出來會更容易一點。

（PEP 342 解釋了具體的規(guī)則，也就是 yield 表達式必須括起來，除非是出現(xiàn)在最頂級的賦值表達式的右邊。這意味著你可以寫 val = yield i，但是必須在操作的時候加上括號，就像``val = (yield i) + 12``）

可以調(diào)用 send(value)() 方法向生成器發(fā)送值。這個方法會恢復(fù)執(zhí)行生成器的代碼，然后 yield 表達式返回特定的值。如果調(diào)用普通的 __next__`方法，``yield`() 會返回 None.

這里有一個簡單的每次加1的計數(shù)器，并允許改變內(nèi)部計數(shù)器的值。

 
 
 
 

  
  
  
  
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
 
 
 
 

這是改變計數(shù)器的一個示例

 
 
 
 

  
  
  
  
>>> 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 
  
  
  
  
 it.next()
  
  
  
  
StopIteration
 
 
 
 

因為 yield 很多時候會返回 None，所以你應(yīng)該總是檢查這個情況。不要在表達式中使用 yield 的值，除非你確定 send() 是唯一的用來恢復(fù)你的生成器函數(shù)的方法。

除了 send() 之外，生成器還有兩個其他的方法:

• throw(value) 用于在生成器內(nèi)部拋出異常；這個異常會在生成器暫停執(zhí)行的時候由 yield 表達式拋出。

• generator.close() 會在生成器內(nèi)部拋出 GeneratorExit 異常來結(jié)束迭代。當接收到這個異常時，生成器的代碼會拋出 GeneratorExit 或者 StopIteration；捕捉這個異常作其他處理是非法的，并會出發(fā) RuntimeError。close() 也會在 Python 垃圾回收器回收生成器的時候調(diào)用。

  如果你要在 GeneratorExit 發(fā)生的時候清理代碼，我建議使用 try: ... finally: 組合來代替 GeneratorExit。

這些改變的累積效應(yīng)是，讓生成器從單向的信息生產(chǎn)者變成了既是生產(chǎn)者，又是消費者。

生成器也可以成為 協(xié)程 ，一種更廣義的子過程形式。子過程可以從一個地方進入，然后從另一個地方退出（從函數(shù)的頂端進入，從 return 語句退出），而協(xié)程可以進入，退出，然后在很多不同的地方恢復(fù)（yield 語句）。

內(nèi)置函數(shù)

我們可以看看迭代器常常用到的函數(shù)的更多細節(jié)。

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

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

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) 返回一個遍歷序列中滿足指定條件的元素的迭代器，和列表推導式的功能相似。 predicate （謂詞）是一個在特定條件下返回真值的函數(shù)；要使用函數(shù) filter()，謂詞函數(shù)必須只能接受一個參數(shù)。

 
 
 
 

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

 
 
 
 

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

這也可以寫成列表推導式:

 
 
 
 

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

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

 
 
 
 

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

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

 
 
 
 

  
  
  
  
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) 會將 iterable 中的元素收集到一個列表中，然后排序并返回結(jié)果。其中 key 和 reverse 參數(shù)會傳遞給所創(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]
 
 
 
 

（對排序更詳細的討論可參見 排序指南。）

內(nèi)置函數(shù) any(iter) 和 all(iter) 會查看一個可迭代對象內(nèi)容的邏輯值。any() 在可迭代對象中任意一個元素為真時返回 True，而 all() 在所有元素為真時返回 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, …) 從每個可迭代對象中選取單個元素組成列表并返回:

 
 
 
 

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

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

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

 
 
 
 

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

然而，你應(yīng)該避免這種情況，因為所有從更長的迭代器中取出的元素都會被丟棄。這意味著之后你也無法冒著跳過被丟棄元素的風險來繼續(xù)使用這個迭代器。

itertools 模塊

The itertools module contains a number of commonly used iterators as well as functions for combining several iterators. This section will introduce the module’s contents by showing small examples.

這個模塊里的函數(shù)大致可以分為幾類：

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

• 接受迭代器元素作為參數(shù)的函數(shù)。

• 選取部分迭代器輸出的函數(shù)。

• 給迭代器輸出分組的函數(shù)。

創(chuàng)建新的迭代器

itertools.count(start, step) 返回一個等分的無限數(shù)據(jù)流。初始值默認為0，間隔默認為1，你也選擇可以指定初始值和間隔:

 
 
 
 

  
  
  
  
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(iter) 保存一份所提供的可迭代對象的副本，并返回一個能產(chǎn)生整個可迭代對象序列的新迭代器。新迭代器會無限重復(fù)這些元素。:

 
 
 
 

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

itertools.repeat(elem, [n]) 返回 n 次所提供的元素，當 n 不存在時，返回無數(shù)次所提供的元素。

 
 
 
 

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

itertools.chain(iterA, iterB, …) 接受任意數(shù)量的可迭代對象作為輸入，首先返回第一個迭代器的所有元素，然后是第二個的所有元素，如此一直進行下去，直到消耗掉所有輸入的可迭代對象。

 
 
 
 

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

itertools.islice(iter, [start], stop, [step]) 返回一個所輸入的迭代器切片的數(shù)據(jù)流。如果只單獨給定 stop 參數(shù)的話，它會返回從起始算起 stop 個數(shù)量的元素。如果你提供了起始下標 start，你會得到 stop-start 個元素；如果你給定了 step 參數(shù)，數(shù)據(jù)流會跳過相應(yīng)的元素。和 Python 里的字符串和列表切片不同，你不能在 start, stop 或者 step 這些參數(shù)中使用負數(shù)。:

 
 
 
 

  
  
  
  
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(iter, [n]) 可以復(fù)制一個迭代器；它返回 n 個能夠返回源迭代器內(nèi)容的獨立迭代器。如果你不提供參數(shù) n，默認值為 2。復(fù)制迭代器需要保存源迭代器的一部分內(nèi)容，因此在源迭代器比較大的時候會顯著地占用內(nèi)存；同時，在所有新迭代器中，有一個迭代器會比其他迭代器占用更多的內(nèi)存。

 
 
 
 

  
  
  
  
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, ...
 
 
 
 

對元素使用函數(shù)

operator 模塊包含一組對應(yīng)于 Python 操作符的函數(shù)。比如 operator.add(a, b) （把兩個數(shù)加起來），operator.ne(a, b) （和 a != b 相同），以及 operator.attrgetter(‘id’) （返回獲取 .id 屬性的可調(diào)用對象）。

itertools.starmap(func, iter) 假定可迭代對象能夠返回一個元組的流，并且利用這些元組作為參數(shù)來調(diào)用 func:

 
 
 
 

  
  
  
  
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
 
 
 
 

選擇元素

另外一系列函數(shù)根據(jù)謂詞選取一個迭代器中元素的子集。

itertools.filterfalse(predicate, iter) 和 filter() 相反，返回所有讓 predicate 返回 false 的元素:

 
 
 
 

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

                                                當前題目：創(chuàng)新互聯(lián)Python教程：函數(shù)式編程指引                                                

                                                本文鏈接：http://m.5511xx.com/article/cdpdsdo.html