Python函数怎样用生成器函数实现协程 Python函数简单协程的创建与使用教程​

答案是生成器通过yield暂停和send()接收数据实现协程，具备双向通信能力，是async/await的底层基础，理解它有助于掌握Python异步编程原理。

Python函数通过生成器函数实现协程，核心在于

yield

关键字的暂停与恢复能力，以及

generator.send()

方法向暂停的生成器内部发送数据。这使得生成器不再仅仅是数据的生产者，也能成为数据的消费者，从而具备了协程（co-routine）的协作执行特性。

Python函数简单协程的创建与使用，本质上是利用了生成器的双向通信能力。一个生成器函数，当它包含

yield

表达式时，它就变成了一个生成器。而当这个

yield

表达式能够接收外部传入的值时（通过

send()

方法），它就具备了协程的雏形。

协程的基石：生成器的工作原理与实践

说起协程，很多人可能首先想到

async/await

，但追根溯源，Python中的协程概念其实是从生成器演变而来的。在我看来，理解生成器如何作为协程的基石，就像是理解汽车发动机的原理，即便你现在开的是电动车，知道内燃机的工作方式也能让你对机械原理有更深的洞察。

生成器最大的特点是它的“暂停”和“恢复”能力。一个普通的函数，一旦开始执行，就会一直运行到结束或遇到错误。但生成器不同，每当它遇到

yield

关键字，它就会暂停执行，将

yield

后的值返回给调用者，并保留当前的所有局部状态。下次调用

next()

或

send()

时，它会从上次暂停的地方继续执行。

立即学习“Python免费学习笔记（深入）”；

而

send()

方法，是让生成器从单向的数据流（只出不进）变成双向通信的关键。当你在生成器暂停在

yield

表达式处时，调用

generator.send(value)

，这个

value

就会成为

yield

表达式的返回值，注入到生成器内部。这就像是生成器在等待一个输入，然后根据这个输入继续它的工作。

举个例子，一个简单的协程可能看起来像这样：

def simple_coroutine():
print("Coroutine started, waiting for first value...")
x = yield  # 第一次暂停，等待外部发送数据
print(f"Received x: {x}, waiting for second value...")
y = yield x * 2 # 第二次暂停，发送 x*2 并等待新的数据
print(f"Received y: {y}, Coroutine finished.")
return "Done"
# 创建并启动协程
my_coro = simple_coroutine()
next(my_coro) # 启动协程，执行到第一个 yield 并暂停，输出 "Coroutine started..."
try:
# 发送第一个值到协程
result1 = my_coro.send(10) # 10 成为 yield 的返回值，赋给 x
print(f"External received from coroutine: {result1}") # 接收到 x * 2 (即 20)
# 发送第二个值
result2 = my_coro.send(5) # 5 成为第二个 yield 的返回值，赋给 y
print(f"External received from coroutine: {result2}") # 理论上这里不会有返回值，因为协程会执行到结束
except StopIteration as e:
print(f"Coroutine finished with return value: {e.value}")

这段代码展示了协程如何通过

yield

暂停，并通过

send()

接收外部数据并继续执行。第一次

next(my_coro)

是为了“预激”协程，让它运行到第一个

yield

语句并暂停。因为第一个

yield

表达式在没有

send()

的情况下，其返回值是

None

。

在生成器协程中传递数据与处理异常

在生成器协程中，数据传递和异常处理是其实现复杂逻辑的关键。理解这些机制，能让你更好地构建协作式的程序。

数据传递：
如前所述，

generator.send(value)

是向协程内部传递数据的主要方式。当协程在

yield

表达式处暂停时，

send()

方法将

value

注入到该

yield

表达式的左侧，使其成为表达式的返回值。

一个常见的“陷阱”是，你不能在协程启动（即第一次运行到

yield

）之前就使用

send()

发送非

None

的值。因为协程还没运行到

yield

，没有地方可以接收这个值。所以，通常的模式是先调用

next(generator)

来“预激”协程，或者直接调用

generator.send(None)

，这两种方式的效果是一样的，都是让协程运行到第一个

yield

并暂停。

异常处理：
生成器协程也支持异常的注入和处理，这通过

generator.throw(type, value=None, traceback=None)

方法实现。你可以通过这个方法在协程暂停的地方“抛出”一个异常。这个异常会像在协程内部正常发生一样被捕获和处理。

def error_handling_coroutine():
print("Coroutine started.")
try:
data = yield
print(f"Received data: {data}")
except ValueError as e:
print(f"Caught ValueError: {e}")
except Exception as e:
print(f"Caught general exception: {e}")
finally:
print("Coroutine cleanup.")
yield "Finished processing"
my_error_coro = error_handling_coroutine()
next(my_error_coro) # 预激
try:
my_error_coro.send("Hello") # 正常发送数据
my_error_coro.throw(ValueError, "Something went wrong!") # 注入一个 ValueError
my_error_coro.send("This won't be reached") # 这行代码不会执行，因为协程已经处理了异常或终止
except StopIteration as e:
print(f"Coroutine ended: {e.value}")

