于是就有了pep342。

pep342中提到了一个 send()方法，允许我们把一个"stuff"送回生成器里面，让他接著运行。来看下面这个例子：

def jumping_range(up_to):
"""Generator for the sequence of integers from 0 to up_to, exclusive.

Sending a value into the generator will shift the sequence by that amount.
"""
index = 0
while index < up_to:
jump = yield index
if jump is None:
jump = 1
index += jump

if __name__ == __main__:
iterator = jumping_range(5)
print(next(iterator)) # 0
print(iterator.send(2)) # 2
print(next(iterator)) # 3
print(iterator.send(-1)) # 2
for x in iterator:
print(x) # 3, 4

这里的 send把一个『stuff』送进去给生成器，赋值给 jump，然后判断jump 是不是 None，来执行对应的逻辑。

python3.3 yield from

自从Python2.5之后，关于生成器就没做什么大的改进了，直到 Python3.3时提出的pep380。这个 pep 提案提出了 yieldfrom这个可以理解为语法糖的东西，使得编写生成器更加简洁：

def lazy_range(up_to):
"""Generator to return the sequence of integers from 0 to up_to, exclusive."""
index = 0
def gratuitous_refactor():
nonlocal index
while index < up_to:
yield index
index += 1
yield from gratuitous_refactor()

第一节我们已经详细讲过 yield from 了，这里就不赘述了。

python3.4 asyncio模块

插播：事件循环（eventloop）

如果你有 js 编程经验，肯定对事件循环有所了解。

理解一个概念，最好也是最有bigger的就是翻出 wikipedia：

an event loop "is a programming construct that waits for and dispatches events or messages in a program" - 来源于Event loop - wikipedia

简单来说，eventloop 实现当 A 事件发生时，做 B 操作。拿浏览器中的JavaScript事件循环来说，你点击了某个东西（A 事件发生了），就会触发定义好了的 onclick函数（做 B 操作）。

在 Python 中，asyncio 提供了一个 eventloop（回顾一下上一篇的例子），asyncio 主要聚焦的是网路请求领域，这里的『A 事件发生』主要就是 socket 可以写、 socket可以读(通过 selectors模块)。

到这个时期，Python 已经通过 Concurrentprogramming的形式具备了非同步编程的实力了。

Concurrentprogramming只在一个 thread 里面执行。go 语言blog 中有一个非常不错的视频：Concurrency is not parallelism，很值得一看。

这个时代的 asyncio 代码

这个时期的asyncio代码是这样的：

import asyncio

# Borrowed from http://curio.readthedocs.org/en/latest/tutorial.html.
@asyncio.coroutine
def countdown(number, n):
while n > 0:
print(T-minus, n, ({}).format(number))
yield from asyncio.sleep(1)
n -= 1

loop = asyncio.get_event_loop()
tasks = [
asyncio.ensure_future(countdown("A", 2)),
asyncio.ensure_future(countdown("B", 3))]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

输出结果为：

T-minus 2 (A)
T-minus 3 (B)
T-minus 1 (A)
T-minus 2 (B)
T-minus 1 (B)

这时使用的是 asyncio.coroutine修饰器,用来标记某个函数可以被 asyncio 的事件循环使用。

看到 yieldfromasyncio.sleep(1)了吗？通过对一个asyncio.Future object yieldfrom，就把这个future object 交给了事件循环，当这个 object 在等待某件事情发生时（这个例子中就是等待 asyncio.sleep(1)，等待 1s 过后），把函数暂停，开始做其他的事情。当这个future object 等待的事情发生时，事件循环就会注意到，然后通过调用 send()方法，让它从上次暂停的地方恢复运行。

break down 一下上面这个代码：

事件循环开启了两个 countdown()协程调用，一直运行到 yieldfromasyncio.sleep(1)，这会返回一个 future object，然后暂停，接下来事件循环会一直监视这两个future object。1秒过后，事件循环就会把 future object send()给coroutine，coroutine又会接著运行，列印出 T-minus2(A)等。

python3.5 async await

python3.4的

@asyncio.coroutine
def py34_coro():
yield from stuff()

到了 Python3.5，可以用一种更加简洁的语法表示：

async def py35_coro():
await stuff()

这种变化，从语法上面来讲并没什么特别大的区别。真正重要的是，是协程在 Python 中哲学地位的提高。 在 python3.4及之前，非同步函数更多就是一种很普通的标记（修饰器），在此之后，协程变成了一种基本的抽象基础类型（abstract base class）：class collections.abc.Coroutine。

How the heck does async/await work in Python 3.5?一文中还讲到了 async、 await底层 bytecode 的实现，这里就不深入了，毕竟篇幅有限。

把 async、await看作是API 而不是 implementation

Python 核心开发者（也是我最喜欢的 pycon talker 之一）David M. Beazley在PyCon Brasil 2015的这一个演讲中提到：我们应该把 async和 await看作是API，而不是实现。 也就是说， async、 await不等于 asyncio， asyncio只不过是 async、 await的一种实现。（当然是 asyncio使得非同步编程在 Python3.4中成为可能，从而推动了 async、 await的出现）

他还开源了一个项目https://github.com/dabeaz/curio，底层的事件循环机制和 asyncio 不一样， asyncio使用的是 futureobject， curio使用的是 tuple。同时，这两个 library 有不同的专注点， asyncio 是一整套的框架， curio则相对更加轻量级，用户自己需要考虑到事情更多。

How the heck does async/await work in Python 3.5?此文还有一个简单的事件循环实现例子，有兴趣可以看一下，后面有时间的话也许会一起实现一下。

总结一下

• 协程只有一个 thread。
• 操作系统调度进程、协程用事件循环调度函数。
• async、await 把协程在 Python 中的哲学地位提高了一个档次。

最重要的一点感受是：Nothing is Magic。现在你应该能够对 Python 的协程有了在整体上有了一个把握。

如果你像我一样真正热爱计算机科学，喜欢研究底层逻辑，欢迎关注我的微信公众号：

推荐阅读：