本文主要讲两个方面的东西，一个是迭代方面，对应是生成器，语法是yield。另一个方面是异步编程，对应是协程，语法是async。

yield

  首先生成器是用来迭代的。所以要先弄清可迭代的，容器，迭代器，生成器的关系。
  简单来说，可以for i in x这样用的x就是可迭代的。它包括容器和迭代器。

容器

  容器就像列表，可以放数据，为什么可以放for里面迭代呢，方便吧。

迭代器

  迭代器就是实现__iter__()和__next__()的，__iter__返回自己，__next__返回迭代的下一个值。在for里其实是隐式调用了__next__()。

class Iterator:
    def __init__(self):
        self.data = 0

    def __iter__(self):
        return self

    def __next__(self):
        self.data += 1
        if self.data > 5:
            raise StopIteration
        return self.data


if __name__ == '__main__':
    I = Iterator()
    try:
       for i in  I:
           print(i)
    except StopIteration:
        pass

  迭代器迭代完了后继续调用__next__()结合触发StopIteration错误。

生成器

  生成器就是一种特殊的迭代器。它外表像函数，但是用yield代替return。调用生成器会返回一个对象，显式或隐式（for里面）调用next就会执行到yield返回一个值，然后暂停，下次从这个地方继续。一个例子如下：

def f(max):
    n = 0
    while n < max:
        yield n
        n += 1


if __name__ == '__main__':
    for i in f(5):
        print(i)

  然后人们就想要是加入send()，可以给生成器发送信息，不就实现了协程么。所以就有了send()函数。用a = yield *，执行到yield暂停后，下次执行，就把send的值赋值给a。

def f(max):
    n = 0
    while n < max:
        a = yield n
        n = n + a + 1


if __name__ == '__main__':
    fun = f(5)
    print(fun.send(None))
    try:
        while True:
            print(fun.send(1))
    except StopIteration:
        pass

  这个代码输出的是0，2，4。当然，还有yield from等配合使用。这里就不讲了。

async/await

  这个语法是专门为协程设计的，为了使python更简洁好用。async def申明一个协程函数，函数里可以使用await等待其他协程函数执行完再继续执行自己的代码。

async def async_f():
    return 1


async def await_f():
    result = await async_f()
    return result + 1

if __name__ == '__main__':
    try:
        await_f().send(None)
    except StopIteration as e:
        print(e.value)

  输出2。但是这样好像没什么意义。其实这两条语法一般是结合asyncio标准库来用的。

import asyncio
async def hello():
    print('Send request')
    await asyncio.sleep(1)
    print('Get')


async def cal():
    n = 0
    for i in range(5):
        n += i
    print(n)


if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    tasks = [hello(), cal()]
    loop.run_until_complete(asyncio.wait(tasks))
    loop.close()

输出：
Send request
10（停顿1秒左右）
Get
异步编程适合IO操作，在等待的时候可以先进行其他操作，提高cpu利用率。asyncio正是这么一个帮忙自动切换协程的库。

异步生成器

  这个名词不知道准不准确，反正就是async和yield结合用法吧。这是一个买西红柿和马铃薯的例子。从货架上一个一个拿，没有了就叫售货员加。

import asyncio
all_potatos = [1, 1, 1, 1, 1]
all_tomatos = [1, 1, 1, 1, 1]


async def ask_for_potato():
    all_potatos.append(1)


async def ask_for_tomato():
    all_potatos.append(1)


async def take_potatos(num):
    count = 0
    while True:
        if len(all_potatos) == 0:
            await ask_for_potato()
        potato = all_potatos.pop()
        yield potato
        count += 1
        if count == num:
            break


async def take_tomatos(num):
    count = 0
    while True:
        if len(all_tomatos) == 0:
            await ask_for_tomato()
        tomato = all_tomatos.pop()
        yield tomato
        count += 1
        if count == num:
            break


async def buy_potatos():
    bucket = []
    async for i in take_potatos(50):
        bucket.append(i)
    print(len(bucket))


async def buy_tomatos():
    bucket = []
    async for i in take_potatos(50):
        bucket.append(i)
    print(len(bucket))

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    tasks = [buy_potatos(), buy_tomatos()]
    loop.run_until_complete(asyncio.wait(tasks))
    loop.close()