於是就有了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 的協程有了在整體上有了一個把握。

如果你像我一樣真正熱愛計算機科學，喜歡研究底層邏輯，歡迎關注我的微信公眾號：

推薦閱讀：