迭代器:初探

上一章曾經(jīng)提到過，其實for循環(huán)是可用于任何可迭代的對象上的。實際上，對Python中所有會從左至右掃描對象的迭代工具而言都是如此，這些迭代工具包括了for循環(huán)、列表解析、in成員關(guān)系測試以及map內(nèi)置函數(shù)等。

“可迭代對象”的概念在Python中是相當(dāng)新穎的，基本這就是序列觀念的通用化:如果對象時實際保存的序列，或者可以再迭代工具環(huán)境中一次產(chǎn)生一個結(jié)果的對象,那就看做是可迭代的。

>>文件迭代器
作為內(nèi)置數(shù)據(jù)類型的文件也是可迭代的，它有一個名為__next__的方法，每次調(diào)用時，就會返回文件中的下一行。當(dāng)?shù)竭_文件末尾時，__next__會引發(fā)內(nèi)置的StopIteration異常，而不是返回空字符串。

這個接口就是Python中所謂的迭代協(xié)議:有__next__方法的對象會前進到下一個結(jié)果，而在一系列結(jié)果的末尾時，則會引發(fā)StopIteration。任何這類對象都認為是可迭代的。任何這類對象也能以for循環(huán)或其他迭代工具遍歷，因為所有迭代工具內(nèi)部工作起來都是在每次迭代中調(diào)用__next__，并且捕捉StopIteratin異常來確定何時離開。

for line in open('script.py'):
 print(line.upper(),end='')

上面的代碼就是文件迭代的一個例子，并且這種用法是最高效的文件讀取方法，主要有三個優(yōu)點:這是最簡單的寫法，運行快，并且從內(nèi)存使用情況來說也是最好的。

替代的寫法是:

for line in open('script.py').readlines():
 print(line.upper(),end='')

這種調(diào)用方法會把文件一次性讀到內(nèi)存中，如果文件太大，那么內(nèi)存會被消耗光的。

>>手動迭代:iter和next
為了支持手動迭代代碼(用較少的錄入)，Python3.0還提供了一個內(nèi)置函數(shù)next，它會自動調(diào)用一個對象的__next__方法。給定一個對象X，調(diào)用next(X)等同于X.__next__()，但前者簡單很多。

從技術(shù)角度來講，迭代協(xié)議還有一點值得注意。當(dāng)for循環(huán)開始時，會通過它傳給iter內(nèi)置函數(shù)，以便從可迭代對象中獲得一個迭代器，返回的對象含有需要的next方法。調(diào)用iter的步驟對于文件來說不是必須的，因為文件對象就是自己的迭代器，但是對于其他的一些內(nèi)置數(shù)據(jù)類型來說，就不一定了。

列表以及很多其他的內(nèi)置對象，不是自身的迭代器，因為它們支持多次打開迭代器。對這樣的對象，我們必須調(diào)用iter來啟動迭代:

L=[1,2,3]
iter(L) is L #return false
L.__next__() #會報錯

I = iter(L)
I.__next__()
I.__next__()

雖然Python迭代工具自動調(diào)用這些(iter,__next__)函數(shù)，我們也可以使用它們來手動地應(yīng)用迭代協(xié)議。

列表解析:初探

>>列表解析基礎(chǔ)知識

L=[1,2,3,4,5]
L = [x+10 for x in L]

列表解析寫在一個方括號中，因為它們最終是構(gòu)建一個新的列表的一種方式。它們以我們所組成的一個任意的表達式開始，該表達式使用我們所組成的一個循環(huán)變量(x+10)。這后面跟著我們現(xiàn)在應(yīng)該看作是一個for循環(huán)頭部的部分，它申明了循環(huán)變量，以及一個可迭代對象(for x in L)

要運行該表達式，Python在解釋器內(nèi)部執(zhí)行一個遍歷L的迭代，按照順序把x賦給每個元素，并且收集對各元素運行左邊的表達式的結(jié)果。我們得到的結(jié)果列表就是列表解析所表達的內(nèi)容——針對L中的每個x,包含了x+10的一個新列表。

