簡介

本 PEP 提議對生成器的 API 和語法進行一些增強，使其能作為簡單的協同程式使用。這基本上是整合了以下兩個 PEP 的想法；若本 PEP 被採納，那兩個 PEP 可能會被視為冗餘：

• PEP 288，「生成器屬性與異常」。目前的 PEP 涵蓋了其後半部分，即生成器異常（事實上 throw() 方法名稱即取自 PEP 288）。然而，PEP 342 用 PEP 288 前一個版本中的概念（即 *yield 表達式*）取代了生成器屬性。
• PEP 325，「生成器的資源釋放支援」。PEP 342 解決了 PEP 325 規範中遺留的少數問題，使其適用於實際開發。

動機

協同程式是表達許多演算法（如模擬、遊戲、非同步 I/O 以及其他事件驅動程式設計或協同式多工處理）的自然方式。Python 的生成器函式幾乎就是協同程式，但還差了一點——它們允許暫停執行以產生一個值，但卻不提供在恢復執行時傳入值或異常的功能。它們也不允許在 try/finally 區塊的 try 部分內暫停執行，因此導致中止的協同程式難以執行自我清理。

此外，生成器無法在其他函式執行時讓出控制權，除非這些函式本身也被定義為生成器，並且外部生成器被編寫為根據內部生成器產生的值來進行 yield。這使得即使是相對簡單的使用情境（例如非同步通訊）的實作也變得複雜，因為呼叫任何函式，要麼需要生成器「阻塞」（即無法讓出控制權），要麼必須在每個需要的函式呼叫周圍添加大量的樣板迴圈程式碼。

然而，如果能夠在生成器暫停的位置將值或異常「傳入」生成器，那麼一個簡單的協同程式排程器或「彈跳函式」(trampoline function) 將允許協同程式在不阻塞的情況下互相「呼叫」——這對非同步應用程式而言是一個巨大的福音。這樣的應用程式可以編寫協同程式來執行非阻塞 Socket I/O，方法是將控制權讓給 I/O 排程器，直到資料發送完畢或可用為止。同時，執行 I/O 的程式碼只需要簡單地執行如下操作：

data = (yield nonblocking_read(my_socket, nbytes))

以便暫停執行，直到 nonblocking_read() 協同程式產生一個值為止。

換句話說，透過對語言及生成器迭代器類型的實作進行一些相對較小的增強，Python 將能夠支援執行非同步操作，而無需將整個應用程式編寫成一系列的回呼 (callbacks)，也無需為需要成百上千個協同式多工偽執行緒的程式使用資源密集型執行緒。因此，這些增強功能將賦予標準 Python 許多 Stackless Python 分支的好處，且無需對 CPython 核心或其 API 進行任何重大修改。此外，這些增強功能應可由任何已經支援生成器的 Python 實作（如 Jython）輕鬆實作。

規範摘要

透過在生成器迭代器類型中添加幾個簡單的方法，並進行兩處小的語法調整，Python 開發者將能夠使用生成器函式來實作協同程式及其他形式的協同式多工處理。這些方法與調整如下：

1. 將 yield 重新定義為一個表達式，而非陳述式。目前的 yield 陳述式將變為一個 yield 表達式，其值將被丟棄。每當生成器由一般的 next() 呼叫恢復時，yield 表達式的值為 None。
2. 為生成器迭代器新增一個 send() 方法，該方法會恢復生成器並「傳送」一個值，該值成為當前 yield 表達式的結果。send() 方法會傳回生成器產生的下一個值；若生成器未產生下一個值即結束，則引發 StopIteration。
3. 為生成器迭代器新增一個 throw() 方法，該方法會在生成器暫停的位置引發一個異常，並傳回生成器產生的下一個值；若生成器未產生下一個值即結束，則引發 StopIteration。（若生成器未捕捉傳入的異常，或引發了不同的異常，則該異常會傳播至呼叫者。）
4. 為生成器迭代器新增一個 close() 方法，該方法會在生成器暫停的位置引發 GeneratorExit。若生成器隨後引發 StopIteration（透過正常退出，或因為已關閉）或 GeneratorExit（透過未捕捉該異常），則 close() 返回至其呼叫者。若生成器產生了一個值，則引發 RuntimeError。若生成器引發任何其他異常，則該異常會傳播至呼叫者。若生成器已因異常或正常退出而結束，close() 則不執行任何操作。
5. 新增支援，以確保當生成器迭代器被垃圾回收時會呼叫 close()。
6. 允許在 try/finally 區塊中使用 yield，因為現在垃圾回收或明確呼叫 close() 將允許執行 finally 子句。

