python生成器之yield_ZenDei技術網路在線

參考：【Python yield 使用淺析】、【Python xrange與range的區別】等一個帶有 yield 的函數就是一個 generator，它和普通函數不同，生成一個 generator 看起來像函數調用，但不會執行任何函數代碼，直到對其調用 next()（在 for 迴圈中會自動調 ...

參考：【Python yield 使用淺析】、【Python xrange與range的區別】等

一個帶有 yield 的函數就是一個 generator，它和普通函數不同，生成一個 generator 看起來像函數調用，但不會執行任何函數代碼，直到對其調用 next()（在 for 迴圈中會自動調用 next()）才開始執行。雖然執行流程仍按函數的流程執行，但每執行到一個 yield 語句就會中斷，並返回一個迭代值，下次執行時從 yield 的下一個語句繼續執行。看起來就好像一個函數在正常執行的過程中被 yield 中斷了數次，每次中斷都會通過 yield 返回當前的迭代值。

yield 的好處是顯而易見的，把一個函數改寫為一個 generator 就獲得了迭代能力，比起用類的實例保存狀態來計算下一個 next() 的值，不僅代碼簡潔，而且執行流程異常清晰。

首先看range和xrange：

for i in range(1000): pass

上面代碼會生成一個含有1000 個元素的 List，而代碼：

for i in xrange(1000): pass

則是在每次迭代中返回下一個數值，記憶體空間占用很小。因為 xrange 不返回 List，而是返回一個生成器，（List是一種迭代對象）。

一個迭代對象可以通過調用iter方法返回一個iterator對象，然後進行for loop訪問：

class Iterable_:  
   def __iter__(self):  
       return iter([1, 2, 3])   
it = iter((Iterable_()))  
for i in it:   
    print "iterable:" + str(i)  
  
#輸出  
iterable:1  
iterable:2  
iterable:3

View Code

range：

a = range(0,5) 
print type(a)    #輸出 <type 'list'>
print a          #輸出 [0,1,2,3,4]
print a[0], a[1] #輸出 0, 1

xrange:

a = xrange(0,5) 
print type(a)    #輸出 <type 'xrange'>
print a          #輸出 xrange(5)
print a[0], a[1] #輸出 0, 1

迭代器肯定是iterable類型的對象，它是包含有next(Python 2) 方法或者__next__(Python 3) 方法和__iter__（返回self）方法的一個特殊對象。對於一個生成器它一定是一個迭代器可以通過for loop進行訪問其中的元素，但是一個迭代器卻不一定是生成器。

定義迭代器有兩種方式，第一個是使用yield關鍵詞，另外一個是生成器表達式"()"。對於一個方法在方法體裡加上yield關鍵詞就變成了生成器。yield作用就是返回一個生成器，它會保存當前函數狀態，記錄下一次函數被調用next的時候運行狀態。當函數沒有下一次運行狀態的時候，再繼續調用next方法，這個時候StopIteration異常就被拋出。 生成器具有迭代器的特性，比如只能向前遍歷等。當然生成器還有自己的方法，比如send方法等。通過send可以定義當前生成器中的值。

斐波那契數列（Fibonacci）

1. 最普通的：

def fab(max): 
   n, a, b = 0, 0, 1 
   while n < max: 
       print b 
       a, b = b, a + b 
       n = n + 1

2. 為了提高 fab 函數的可重用性，最好返回一個 List如下：

def fab(max): 
   n, a, b = 0, 0, 1 
   L = [] 
   while n < max: 
       L.append(b) 
       a, b = b, a + b 
       n = n + 1 
   return L

for n in fab(5): 
       print n

3. 該函數在運行中占用的記憶體會隨著參數 max 的增大而增大，所以最好不要用 List來保存中間結果，而是通過 iterable 對象來迭代，利用 iterable 我們可以把 fab 函數改寫為一個支持 iterable 的 class：

class Fab(object): 
 
   def __init__(self, max): 
       self.max = max 
       self.n, self.a, self.b = 0, 0, 1 
 
   def __iter__(self): 
       return self 
 
   def next(self): 
       if self.n < self.max: 
           r = self.b 
           self.a, self.b = self.b, self.a + self.b 
           self.n = self.n + 1 
           return r 
       raise StopIteration()