其實列表解析式并不是必須的，因為它能完成的工作都能夠通過for循環(huán)完成，但是列表解析式比手動的for循環(huán)語句運行得更快(往往速度快一倍)，因為它們的迭代在解釋器內(nèi)部是以C語言的速度執(zhí)行的，而不是以手動的Python代碼執(zhí)行的，特別是對于較大的數(shù)據(jù)集合，這是使用列表解析的一個主要的性能優(yōu)點。

當(dāng)我們考慮在一個序列中的每個項上執(zhí)行一個操作時，都可以考慮使用列表解析。

>>擴展的列表解析語法
實際上，列表解析可以有更高級的應(yīng)用。作為一個特別有用的擴展，表達式中嵌套的for循環(huán)可以有一個相關(guān)的if子句，來過濾那些測試不為真的結(jié)果項。

lines = [line.rstrip() for line in open('script.py') if line[0]='p']

這條if子句檢查從文件讀取的每一行，看它的第一個字符是否是p；如果不是，從結(jié)果列表中省略改行。

事實上，如果我們愿意的話，列表解析可以變得更加復(fù)雜——它們的完整語法允許任意數(shù)目的for子句，每個子句有一個可選的相關(guān)的if子句。

Python3.0中的新的可迭代對象

Pyton3.0中的一個基本的改變是，它比Python2.x更強調(diào)迭代。除了與文件和字典這樣的內(nèi)置類型相關(guān)的迭代，字典方法keys、values和items都在Python3.0中返回可迭代對象。 返回一個可迭代對象而不是返回一個結(jié)果列表的好處在于節(jié)省了內(nèi)存的空間。

>>多個迭代器VS單個迭代器
多個迭代器:在它們的結(jié)果中能保持不同位置的多個迭代器
單個迭代器:只能保持一個迭代器，在遍歷其結(jié)果之后，它們就用盡了。
通常通過針對iter調(diào)用返回一個新的對象，來支持多個迭代器；單個迭代器一般意味著一個對象返回其自身。

>>字典視圖迭代器
在Python3.0中，字典的keys、values和items方法返回可迭代的視圖對象，它們一次產(chǎn)生一個結(jié)果項，而不是在內(nèi)存中一次產(chǎn)生全部結(jié)果列表。視圖項保持和字典中的那些項相同的物理順序，并且反映對底層的字典做出的修改。

和所有迭代器一樣，我們總可以通過把一個Python3.0字典視圖傳遞到list內(nèi)置函數(shù)中，從而強制構(gòu)建一個真正的列表。然而，這通常不是必須的。

此外，Python3.0字典仍然有自己的迭代器，它返回連續(xù)的鍵。因此，無需直接在此環(huán)境中調(diào)用keys:

for key in D:print(key,end='')

>>列表解析與map
列表解析在一個序列上的值應(yīng)用一個任意表達式，將其結(jié)果搜集到一個新的列表中并返回。從語法上說，列表解析是由方括號封裝起來的(為了提醒你它們構(gòu)造了一個列表)。它們的簡單形式是在方括號中編寫一個表達式，Python之后將這個表達式的應(yīng)用循環(huán)中每次迭代的結(jié)果搜集起來。例如，假如我們希望搜集字符串中的所有字符的ASCII碼，可以這樣做:

#循環(huán)的方法
res=[]
for x in 'spam':
 res.append(ord(x))

#map函數(shù)的方法
res=list(map(ord,'spam'))

#列表解析
res=[ord(x) for x in 'spam']

>>增加測試和嵌套循環(huán)
其實，列表解析還要比上面說的通用的多，我們可以在for之后編寫一個if分支，用來增加選擇邏輯。

#列表解析

[x ** 2 for x in range(10) if x % 2 == 0]


#map
list(map((lambda x:x**2),filter((lambda x: x % 2==0),range(10))))

