Python函數式編程指南（三）：迭代器詳解

 　　這篇文章主要介紹了Python函數式編程指南(三)：迭代器詳解,本文講解了迭代器(Iterator)概述、使用迭代器、產生器運算式(Generator expression)和列表解析(List Comprehension)等內容,需要的朋友可以參考下

　　3. 迭代器

　　3.1. 迭代器(Iterator)概述

　　迭代器是訪問集合內元素的一種方式。迭代器對象從集合的第一個元素開始訪問，直到所有的元素都被訪問一遍後結束。

　　迭代器不能回退，只能往前進行迭代。這並不是什麼很大的缺點，因為人們幾乎不需要在迭代途中進行後援動作。

　　迭代器也不是安全執行緒的，在多線程環境中對可變集合使用迭代器是一個危險的操作。但如果小心謹慎，或者乾脆貫徹函數式思想堅持使用不可變的集合，那這也不是什麼大問題。

　　對於原生支援隨機訪問的資料結構(如tuple、list)，迭代器和經典for迴圈的索引訪問相比並無優勢，反而丟失了索引值(可以使用內建函數enumerate()找回這個索引值，這是後話)。但對於無法隨機訪問的資料結構(比如set)而言，迭代器是唯一的訪問元素的方式。

　　迭代器的另一個優點就是它不要求你事先準備好整個迭代過程中所有的元素。迭代器僅僅在迭代至某個元素時才計算該元素，而在這之前或之後，元素可以不存在或者被銷毀。這個特點使得它特別適合用於遍曆一些巨大的或是無限的集合，比如幾個G的檔案，或是斐波那契數列等等。這個特點被稱為延遲計算或惰性求值(Lazy evaluation)。

　　迭代器更大的功勞是提供了一個統一的訪問集合的介面。只要是實現了__iter__()方法的對象，就可以使用迭代器進行訪問。

　　3.2. 使用迭代器

　　使用內建的工廠函數iter(iterable)可以擷取迭代器對象：

　　 代碼如下:

　　>>> lst = range(2)

　　>>> it = iter(lst)

　　>>> it

　　使用迭代器的next()方法可以訪問下一個元素：

　　代碼如下:

　　>>> it.next()

　　0

　　如果是Python 2.6+，還有內建函數next(iterator)可以完成這一功能：

　　 代碼如下:

　　>>> next(it)

　　1

　　如何判斷迭代器還有更多的元素可以訪問呢?Python裡的迭代器並沒有提供類似has_next()這樣的方法。

　　那麼在這個例子中，我們已經訪問到了最後一個元素1，再使用next()方法會怎樣呢?

　　 代碼如下:

　　>>> it.next()

　　Traceback (most recent call last):

　　File "", line 1, in

　　StopIteration

　　Python遇到這樣的情況時將會拋出StopIteration異常。事實上，Python正是根據是否檢查到這個異常來決定是否停止迭代的。

　　這種做法與迭代前手動檢查是否越界相比各有優點。但Python的做法總有一些利用異常進行流程式控制制的嫌疑。

　　瞭解了這些情況以後，我們就能使用迭代器進行遍曆了。

　　代碼如下:

　　it = iter(lst)

　　try:

　　while True:

　　val = it.next()

　　print val

　　except StopIteration:

　　pass

　　實際上，因為迭代操作如此普遍，Python專門將關鍵字for用作了迭代器的文法糖。在for迴圈中，Python將自動調用工廠函數iter()獲得迭代器，自動調用next()擷取元素，還完成了檢查StopIteration異常的工作。上述代碼可以寫成如下的形式，你一定非常熟悉：

　　 代碼如下:

　　for val in lst:

　　print val

　　首先Python將對關鍵字in後的對象調用iter函數擷取迭代器，然後調用迭代器的next方法擷取元素，直到拋出StopIteration異常。對迭代器調用iter函數時將返回迭代器自身，所以迭代器也可以用於for語句中，不需要特殊處理。

　　常用的幾個內建資料結構tuple、list、set、dict都支援迭代器，字串也可以使用迭代操作。你也可以自己實現一個迭代器，如上所述，只需要在類的__iter__方法中返回一個對象，這個對象擁有一個next()方法，這個方法能在恰當的時候拋出StopIteration異常即可。但是需要自己實現迭代器的時候不多，即使需要，使用產生器會更輕鬆。下一篇我們將討論產生器的部分。

　　*異常並不是非拋出不可的，不拋出該異常的迭代器將進行無限迭代，某些情況下這樣的迭代器很有用。這種情況下，你需要自己判斷元素並中止，否則就死迴圈了!

　　使用迭代器的迴圈可以避開索引，但有時候我們還是需要索引來進行一些操作的。這時候內建函數enumerate就派上用場咯，它能在iter函數的結果前加上索引，以元組返回，用起來就像這樣：

　　 代碼如下:

　　for idx, ele in enumerate(lst):

　　print idx, ele

　　3.3. 產生器運算式(Generator expression)和列表解析(List Comprehension)

　　絕大多數情況下，遍曆一個集合都是為了對元素應用某個動作或是進行篩選。如果看過本文的第二部分，你應該還記得有內建函數map和filter提供了這些功能，但Python仍然為這些操作提供了語言級的支援。

　　 代碼如下:

　　(x+1 for x in lst) #產生器運算式，返回迭代器。外部的括弧可在用於參數時省略。

　　[x+1 for x in lst] #列表解析，返回list