View Code

Fab 類通過 next() 不斷返回數列的下一個數，記憶體占用始終為常數：

>>> for n in Fab(5): 
...     print n 
...

View Code

4. 但是使用 class 改寫的這個版本，代碼遠遠沒有第一版的 fab 函數來得簡潔。使用yield：

def fab(max): 
    n, a, b = 0, 0, 1 
    while n < max: 
        yield b 
        # print b 
        a, b = b, a + b 
        n = n + 1

和第一版相比，僅僅把 print b 改為了 yield b，調用也沒什麼變化：

>>> for n in fab(5): 
...     print n 
... 
1 
1 
2 
3 
5

yield 的作用就是把一個函數變成一個 generator，Python 解釋器會將其視為一個 generator，調用 fab(5) 不會執行 fab 函數，而是返回一個 iterable 對象！在 for 迴圈執行時，每次迴圈都會執行 fab 函數內部的代碼，執行到 yield b 時，fab 函數就返回一個迭代值，下次迭代時，代碼從 yield b 的下一條語句繼續執行，而函數的本地變數看起來和上次中斷執行前是完全一樣的，於是函數繼續執行，直到再次遇到 yield。

也可以手動調用 fab(5) 的 next() 方法（因為 fab(5) 是一個 generator 對象，該對象具有 next() 方法），這樣我們就可以更清楚地看到 fab 的執行流程：

>>> f = fab(5) 
>>> f.next() 

>>> f.next() 

>>> f.next() 

>>> f.next() 

>>> f.next() 

>>> f.next() 
Traceback (most recent call last): 
 File "<stdin>", line 1, in <module> 
StopIteration

View Code

當函數執行結束時，generator 自動拋出 StopIteration 異常，表示迭代完成。在 for 迴圈里，無需處理 StopIteration 異常，迴圈會正常結束。

6. 何判斷一個函數是否是一個特殊的 generator 函數？可以利用 isgeneratorfunction 判斷：

>>> from inspect import isgeneratorfunction 
>>> isgeneratorfunction(fab) 
True

7. 要註意區分 fab 和 fab(5)，fab 是一個 generator function，而 fab(5) 是調用 fab 返回的一個 generator，好比類的定義和類的實例的區別：

>>> import types 
>>> isinstance(fab, types.GeneratorType) 
False 
>>> isinstance(fab(5), types.GeneratorType) 
True

fab 是無法迭代的，而 fab(5) 是可迭代的：

>>> from collections import Iterable 
>>> isinstance(fab, Iterable) 
False 
>>> isinstance(fab(5), Iterable) 
True

每次調用 fab 函數都會生成一個新的 generator 實例，各實例互不影響：

>>> f1 = fab(3) 
>>> f2 = fab(5) 
>>> print 'f1:', f1.next() 
f1: 1 
>>> print 'f2:', f2.next() 
f2: 1 
>>> print 'f1:', f1.next() 
f1: 1 
>>> print 'f2:', f2.next() 
f2: 1 
>>> print 'f1:', f1.next() 
f1: 2 
>>> print 'f2:', f2.next() 
f2: 2 
>>> print 'f2:', f2.next() 
f2: 3 
>>> print 'f2:', f2.next() 
f2: 5

View Code

return 的作用

在一個 generator function 中，如果沒有 return，則預設執行至函數完畢，如果在執行過程中 return，則直接拋出 StopIteration 終止迭代。

另一個例子

另一個 yield 的例子來源於文件讀取。如果直接對文件對象調用 read() 方法，會導致不可預測的記憶體占用。好的方法是利用固定長度的緩衝區來不斷讀取文件內容。通過 yield，我們不再需要編寫讀文件的迭代類，就可以輕鬆實現文件讀取：

def read_file(fpath): 
   BLOCK_SIZE = 1024 
   with open(fpath, 'rb') as f: 
       while True: 
           block = f.read(BLOCK_SIZE) 
           if block: 
               yield block 
           else: 
               return

以上僅僅簡單介紹了 yield 的基本概念和用法，yield 在 Python 3 中還有更強大的用法