Python 迭代器、生成器和列表解析

摘要： 迭代器 迭代器在 Python 2.2 版本中被加入, 它為類序列物件提供了一個類序列的介面。 Python 的迭代無縫地支援序列物件, 而且它還允許迭代非序列型別, 包括使用者定義的物件。即迭代器可以迭代不是序列但表現出序列行為的物件, 例如字典的 key , 一個檔案的行, 等等。迭代...

迭代器

迭代器在 Python 2.2 版本中被加入, 它為類序列物件提供了一個類序列的介面。 Python 的迭代無縫地支援序列物件, 而且它還允許迭代非序列型別, 包括使用者定義的物件。即迭代器可以迭代不是序列但表現出序列行為的物件, 例如字典的 key , 一個檔案的行, 等等。迭代器有以下特性：

• 提供了可擴充套件的迭代器介面.
• 對列表迭代帶來了效能上的增強.
• 在字典迭代中效能提升.
• 建立真正的迭代介面, 而不是原來的隨機物件訪問.
• 與所有已經存在的使用者定義的類以及擴充套件的模擬序列和對映的物件向後相容
• 迭代非序列集合(例如對映和檔案)時, 可以建立更簡潔可讀的程式碼.

迭代器物件即實現了迭代器協議的物件，在 Python 中，支援迭代器協議就是實現物件的__iter__() 和next() 方法（注：在 Python3 中被改為next 方法）。其中 __iter__() 方法返回迭代器物件本身；next() 方法返回容器的下一個元素，在結尾時引發StopIteration 異常。

迭代器協議

迭代器協議即實現__iter__() 與next() 方法。這兩個方法是迭代器最基本的方法，一個用來獲得迭代器物件，一個用來獲取容器中的下一個元素。對於可迭代物件，可以使用內建函式iter() 來獲取它的迭代器物件：

li = [1, 2]
it = iter(li)
print it

print it.next()
print it.next()
print it.next()

結果如下所示:

<listiterator object at 0xb708aa6c>
1
2
Traceback (most recent call last):
File "iter.py", line 21, in <module>
print it.next()
StopIteration

列表（list）本身是可迭代的，通過 iter() 方法可以獲得其迭代器物件，然後就可以通過 next() 方法來訪問 list 中的元素。當容器中沒有可以訪問的元素時， next() 方法將會丟擲一個StopIteration 的異常，從而終止迭代器。當我們使用 for 語句的時候，for 語句就會自動的通過 __iter__() 方法來獲得迭代器物件，並且通過 next() 方法來獲取下一個元素，遇到StopIteration 異常時會自動結束迭代。

自定義迭代器

自己建立迭代器實際上就是實現一個帶有 __iter__() 方法和 next() 方法的類，用該類建立的例項即是可迭代物件。例如我們用迭代器來實現斐波那契數列：

class Fibs:
def __init__(self):
self.a = 0
self.b = 1

def next(self):
self.a, self.b = self.b, self.a + self.b
return self.a

def __iter__(self):
return self

fibs = Fibs()// 這將得到一個無窮的數列
for f in fibs:
if f > 1000:
print f
break
else:
print f

這裡有一個問題，大多數的序列或者類序列都不是無窮的，所以在達到一定條件後就該終止。因此我們需要在序列或者類序列需要結束時引發StopIteration 異常：

class MyRange(object):
def __init__(self, n):
self.idx = 0
self.n = n

def __iter__(self):
return self

def next(self):
if self.idx < self.n:
val = self.idx
self.idx += 1
return val
else:
raise StopIteration()

myRange = MyRange(3)
for i in myRange:
print i

可迭代物件和迭代器物件

可迭代物件即具有 __iter__() 方法的物件，該方法可獲取其迭代器物件。迭代器物件即具有next() 方法的物件。也就是說，一個實現了 __iter_() 的物件是可迭代的，一個實現了 next() 方法的物件則是迭代器。可迭代物件也可以是迭代器物件，如檔案物件。此時可迭代物件自己有 next() 方法，而其 __iter () 方法返回的就是它自己。對於許多內建物件及其派生物件，如 list、dict 等，由於需要支援多次開啟迭代器，因此自己並非迭代器物件，需要用 __iter _() 方法返回其迭代器物件，並用迭代器物件來訪問其它元素。

以上例子中的 myRange 這個物件就是一個可迭代物件，同時它本身也是一個迭代器物件。對於一個可迭代物件，如果它本身又是一個迭代器物件，就會有這樣一個問題，其沒有辦法支援多次迭代。如下所示：

myRange = MyRange(3)
print myRange is iter(myRange)

print [i for i in myRange]
print [i for i in myRange]

執行結果：

True
[0, 1, 2]
[]

為了解決上面的問題，可以分別定義可迭代型別物件和迭代器型別物件；然後可迭代型別物件的 __iter__() 方法可以獲得一個迭代器型別的物件。如下所示：

class Zrange:
def __init__(self, n):
self.n = n