上述的兩行代碼都是搜集了0~9中的偶數(shù)的平方和，可以很明顯的看到，完成同樣的功能，列表解析的語句簡單地多。

實際上，列表解析還能夠更加通用。你可以在一個列表解析中編寫任意數(shù)量的嵌套的for循環(huán)，并且每一個都有可選的關(guān)聯(lián)的if測試。通用結(jié)構(gòu)如下所示:

expression for target1 in iterable1 [if comdition1]
      for target2 in iterable2 [if condition2] ...
      for targetN in iterableN [if conditionN]

當(dāng)for分句嵌套在列表解析中時，它們工作起來就像等效的嵌套的for循環(huán)語句。例如，如下的代碼:

res=[x+y for x in [0,1,2] for y in [100,200,300]]

與下面如此冗長的代碼有相同的效果:

res=[]
for x in [0,1,2]:
 for y in [100,200,30]:
  res.append(x+y)

>>列表解析和矩陣
使用Python編寫矩陣的一個基本的方法就是使用嵌套的列表結(jié)構(gòu)，例如，下面的代碼定義了兩個3x3的矩陣:

M=[[1,2,3],
  [4,5,6],
  [7,8,9]]

N=[[2,2,2],
  [3,3,3],
  [4,4,4]]

列表解析也是處理這樣結(jié)構(gòu)的強大工具，它們能夠自動掃描行和列。

取出第二列的所有元素:

[row[1] for row in M]   #[2,5,8]

[M[row][1] for row in (0,1,2)]  #[2,5,8]

取出對角線上的元素:

[M[i][i] for i in range(len(M))] #[1,5,9]

混合多個矩陣，下面的代碼創(chuàng)建了一個單層的列表，其中包含了矩陣對元素的乘積。

下面的代碼再復(fù)雜一點，構(gòu)造一個嵌套的列表，其中的值與上面的一樣:

res=[]
for row in range(3):
 tmp=[]
 for col in range(3):
  tmp.append(M[row][col]*N[row][col])
 res.append(tmp)

>>理解列表解析
基于對運行在當(dāng)前Python版本下的測試，map調(diào)用比等效的for循環(huán)要快兩倍，而列表解析往往比map調(diào)用要稍快一些。速度上的差距來自底層實現(xiàn)，map和列表解析是在解釋器中以C語言的速度來運行的，比Python的for循環(huán)在PVM中步進要快得多。

重訪迭代器:生成器

如今的Python對延遲提供更多的支持——它提供了工具在需要的時候才產(chǎn)生結(jié)果，而不是立即產(chǎn)生結(jié)果。特別地，有兩種語言結(jié)構(gòu)盡可能地拖延結(jié)果創(chuàng)建。

生成器函數(shù):編寫為常規(guī)的def語句，但是是使用yield語句一次返回一個結(jié)果，在每個結(jié)果之間掛起和繼續(xù)它們的狀態(tài)。
生成器表達式:生成器表達式類似于上一小節(jié)的列表解析，但是，它們返回按需產(chǎn)生結(jié)果的一個對象，而不是構(gòu)建一個結(jié)果列表。
由于上面二者都不會一次性構(gòu)建一個列表，它們節(jié)省了內(nèi)存空間，并且允許計算時間分散到各個結(jié)果請求。

>>生成器函數(shù):yield VS return
之前我們寫的函數(shù)都是接受輸入?yún)?shù)并立即返回單個結(jié)果的常規(guī)函數(shù)，然而，也有肯能來編寫可以送回一個值并隨后從其退出的地方繼續(xù)的函數(shù)。這樣的函數(shù)叫做生成器函數(shù)，因為它們隨著時間產(chǎn)生值的一個序列。

一般來說，生成器函數(shù)和常規(guī)函數(shù)一樣，并且，實際上也是用常規(guī)的def語句編寫的。然后，當(dāng)創(chuàng)建時，它們自動實現(xiàn)迭代協(xié)議，以便可以出現(xiàn)在迭代背景中。