在这个例子中，

throw()

方法在

yield

暂停处注入了

ValueError

，协程内部的

try...except

块捕获并处理了它。如果协程内部没有捕获这个异常，它就会向上冒泡，最终在调用

throw()

的地方被捕获。

关闭协程：

generator.close()

方法用于关闭一个生成器协程。当调用

close()

时，生成器会在当前

yield

处抛出一个

GeneratorExit

异常。如果协程内部捕获并处理了这个异常，它应该重新抛出它，或者直接返回，否则Python解释器会抛出一个

RuntimeError

。这通常用于清理资源。

def cleanup_coroutine():
print("Cleanup coroutine started.")
try:
yield
except GeneratorExit:
print("GeneratorExit caught, performing cleanup...")
finally:
print("Final cleanup always runs.")
print("Cleanup coroutine finished.")
my_cleanup_coro = cleanup_coroutine()
next(my_cleanup_coro)
my_cleanup_coro.close() # 关闭协程

这些机制共同构成了生成器协程的强大之处，使得它们能够实现复杂的控制流和状态管理。

生成器协程与现代异步编程（async/await）有何不同？我们还需要学它吗？

这是一个非常好的问题，尤其是在Python 3.5引入

async/await

语法糖之后，很多人可能会觉得基于生成器的协程已经过时了。从我的经验来看，它们确实有所不同，但理解生成器协程的原理依然非常有价值。

主要区别：

1. 语法层面：

   • 生成器协程： 依赖

     yield

     和

     yield from

     （在Python 3.3引入，用于委托给子生成器，是

     async/await

     的前身）以及

     send()

     ,

     throw()

     ,

     close()

     等方法。代码看起来更像普通的生成器。

   • async/await

     ： 引入了

     async def

     定义协程函数，

     await

     关键字用于等待一个可等待对象（通常是另一个协程或Future）。语法更直观，更明确地表达了“等待”和“非阻塞”的意图。

2. 语义与意图：

   • 生成器协程： 它们的“协程”行为是基于生成器“暂停/恢复”的副作用。

     yield

     既可以用于生成数据，也可以用于暂停等待数据。这种双重含义有时会让人感到混淆。

   • async/await

     ： 明确地将协程定义为一种特殊的函数，

     await

     明确表示一个“暂停点”，它只会等待一个异步操作完成。这种分离使得代码意图更加清晰，更易于阅读和维护。

3. 生态系统与工具支持：

   • 生成器协程： 它们是Python异步演进的早期阶段，虽然可以实现协程，但缺乏像

     asyncio

     这样的标准库和框架的直接、强大支持。

   • async/await

     ： 它是Python官方推荐的异步编程方式，得到了

     asyncio

     、

     aiohttp

     、

     FastAPI

     等大量现代异步框架和库的全面支持，拥有更成熟的调度器、事件循环和调试工具。

我们还需要学它吗？

我的答案是：绝对需要！ 尽管

async/await

是未来的方向，但理解生成器协程并非毫无意义。

• 理解底层机制：

  async/await

  并非凭空出现，它在很大程度上是基于生成器（尤其是

  yield from

  ）实现的语法糖。理解生成器协程，能让你对Python异步编程的底层原理有更深刻的认识。当你遇到一些复杂的异步问题或需要优化时，这种底层理解会非常有帮助。

• 维护旧代码： 许多现有的Python项目，特别是在Python 3.5之前编写的，可能仍然在使用基于生成器的协程模式（例如某些早期版本的

  Tornado

  或自定义的微型框架）。如果你需要维护或调试这些代码，了解其工作原理是必不可少的。

• 特定场景下的灵活性： 在某些非常特定的、轻量级的协作任务中，你可能不需要引入整个

  asyncio

  事件循环的开销，而直接使用生成器协程就足够了。例如，构建一个简单的流水线处理器，其中每个阶段都可以在

  yield

  处暂停并等待前一个阶段的结果。

• 深入学习的阶梯： 对于任何希望深入学习Python并发和并行的人来说，从生成器到线程、进程，再到异步I/O，是一个非常自然的学习路径。生成器协程是理解更高级异步概念的一个重要过渡。

所以，即便你现在主要使用

async/await

，花时间理解生成器协程的工作方式，会让你成为一个更全面的Python开发者，能够更好地理解和驾驭Python的并发能力。它就像是学习了编程语言的汇编，虽然日常不常用，但关键时刻能帮你解决大问题。