引言

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

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

然而，如果能够在生成器暂停时将值或异常 传入 生成器，那么一个简单的协程调度器或 trampoline 函数 将允许协程在不阻塞的情况下相互 调用——这对于异步应用程序来说是一个巨大的福音。然后，这些应用程序可以编写协程通过将控制权交给 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 装饰器创建 reverse generator 的示例，该生成器接收图像并创建缩略图页面，然后将其发送给另一个消费者。这样的函数可以链接起来，形成高效的 consumers 处理管道，每个消费者都可以拥有复杂的内部状态

   @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. 一个简单的协程调度器或 trampoline，它允许协程通过 yield 他们希望调用的协程来 调用 其他协程。协程 yield 的任何非生成器值都将返回给 调用 yield 值的协程。同样，如果协程引发异常，异常将传播给其 调用者。实际上，这个例子模拟了 Stackless Python 中使用的简单 tasklet，只要您使用 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. 一个简单的 echo 服务器，以及使用 trampoline 运行它的代码（假定存在 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 的致谢部分。

参考资料

待定。

版权

本文档已置于公共领域。