程式扎記: [ Python 文章收集 ] Python yield 使用淺析

標籤

2016年5月6日 星期五

[ Python 文章收集 ] Python yield 使用淺析

Source From Here 
Introduction 
初學 Python 的開發者經常會發現很多Python 函數中用到了yield 關鍵字,然而,帶有 yield 的函數執行流程卻和普通函數不一樣,yield 到底用來做什麼,為什麼要設計yield ?本文將由淺入深地講解 yield 的概念和用法,幫助讀者體會Python 裡yield 簡單而強大的功能。您可能聽說過,帶有yield 的函數在Python 中被稱之為generator(生成器),何謂 generator ?我們先拋開generator,以一個常見的編程題目來展示 yield 的概念。 

如何生成斐波那契數列 
斐波那契(Fibonacci)數列是一個非常簡單的遞歸數列,除第一個和第二個數外,任意一個數都可由前兩個數相加得到。用計算機程序輸出斐波那契數列的前N 個數是一個非常簡單的問題,許多初學者都可以輕易寫出如下函數: 
- 清單1. 簡單輸出斐波那契數列前 N 個數 
  1. def fab(N):   
  2.     n, a, b = 001   
  3.     while n < N:   
  4.         print b   
  5.         a, b = b, a + b   
  6.         n = n + 1  
執行 fab(5),我們可以得到如下輸出: 
>>> fab(5)
1
1
2
3
5

結果沒有問題,但有經驗的開發者會指出,直接在 fab 函數中用 print 打印數字會導致該函數可複用性較差,因為 fab 函數返回 None,其他函數無法獲得該函數生成的數列。要提高 fab 函數的可複用性,最好不要直接打印出數列,而是返回一個 List。以下是 fab 函數改寫後的第二個版本: 
清單2. 輸出斐波那契數列前N 個數第二版 
  1. def fab2(N):   
  2.     n, a, b = 001   
  3.     L = []   
  4.     while n < N:   
  5.         L.append(b)   
  6.         a, b = b, a + b   
  7.         n = n + 1   
  8.     return L  
可以使用如下方式打印出 fab2 函數返回的 List: 
>>> for n in fab2(5):
... print n
...
1
1
2
3
5

改寫後的 fab2 函數通過返回 List 能滿足復用性的要求,但是更有經驗的開發者會指出,該函數在運行中佔用的內存會隨著參數 的增大而增大,如果要控制內存佔用,最好不要用 List 來保存中間結果,而是通過 iterable 對象來迭代。考慮簡單範例如下面代碼: 
清單3. 通過iterable 對象來迭代 
  1. for i in range(1000): pass  
會導致生成一個1000 個元素的List,而代碼: 
  1. for i in xrange(1000): pass  
則不會生成一個1000 個元素的 List,而是在每次迭代中返回下一個數值,內存空間佔用很小。因為 xrange 不返回List,而是返回一個 iterable 對象。 

利用 iterable 我們可以把 fab 函數改寫為一個支持 iterable 的class,以下是第三個版本的 Fab: 
清單4. 第三個版本 
  1. class Fab(object):   
  2.   
  3.     def __init__(self, max):   
  4.         self.max = max   
  5.         self.n, self.a, self.b = 001   
  6.   
  7.     def __iter__(self):   
  8.         return self   
  9.   
  10.     def next(self):   
  11.         if self.n < self.max:   
  12.             r = self.b   
  13.             self.a, self.b = self.b, self.a + self.b   
  14.             self.n = self.n + 1   
  15.             return r   
  16.         raise StopIteration()  
Fab 類通過 next() 不斷返回數列的下一個數,內存佔用始終為常數: 
>>> for n in Fab(5): 
... print n 
...
1
1
2
3
5

然而,使用 class 改寫的這個版本,代碼遠遠沒有第一版的 fab 函數來得簡潔。如果我們想要保持第一版 fab 函數的簡潔性,同時又要獲得 iterable 的效果,yield 就派上用場了: 
清單5. 使用yield 的第四版 
  1. def fab4(N):   
  2.     n, a, b = 001   
  3.     while n < N:   
  4.         yield b   
  5.         # print b   
  6.         a, b = b, a + b   
  7.         n = n + 1   