def __iter__(self):
return ZrangeIterator(self.n)

class ZrangeIterator:
def __init__(self, n):
self.i = 0
self.n = n

def __iter__(self):
return self

def next(self):
if self.i < self.n:
i = self.i
self.i += 1
return i
else:
raise StopIteration()

zrange = Zrange(3)
print zrange is iter(zrange)

print [i for i in zrange]
print [i for i in zrange]

執行結果：

False
[0, 1, 2]
[0, 1, 2]

另外，reversed() 內建函式將返回一個反序訪問的迭代器，enumerate() 內建函式同樣也返回迭代器。例如可以用 enumerate() 函式遍歷列表:

ll = [1, 2, 3]
print enumerate(ll)

/* 優雅的遍歷列表 */
for i, ele in enumerate(ll):
print i, ll[i]

生成器

迭代器和生成器可能是近幾年引入的最強大的兩個特性。生成器是一種用普通的函式語法定義的迭代器，也就是說生成器實際上就是一個函式。但是生成器不用 return 返回，而是用 yield 一次返回一個結果，在每個結果之間掛起和繼續它們的狀態，來自動實現迭代協議。任何包含 yield 語句的函式稱為生成器。yield 被人們優雅的稱之為語法糖，意思就是包在裡邊的甜心。在 yield 的內部是一個狀態機，維護著掛起和繼續的狀態。

生成器執行流程

先看看下邊的列子：

def Zrange(n):
print "beginning of Zrange"
i = 0
while i < n:
print "before yield", i
yield i
i += 1
print "after yield", i

print "endding of Zrange"

zrange = Zrange(3)
print "------------"

print zrange.next()
print "------------"

print zrange.next()
print "------------"

print zrange.next()
print "------------"

print zrange.next()def flatten(nested):
result = []
try:
# 不要迭代類似字串的物件
try: nested + ""
except TypeError: pass
else: raise TypeError
for sublist in nested:
for element in flatten(sublist):
result.append(element)
except TypeError:
result.append(nested)
return result
print "------------"

執行結果：

--------------------
beginning of Zrange
before yield 0
0
--------------------
after yield 1
before yield 1
1
--------------------
after yield 2
before yield 2
2
--------------------
after yield 3
endding of Zrange
Traceback (most recent call last):
File "one.py", line 38, in <module>
print zrange.next()
StopIteration

通過結果可以看到：

• 當呼叫生成器函式的時候，函式只是返回了一個生成器物件，並沒有 執行。
• 當next()方法第一次被呼叫的時候，生成器函式才開始執行，執行到yield語句處停止
• next()方法的返回值就是yield語句處的引數（yielded value）
• 當繼續呼叫next()方法的時候，函式將接著上一次停止的yield語句處繼續執行，併到下一個yield處停止；如果後面沒有yield就丟擲StopIteration異常

遞迴生成器

生成器可以向函式一樣進行遞迴使用,下面列舉兩個示例：

對一個序列進行全排列：

def permutations(li):
if len(li) == 0:
yield li
else:
for i in range(len(li)):
li[0], li[i] = li[i], li[0] #
for item in permutations(li[1:]):
yield [li[0]] + item

for item in permutations(range(3)):
print item

這裡的實現思路是，每次取序列中不一樣的元素放在最前面，直到只有一個元素時返回，並將返回結果往後拼接。

展開多層巢狀的列表：

def flatten(nested):
try:
# 不要迭代類似於字串的物件
try: nested + ""
except TypeError: pass
else: raise TypeError
for sublist in nested:
for element in flatten(sublist):
yield element
except TypeError:
yield nested

print list(flatten([[[1], 2], 3, 4, [5, [6, 7]], 8]))

這裡需要注意的是，不應該在 flatten 函式中對類似於字串的物件進行迭代，這樣會導致無窮遞迴，因為一個字串的第一個元素是另一個長度為1的字串，而長度為一個字串的第一個元素就是字串本身。

通用生成器

生成器可以人為是由兩部分組成：生成器的函式和生成器的迭代器。生成器的函式是用 def 語句定義的，包含 yield 部分，生成器的迭代器是這個函式返回的部分。按照一種不是很準確的說法，兩個實體經常被當做一個，合起來叫做生成器。如下例項所示：

def simple_generator():
yield 1

print simple_generator
print simple_generator()

執行結果：

<function simple_generator at 0xb743d79c>
<generator object simple_generator at 0xb71c7be4>

生成器方法

• send(value)

外部作用域訪問生成器的 send 方法，就像訪問 next() 方法一樣。next()方法可以恢復生成器狀態並繼續執行，其實 send() 是除 next() 外另一個恢復生成器的方法。Python 2.5 中，yield 語句變成了 yield 表示式，也就是說 yield 可以有一個值，而這個值就是send()方法的引數，所以 send(None) 和 next() 是等效的。同樣，next()和send()的返回值都是 yield語 句處的引數（yielded value）。使用 send() 方法只有在生成器掛起之後才有意義，如果真想對剛剛啟動的生成器使用 send 方法，則可以將 None 作為引數進行呼叫。也就是說，第一次呼叫時，要使用 next() 語句或 send(None)，因為沒有 yield 語句來接收這個值 。