狀態(tài)掛起

和返回一個值并退出的函數(shù)不同，生成器函數(shù)自動在生成值的時刻掛起并繼續(xù)函數(shù)的執(zhí)行。因此，它們對于提前計算整個一系列值以及在類中手動保存和恢復(fù)狀態(tài)都很有用。由于生成器函數(shù)在掛起時保存的狀態(tài)包含了它們的整個本地作用域，當(dāng)函數(shù)恢復(fù)時，它們的本地變量保持了信息并且使其可用。

生成器函和常規(guī)函數(shù)之間的主要不同之處在于，生成器yield一個值，而不是return一個值。yield語句掛起該函數(shù)并向調(diào)用者發(fā)送一個值，但是，保留足夠的狀態(tài)以使得函數(shù)從它離開的地方繼續(xù)。當(dāng)繼續(xù)時，函數(shù)在上一個yield返回立即繼續(xù)執(zhí)行。從函數(shù)角度來看，這允許其代碼隨著時間產(chǎn)生一系列的值，而不是一次計算它們并在諸如列表的內(nèi)容中送回它們。

迭代協(xié)議整合

可迭代對象定義了一個__next__方法，它要么返回迭代中的下一項，要么引發(fā)一個特殊的StopIteration異常來終止迭代。一個對象的迭代器用iter內(nèi)置函數(shù)接受。

如果支持該協(xié)議的話，Python的for循環(huán)以及其他的迭代技術(shù)，使用這種迭代協(xié)議來便利一個序列或值生成器；如果不支持，跌打返回去重復(fù)索引序列。

要支持這一協(xié)議，函數(shù)包含一條yield語句，該語句特別編譯為生成器。當(dāng)調(diào)用時，它們返回一個迭代器對象，該對象支持用一個名為__next__的自動創(chuàng)建的方法來繼續(xù)執(zhí)行的接口。生成器函數(shù)也可能有一條return語句，總是在def語句塊的末尾，直接終止值的生成。

生成器函數(shù)應(yīng)用

def gensquares(N):
 for i in range(N):
  yield i ** 2

這個函數(shù)在每次循環(huán)時都會產(chǎn)生一個值，之后將其返回給它的調(diào)用者。當(dāng)它被暫定后，它的上一個狀態(tài)保存了下來 并且在yield語句之后把控制器馬上回收。它允許函數(shù)避免臨時再做所有的工作，當(dāng)結(jié)果的列表很大或者在處理每一個結(jié)果都需要很多時間時，這一點尤其重要。生成器將在loop迭代中處理一系列值的時間分布開來。

擴展生成器函數(shù)協(xié)議:send和next 在Python2.5中，生成器函數(shù)協(xié)議中增加了一個send方法。send方法生成一系列結(jié)果的下一個元素，這一點像__next__方法一樣，但是它提供了一種調(diào)用者與生成器之間進行通信的方法，從而能夠影響它的操作。

def gen():
 for i in range(10):
  X =yield i
  print(X)

G = gen()
next(G)     #0
G.send(77)    #77 1
G.send(88)    #88 2
next(G)     #None 3

上面的代碼比較難于理解，而且書上的翻譯比較劣質(zhì)，沒看懂。在網(wǎng)上查了一些資料，結(jié)合自己的理解，上述代碼的運行過程應(yīng)該是這樣的:生成了一個函數(shù)對象，賦值給了G，然后調(diào)用了next() 函數(shù)，生成了生成器的第一個值0，所以返回值是0。此時函數(shù)運行到y(tǒng)ield語句，碰到y(tǒng)ield語句后立即掛起函數(shù)，保存狀態(tài)，等待下一次迭代。程序中之后又調(diào)用了send()方法，將77傳遞給了yield語句，yield語句將send()傳遞過來的值(此處是77)賦值給X，然后打印出來。然后函數(shù)繼續(xù)運行，直到再次碰到y(tǒng)ield，此時是第二次碰到y(tǒng)ield，所以返回了1，接著函數(shù)又被掛起，等待下一次迭代。接著又調(diào)用了send()，同上次調(diào)用一樣，將傳進的參數(shù)(此處是88)作為yield的返回值賦值給X，然后打印，接著繼續(xù)運行函數(shù)，直到再次碰到y(tǒng)ield，此時是第三次，因此輸出2。最后又再次調(diào)用了next()函數(shù)，其實'next()'函數(shù)就是傳遞了一個None,因此，我們得到的結(jié)果是None和3。