一個針對當前 Python CVS HEAD 實作了所有這些更改的原型修補程式，可從 SourceForge 取得，編號 #1223381 (https://bugs.python.org/issue1223381)。

規範：向生成器發送值

x = yield 42
x = yield
x = 12 + (yield 42)
x = 12 + (yield)
foo(yield 42)
foo(yield)

x = 12 + yield 42
x = 12 + yield
foo(yield 42, 12)
foo(yield, 12)

規範：異常與清理

設一個生成器物件為呼叫生成器函式所產生的迭代器。在下文中，*g* 始終指代一個生成器物件。

raise type, value, traceback

def close(self):
    try:
        self.throw(GeneratorExit)
    except (GeneratorExit, StopIteration):
        pass
    else:
        raise RuntimeError("generator ignored GeneratorExit")
    # Other exceptions are not caught

選用擴充功能

待決問題

在 python-dev 上的討論揭示了一些懸而未決的問題。我在這裡列出它們，並附上我首選的解決方案及其動機。目前編寫的 PEP 反映了這些首選解決方案。

1. 當生成器產生另一個值以回應 GeneratorExit 異常時，close() 應該引發什麼異常？

   我最初選擇了 TypeError，因為它代表了生成器函式的嚴重不當行為，應該透過修改程式碼來修復。但 PEP 343 中的 with_template 裝飾器類別對類似的違規行為使用了 RuntimeError。可以說，它們都應該使用相同的異常。我不想僅為了這個目的引入一個新的異常類別，因為我不希望人們捕捉這個異常：我希望它轉化為 traceback，讓開發者看到後修正程式碼。因此，我現在認為它們都應該引發 RuntimeError。這是有先例的：核心 Python 程式碼在檢測到無限遞迴、未初始化物件（以及各種其他雜項條件）時會引發該異常。

2. Oren Tirosh 提議將 send() 方法重新命名為 feed()，以相容於 *consumer 介面*（參見 http://effbot.org/zone/consumer.htm 規範）。

   然而，仔細研究 consumer 介面後，似乎 feed() 所需的語意與 send() 不同，因為 send() 不能在剛啟動的生成器上被有意義地呼叫。此外，當前定義的 consumer 介面未包含對 StopIteration 的處理。

   因此，建立一個簡單的裝飾器來封裝生成器函式，使其符合 consumer 介面，可能會更有用。例如，它可以用初始的 next() 呼叫來「預熱」生成器、捕捉 StopIteration，甚至可能透過重新呼叫生成器函式來提供 reset() 功能。

範例

1. 一個簡單的 *consumer* 裝飾器，使得生成器函式在最初被呼叫時會自動推進至其第一個 yield 點：

   def consumer(func):
       def wrapper(*args,**kw):
           gen = func(*args, **kw)
           gen.next()
           return gen
       wrapper.__name__ = func.__name__
       wrapper.__dict__ = func.__dict__
       wrapper.__doc__  = func.__doc__
       return wrapper
   

2. 使用 *consumer* 裝飾器建立 *反向生成器* 的範例，它接收影像並建立縮圖頁面，然後將它們發送給另一個 consumer。像這樣的函式可以串聯起來，形成高效的 *consumer* 處理管道，每個 consumer 都可以擁有複雜的內部狀態：

   @consumer
   def thumbnail_pager(pagesize, thumbsize, destination):
       while True:
           page = new_image(pagesize)
           rows, columns = pagesize / thumbsize
           pending = False
           try:
               for row in xrange(rows):
                   for column in xrange(columns):
                       thumb = create_thumbnail((yield), thumbsize)
                       page.write(
                           thumb, col*thumbsize.x, row*thumbsize.y )
                       pending = True
           except GeneratorExit:
               # close() was called, so flush any pending output
               if pending:
                   destination.send(page)
   
               # then close the downstream consumer, and exit
               destination.close()
               return
           else:
               # we finished a page full of thumbnails, so send it
               # downstream and keep on looping
               destination.send(page)
   
   @consumer
   def jpeg_writer(dirname):
       fileno = 1
       while True:
           filename = os.path.join(dirname,"page%04d.jpg" % fileno)
           write_jpeg((yield), filename)
           fileno += 1
   
   
   # Put them together to make a function that makes thumbnail
   # pages from a list of images and other parameters.
   #
   def write_thumbnails(pagesize, thumbsize, images, output_dir):
       pipeline = thumbnail_pager(
           pagesize, thumbsize, jpeg_writer(output_dir)
       )
   
       for image in images:
           pipeline.send(image)
   
       pipeline.close()
   