• throw()

用於在生成器內引發一個異常。

• close()

用於停止生成器，呼叫它時，會在 yield 執行出引發一個 GeneratorExit 異常。

使用示例：

def Zrange(n):
i = 0
while i < n:
val = yield i
print "val is", val
i += 1

zrange = Zrange(5)

print zrange.next()
print zrange.next()
print zrange.send("hello")
print zrange.next()
#print zrange.next()

zrange.close()

print zrange.send("world")

模擬生成器

在舊的 Python 版本中並不支援生成器，那麼我們可以用普通的函式來模擬生成器。如下所示：

def flatten(nested):
result = []
try:
# 不要迭代類似字串的物件
try: nested + ""
except TypeError: pass
else: raise TypeError
for sublist in nested:
for element in flatten(sublist):
result.append(element)
except TypeError:
result.append(nested)
return result

儘管這個版本可能不適用於所有的生成器，但對大多數生成器來說是可行的。比如，它不適用於一個無限的生成器。

列表解析和生成器表示式

列表解析

列表解析( List comprehensions, 或縮略為 list comps ) 來自函數語言程式設計語言 Haskell . 它是一個非常有用, 簡單, 而且靈活的工具, 可以用來動態地建立列表。其語法結構為：

[expr for iter_var in iterable]

這個語句的核心是 for 迴圈, 它迭代 iterable 物件的所有條目. 前邊的 expr 應用於序列的每個成員, 最後的結果值是該表示式產生的列表。 迭代變數並不需要是表示式的一部分。例如用 lambda 函式計算序列成員的平方的表達是為：

map(lambda x: x ** 2, range(6))

這可以用列表解析來改寫：

[x ** 2 for x in range(6)]

列表解析的表示式可以取代內建的 map() 函式以及 lambda , 而且效率更高。結合 if 語句，列表解析還提供了一個擴充套件版本的語法：

[expr for iter_var in iterable if cond_expr]

這個語法在迭代時會過濾/捕獲滿足條件表示式 cond_expr 的序列成員。例如挑選出序列中的奇數可以用下邊的方法:

[x for x in seq if x % 2]

列表解析還有很多巧妙的應用：

迭代一個有三行五列的矩陣:

[(x+1,y+1) for x in range(3) for y in range(5)]

計算出所有非空白字元的數目:

len([word for line in f for word in line.split()])

生成器表示式

生成器表示式是列表解析的一個擴充套件。列表解析的一個不足就是必要生成所有的資料, 用以建立整個列表。這可能對有大量資料的迭代器有負面效應。生成器表示式通過結合列表解析和生成器解決了這個問題。生成器表示式在 Python 2.4 被引入, 它與列表解析非常相似，而且它們的基本語法基本相同; 不過它並不真正建立數字列表, 而是返回一個生成器 ，這個生成器在每次計算出一個條目後，把這個條目“產生”(yield)出來。生成器表示式使用了"延遲計算"(lazy evaluation), 所以它在使用記憶體上更有效。生成器表示式語法:

(expr for iter_var in iterable if cond_expr)

生成器並不會讓列表解析廢棄, 它只是一個記憶體使用更友好的結構, 基於此, 有很多使用生 成器地方，如下所示：

快速地計算檔案大小:

上面我們用列表解析計算出了檔案中非空白字元的數目，那麼只要用 sum() 函式對每個單詞的長度求和，則可大致計算出檔案的大小。sum() 函式的引數不僅可以是列表，還可以是可迭代物件,比如生成器表示式。這裡我們用生成器表示式改寫整個過程：

sum(len(word) for line in data for word in line.split())

交叉配對：

生成器表示式就好像是懶惰的列表解析(這反而成了它主要的優勢)。它還可以用來處理其他列表或生成器：

rows = [1, 2, 3, 17]

def cols(): # example of simple generator
yield 56
yield 2
yield 1

x_product_pairs = ((i, j) for i in rows for j in cols())

for pair in x_product_pairs:
print pair

尋找檔案最長的行：

def longest(filename):
glines = (x.strip() for x in open(filename))
return max([len(l) for l in glines])

# Script starts from here

if __name__ == "__main__":
print longest("/etc/hosts")

這個例子摘自 《Python核心程式設計》 中生成器表示式一節，作者在原書中只用了一行程式碼來實現這個功能，即：

return max(len(x.strip()) for x in open('/etc/motd'))

這行程式碼會報出如下錯誤：

TypeError: object of type 'generator' has no len()

也就是說生成器沒有 len() 方法，所以這樣並不可行，但是用列表解析則可以用一行實現：

return max([len(x.strip()) for x in open("/etc/motd")])