简介

本 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 部分内暂停执行，因此使中止的协程难以自行清理。

此外，生成器无法在其他函数执行时产生控制权，除非这些函数本身以生成器形式表达，并且外部生成器被编写为响应内部生成器产生的值而产生控制权。这使得即使是相对简单的用例（如异步通信）的实现也变得复杂，因为调用任何函数都需要生成器阻塞（即无法产生控制权），或者在每个需要的函数调用周围添加大量样板循环代码。

但是，如果可以在生成器暂停的位置向其传入值或异常，一个简单的协程调度程序或蹦床函数将允许协程调用彼此而不会阻塞——这对于异步应用程序来说是一个巨大的好处。此类应用程序随后可以编写协程来执行非阻塞套接字 I/O，方法是将控制权产生给 I/O 调度程序，直到数据已发送或可用。同时，执行 I/O 的代码只需执行以下操作

data = (yield nonblocking_read(my_socket, nbytes))

以暂停执行，直到 nonblocking_read() 协程生成一个值。

换句话说，通过对语言和生成器迭代器类型的实现进行一些相对较小的增强，Python 将能够支持执行异步操作，而无需将整个应用程序编写为一系列回调，并且无需为需要数百甚至数千个协作式多任务伪线程的程序使用资源密集型线程。因此，这些增强将为标准 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。可以说它们都应该使用相同的异常。我宁愿不为此目的引入新的异常类，因为它不是我想让人们捕获的异常：我想让它变成一个回溯，程序员看到后会修复代码。因此，我现在认为它们都应该引发RuntimeError。有一些先例：在检测到无限递归以及未初始化对象（以及各种杂项条件）的情况下，核心 Python 代码会引发它。

2. Oren Tirosh 建议将send()方法重命名为feed()，以与消费者接口兼容（有关规范，请参见http://effbot.org/zone/consumer.htm）。

   但是，更仔细地查看消费者接口，似乎feed()所需的语义与send()不同，因为send()不能有意义地对刚刚启动的生成器调用。此外，当前定义的消费者接口不包含对StopIteration的处理。

   因此，创建一个简单的装饰器来包装生成器函数以使其符合消费者接口可能更有用。例如，它可以使用初始next()调用预热生成器，捕获 StopIteration，甚至可能通过重新调用生成器函数提供reset()。

示例

1. 一个简单的消费者装饰器，使生成器函数在最初调用时自动前进到其第一个 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
   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. 一个简单的协程调度器或蹦床，它允许协程通过产出它们希望调用的协程来调用其他协程。协程产出的任何非生成器值都会返回给调用该产出值的协程。类似地，如果协程引发异常，则异常会传播到其调用者。实际上，此示例模拟了 Stackless Python 中使用的简单任务，只要您使用 yield 表达式来调用原本会阻塞的例程即可。这只是一个非常简单的示例，还有可能实现更复杂的调度器。（例如，现有的 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. 一个简单的回显服务器，以及使用蹦床运行它的代码（假设存在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的致谢部分。

参考文献

待定。

版权

本文档已置于公共领域。