3. 一個簡單的協同程式排程器或 *彈跳器*，允許協同程式透過 yield 它們想要呼叫的協同程式來「呼叫」其他協同程式。協同程式產生的任何非生成器值都會傳回給「呼叫」該產生值協同程式的協同程式。同樣地，若一個協同程式引發異常，該異常會傳播至其「呼叫者」。實際上，只要你使用 yield 表達式來呼叫原本會「阻塞」的常式，這個範例就能模擬 Stackless Python 中使用的簡單 tasklets。這只是一個非常簡單的範例，還有更多精密的排程器是可行的。（例如，現有的 Python GTasklet 框架 (http://www.gnome.org/~gjc/gtasklet/gtasklets.html) 和 peak.events 框架 (http://peak.telecommunity.com/) 已經實作了類似的排程功能，但目前必須為無法傳入值或異常給生成器的限制使用笨拙的變通方法。）

   import collections
   
   class Trampoline:
       """Manage communications between coroutines"""
   
       running = False
   
       def __init__(self):
           self.queue = collections.deque()
   
       def add(self, coroutine):
           """Request that a coroutine be executed"""
           self.schedule(coroutine)
   
       def run(self):
           result = None
           self.running = True
           try:
               while self.running and self.queue:
                  func = self.queue.popleft()
                  result = func()
               return result
           finally:
               self.running = False
   
       def stop(self):
           self.running = False
   
       def schedule(self, coroutine, stack=(), val=None, *exc):
           def resume():
               value = val
               try:
                   if exc:
                       value = coroutine.throw(value,*exc)
                   else:
                       value = coroutine.send(value)
               except:
                   if stack:
                       # send the error back to the "caller"
                       self.schedule(
                           stack[0], stack[1], *sys.exc_info()
                       )
                   else:
                       # Nothing left in this pseudothread to
                       # handle it, let it propagate to the
                       # run loop
                       raise
   
               if isinstance(value, types.GeneratorType):
                   # Yielded to a specific coroutine, push the
                   # current one on the stack, and call the new
                   # one with no args
                   self.schedule(value, (coroutine,stack))
   
               elif stack:
                   # Yielded a result, pop the stack and send the
                   # value to the caller
                   self.schedule(stack[0], stack[1], value)
   
               # else: this pseudothread has ended
   
           self.queue.append(resume)
   

4. 一個簡單的 *echo* 伺服器，以及使用彈跳器執行它的程式碼（假設存在 nonblocking_read、nonblocking_write 以及其他 I/O 協同程式，例如若連線關閉則引發 ConnectionLost）：

   # coroutine function that echos data back on a connected
   # socket
   #
   def echo_handler(sock):
       while True:
           try:
               data = yield nonblocking_read(sock)
               yield nonblocking_write(sock, data)
           except ConnectionLost:
               pass  # exit normally if connection lost
   
   # coroutine function that listens for connections on a
   # socket, and then launches a service "handler" coroutine
   # to service the connection
   #
   def listen_on(trampoline, sock, handler):
       while True:
           # get the next incoming connection
           connected_socket = yield nonblocking_accept(sock)
   
           # start another coroutine to handle the connection
           trampoline.add( handler(connected_socket) )
   
   # Create a scheduler to manage all our coroutines
   t = Trampoline()
   
   # Create a coroutine instance to run the echo_handler on
   # incoming connections
   #
   server = listen_on(
       t, listening_socket("localhost","echo"), echo_handler
   )
   
   # Add the coroutine to the scheduler
   t.add(server)
   
   # loop forever, accepting connections and servicing them
   # "in parallel"
   #
   t.run()
   

參考實作

一個實作了本 PEP 中描述的所有特性的原型修補程式，可從 SourceForge 取得，編號 #1223381 (https://bugs.python.org/issue1223381)。

該修補程式已於 2005 年 8 月 1 日至 2 日合併至 CVS。

致謝

Raymond Hettinger (PEP 288) 和 Samuele Pedroni (PEP 325) 最先正式提出了將值或異常傳入生成器的想法，以及「關閉」生成器的能力。Timothy Delaney 建議了本 PEP 的標題，Steven Bethard 協助編輯了之前的版本。另請參閱 PEP 340 的致謝部分。

參考文獻

待定 (TBD)。

版權

此文件已歸入公有領域 (public domain)。