第四個版本的 fab4 和第一版相比,僅僅把 print b 改為了yield b,就在保持簡潔性的同時獲得了 iterable 的效果。調用第四版的 fab4 和第二版的 fab 完全一致: 
>>> for n in fab4(5):
... print n
...
1
1
2
3
5

簡單地講,yield 的作用就是把一個函數變成一個generator,帶有yield 的函數不再是一個普通函數,Python 解釋器會將其視為一個generator,調用 fab4(5) 不會執行 fab4 函數,而是返回一個 iterable 對象!在 fo​​r 循環執行時,每次循環都會執行 fab4 函數內部的代碼,執行到 yield b 時,fab4 函數就返回一個迭代值,下次迭代時,代碼從 yield b 的下一條語句繼續執行,而函數的本地變量看起來和上次中斷執行前是完全一樣的,於是函數繼續執行,直到再次遇到 yield。 

也可以手動調用 fab4(5) 的 next() 方法(因為 fab4(5) 是一個generator 對象,該對象具有 next() 方法),這樣我們就可以更清楚地看到 fab4 的執行流程: 
清單6. 執行流程 
>>> f = fab4(5)
>>> f.__class__

>>> f.next()
1
>>> f.next()
1
>>> f.next()
2
>>> f.next()
3
>>> f.next()
5
>>> f.next()
Traceback (most recent call last):
File "", line 1, in
StopIteration

當函數執行結束時,generator 自動拋出 StopIteration 異常,表示迭代完成。在fo​​r 循環裡,無需處理 StopIteration 異常,循環會正常結束。我們可以得出以下結論: 
一個帶有 yield 的函數就是一個 generator,它和普通函數不同,生成一個 generator 看起來像函數調用,但不會執行任何函數代碼,直到對其調用 next()(在for 循環中會自動調用next( ))才開始執行。雖然執行流程仍按函數的流程執行,但每執行到一個 yield 語句就會中斷,並返回一個迭代值,下次執行時從 yield 的下一個語句繼續執行。看起來就好像一個函數在正常執行的過程中被 yield 中斷了數次,每次中斷都會通過 yield 返回當前的迭代值。

yield 的好處是顯而易見的,把一個函數改寫為一個 generator 就獲得了迭代能力,比起用類的實例保存狀態來計算下一個 next() 的值,不僅代碼簡潔,而且執行流程異常清晰。如何判斷一個函數是否是一個特殊的generator 函數?可以利用 isgeneratorfunction 判斷: 
清單7. 使用isgeneratorfunction 判斷 
>>> from inspect import isgeneratorfunction
>>> isgeneratorfunction(fab4)
True

要注意區分 fab4 和 fab4(5)fab4 是一個generator function,而 fab4(5) 是調用 fab4 返回的一個generator,好比類的定義和類的實例的區別: 
清單8. 類的定義和類的實例 
>>> import types
>>> isinstance(fab4, types.GeneratorType)
False
>>> isinstance(fab4(5), types.GeneratorType)
True

另一個例子 
另一個yield 的例子來源於文件讀取。如果直接對文件對象調用 read() 方法,會導致不可預測的內存佔用。好的方法是利用固定長度的緩衝區來不斷讀取文件內容。通過yield,我們不再需要編寫讀文件的迭代類,就可以輕鬆實現文件讀取: 
清單9. 另一個yield 的例子 
  1. def read_file(fpath):   
  2.     BLOCK_SIZE = 1024   
  3.     with open(fpath, 'rb') as f:   
  4.         while True:   
  5.             block = f.read(BLOCK_SIZE)   
  6.             if block:   
  7.                 yield block   
  8.             else:   
  9.                 return  


Supplement 
Python Gossip - 函式、類別與模組 - yield 產生器

沒有留言:

張貼留言

網誌存檔

關於我自己

我的相片
Where there is a will, there is a way!