　　如你所見，產生器運算式和列表解析(註：這裡的翻譯有很多種，比如列表展開、列表推導等等，指的是同一個意思)的區別很小，所以人們提到這個特性時，簡單起見往往只描述成列表解析。然而由於返回迭代器時，並不是在一開始就計算所有的元素，這樣能得到更多的靈活性並且可以避開很多不必要的計算，所以除非你明確希望返回列表，否則應該始終使用產生器運算式。接下來的文字裡我就不區分這兩種形式了：)

　　你也可以為列表解析提供if子句進行篩選：

　　 代碼如下:

　　(x+1 for x in lst if x!=0)

　　或者提供多條for子句進行嵌套迴圈，嵌套次序就是for子句的順序：

　　 代碼如下:

　　((x, y) for x in range(3) for y in range(x))

　　列表解析就是鮮明的Pythonic。我常遇到兩個使用列表解析的問題，本應歸屬於最佳實務，但這兩個問題非常典型，所以不妨在這裡提一下：

　　第一個問題是，因為對元素應用的動作太複雜，不能用一個運算式寫出來，所以不使用列表解析。這是典型的思想沒有轉變的例子，如果我們將動作封裝成函數，那不就是一個運算式了麼?

　　第二個問題是，因為if子句裡的條件需要計算，同時結果也需要進行同樣的計算，不希望計算兩遍，就像這樣：

　　 代碼如下:

　　(x.doSomething() for x in lst if x.doSomething()>0)

　　這樣寫確實很糟糕，但組合一下列表解析即可解決：

　　 代碼如下:

　　(x for x in (y.doSomething() for y in lst) if x>0)

　　內部的列表解析變數其實也可以用x，但為清晰起見我們改成了y。或者更清楚的，可以寫成兩個運算式：

　　代碼如下:

　　tmp = (x.doSomething() for x in lst)

　　(x for x in tmp if x > 0)

　　列表解析可以替代絕大多數需要用到map和filter的場合，可能正因為此，著名的靜態檢查工具pylint將map和filter的使用列為了警告。

　　3.4. 相關的庫

　　Python內建了一個模組itertools，包含了很多函數用於creating iterators for efficient looping(建立更有效率的迴圈迭代器)，這說明很是霸氣，這一小節就來瀏覽一遍這些函數並留下印象吧，需要這些功能的時候隱約記得這裡面有就好。這一小節的內容翻譯自itertools模組官方文檔。

　　3.4.1. 無限迭代

　　count(start, [step])

　　從start開始，以後每個元素都加上step。step預設值為1。

　　count(10) --> 10 11 12 13 14 ...

　　cycle(p)

　　迭代至序列p的最後一個元素後，從p的第一個元素重新開始。

　　cycle('ABCD') --> A B C D A B C D ...

　　repeat(elem [,n])

　　將elem重複n次。如果不指定n，則無限重複。

　　repeat(10, 3) --> 10 10 10

　　3.4.2. 在最短的序列參數終止時停止迭代

　　chain(p, q, ...)

　　迭代至序列p的最後一個元素後，從q的第一個元素開始，直到所有序列終止。

　　chain('ABC', 'DEF') --> A B C D E F

　　compress(data, selectors)

　　如果bool(selectors[n])為True，則next()返回data[n]，否則跳過data[n]。

　　compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F

　　dropwhile(pred, seq)

　　當pred對seq[n]的調用返回False時才開始迭代。

　　dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1

　　takewhile(pred, seq)

　　dropwhile的相反版本。

　　takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4

　　ifilter(pred, seq)

　　內建函數filter的迭代器版本。

　　ifilter(lambda x: x%2, range(10)) --> 1 3 5 7 9

　　ifilterfalse(pred, seq)

　　ifilter的相反版本。

　　ifilterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8

　　imap(func, p, q, ...)

　　內建函數map的迭代器版本。

　　imap(pow, (2,3,10), (5,2,3)) --> 32 9 1000

　　starmap(func, seq)

　　將seq的每個元素以變長參數(*args)的形式調用func。

　　starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000

　　izip(p, q, ...)

　　內建函數zip的迭代器版本。

　　izip('ABCD', 'xy') --> Ax By

　　izip_longest(p, q, ..., fillvalue=None)

　　izip的取最長序列的版本，短序列將填入fillvalue。

　　izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-

　　tee(it, n)

　　返回n個迭代器it的複製迭代器。

　　groupby(iterable[, keyfunc])

　　這個函數功能類似於SQL的分組。使用groupby前，首先需要使用相同的keyfunc對iterable進行排序，比如調用內建的sorted函數。然後，groupby返回迭代器，每次迭代的元素是元組(key值, iterable中具有相同key值的元素的集合的子迭代器)。或許看看Python的排序指南對理解這個函數有協助。

　　groupby([0, 0, 0, 1, 1, 1, 2, 2, 2]) --> (0, (0 0 0)) (1, (1 1 1)) (2, (2 2 2))

　　3.4.3. 組合迭代器

　　product(p, q, ... [repeat=1])

　　笛卡爾積。

　　product('ABCD', repeat=2) --> AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD

　　permutations(p[, r])

　　去除重複的元素。

　　permutations('ABCD', 2) --> AB AC AD BA BC BD CA CB CD DA DB DC

　　combinations(p, r)

　　排序後去除重複的元素。

　　combinations('ABCD', 2) --> AB AC AD BC BD CD

　　combinations_with_replacement()

　　排序後，包含重複元素。

　　combinations_with_replacement('ABCD', 2) --> AA AB AC AD BB BC BD CC CD DD

　　此篇結束。