此處需要注意的是，其實next()和send(None)是等價的。通過send()方法，我們就能夠和生成器實現(xiàn)通信。

>>生成器表達式：迭代器遇到列表解析
在最新版的Python中，迭代器和列表解析的概念形成了這種語言的一個新特性——生成器表達式。從語法上講，生成器表達式就像一般的列表解析一樣，但是它們是擴在圓括號中而不是方括號中的。

[x ** 2 for x in range(4)]  #List comprehension:build a list
(x ** 2 for x in range(4))  #Genterator expression:make an iterable

從執(zhí)行過程上來講，生成器表達式很不相同:不是在內(nèi)存中構(gòu)建結(jié)果，而是返回一個生成器對象，這個對象將會支持迭代協(xié)議。

生成器表達式大體上可以認為是對內(nèi)存空間的優(yōu)化，他們不需要像方括號的列表解析一樣，一次構(gòu)造出整個結(jié)果列表。它們在實際中運行起來可能稍慢一些，所以它們可能只對于非常龐大的結(jié)果集合的運算來說是最優(yōu)的選擇。

>>生成器函數(shù)VS生成器表達式
生成器函數(shù)和生成器表達式自身都是迭代器，并由此只支持一次活躍迭代，我們無法有在結(jié)果集中位于不同位置的多個迭代器。

Python3.0解析語法概括

我們已經(jīng)在本章中關(guān)注過列表解析和生成器，但是，別忘了，還有兩種在Python3.0中可用的解析表達式形式:集合解析和字典解析。

[x*x for x in range(10)]   #List comprehension:build list
(x*x for x in range(10))   #Generator expression:produces items
{x*x for x in range(10)}   #Set comprehension:new in 3.0
{x:x*x for x in range(10)  #Directionary comprehension:new in 3.0

需要注意的是，上面最后兩種表達方式都是一次性構(gòu)建所有對象的，它們沒有根據(jù)需要產(chǎn)生結(jié)果的概念。

總結(jié)

列表解析、集合解析、字典解析都是一次性構(gòu)建對象的，直接返回的。
生成器函數(shù)和生成器表達式不是在內(nèi)存中構(gòu)建結(jié)果的，它們是返回一個生成器對象，這個對象支持迭代協(xié)議，根據(jù)調(diào)用者需要產(chǎn)生結(jié)果。
集合解析、字典解析都支持嵌套相關(guān)的if子句從結(jié)果中過濾元素。
函數(shù)陷阱

>>本地變量是靜態(tài)檢測的
Python定義的在一個函數(shù)中進行分配的變量名時默認為本地變量的，它們存在于函數(shù)的作用域并只在函數(shù)運行時存在。Python靜態(tài)檢測Python的本地變量，當(dāng)編譯def代碼時，不是通過發(fā)現(xiàn)賦值語句在運行時進行檢測的。被賦值的變量名在函數(shù)內(nèi)部是當(dāng)做本地變量來對待的，而不是僅僅在賦值以后的語句才被當(dāng)做是本地變量。

>>沒有return語句的函數(shù)
在Python函數(shù)中，return(以及yield)語句是可選的。從技術(shù)上說，所有的函數(shù)都會返回了一個值，如果沒有提供return語句，函數(shù)將自動返回None對象。