Python yield 使用方法淺析

本篇文章主要介紹了Python yield 使用方法淺析，小編覺得挺不錯的，現在分享給大家，也給大家做個參考。

如何生成斐波那契數列

斐波那契（Fibonacci）數列是一個非常簡單的遞歸數列，除第一個和第二個數外，任意一個數都可由前兩個數相加得到。用計算機程序輸出斐波那契數列的前 N 個數是一個非常簡單的問題，許多初學者都可以輕易寫出如下函數：

清單 1. 簡單輸出斐波那契數列前 N 個數    
def fab(max):
 n, a, b = 0, 0, 1
 while n < max:
   print b
   a, b = b, a + b
   n = n + 1

執行 fab(5)，我們可以得到如下輸出：

 >>> fab(5)
 1
 1
 2
 3
 5

結果沒有問題，但有經驗的開發者會指出，直接在 fab 函數中用 print 打印數字會導致該函數可復用性較差，因為 fab 函數返回 None，其他函數無法獲得該函數生成的數列。

要提高 fab 函數的可復用性，最好不要直接打印出數列，而是返回一個 List。以下是 fab 函數改寫后的第二個版本：

清單 2. 輸出斐波那契數列前 N 個數第二版
    
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

可以使用如下方式打印出 fab 函數返回的 List：

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

改寫后的 fab 函數通過返回 List 能滿足復用性的要求，但是更有經驗的開發者會指出，該函數在運行中占用的內存會隨著參數 max 的增大而增大，如果要控制內存占用，最好不要用 List來保存中間結果，而是通過 iterable 對象來迭代。例如，在 Python2.x 中，代碼：

清單 3. 通過 iterable 對象來迭代

 for i in range(1000): pass會導致生成一個 1000 個元素的 List，而代碼：

 for i in xrange(1000): pass則不會生成一個 1000 個元素的 List，而是在每次迭代中返回下一個數值，內存空間占用很小。因為 xrange 不返回 List，而是返回一個 iterable 對象。

利用 iterable 我們可以把 fab 函數改寫為一個支持 iterable 的 class，以下是第三個版本的 Fab：

清單 4. 第三個版本    
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()

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

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

然而，使用 class 改寫的這個版本，代碼遠遠沒有第一版的 fab 函數來得簡潔。如果我們想要保持第一版 fab 函數的簡潔性，同時又要獲得 iterable 的效果，yield 就派上用場了：

清單 5. 使用 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
 
'''

第四個版本的 fab 和第一版相比，僅僅把 print b 改為了 yield b，就在保持簡潔性的同時獲得了 iterable 的效果。

調用第四版的 fab 和第二版的 fab 完全一致：

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

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

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

清單 6. 執行流程
    
>>> f = fab(5)
>>> f.next()
1
>>> f.next()
1
>>> f.next()
2
>>> f.next()
3
>>> f.next()
5
>>> f.next()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration

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

我們可以得出以下結論：

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

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

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

清單 7. 使用 isgeneratorfunction 判斷
    
>>> from inspect import isgeneratorfunction
>>> isgeneratorfunction(fab)
True

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

清單 8. 類的定義和類的實例
    
>>> 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

return 的作用

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

另一個例子

另一個 yield 的例子來源于文件讀取。如果直接對文件對象調用 read() 方法，會導致不可預測的內存占用。好的方法是利用固定長度的緩沖區來不斷讀取文件內容。通過 yield，我們不再需要編寫讀文件的迭代類，就可以輕松實現文件讀?。?br />
清單 9. 另一個 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
以上就是本文的全部內容，希望對大家的學習有所幫助