Python协程

最新推荐文章于 2024-05-01 17:39:22 发布

Debris丶

最新推荐文章于 2024-05-01 17:39:22 发布

阅读量130

点赞数

分类专栏： Python 文章标签： Python 协程 asyncio Event Loop

本文链接：https://blog.csdn.net/qq_34377830/article/details/85000145

版权

Python 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

最近对Python中的协程挺感兴趣，这里记录对协程的个人理解。

要理解协程，首先需要知道生成器是什么。生成器其实就是不断产出值的函数，只不过在函数中需要使用yield这一个关键词将值产出。下面来看一个例子：

def gen():
    n = 0
    while True:
        yield n
        n += 1
        
        
g = gen()
print(g)  # <generator object gen at 0x00000246E165A7C8>
print(next(g))  # 输出结果为0
print(next(g))  # 输出结果为1

我们调用gen()函数并不会直接执行该函数，而是会得到一个生成器对象。对这个生成器对象调用next()函数，这个生成器对象会开始执行到第一个yield处，于是产出一个值0，注意：这时候gen()就暂停在yield处，直到第二次调用next()函数。

到这里我们可以发现，生成器函数是可以暂停的函数，它在调用方的驱使下（调用方使用next()函数），每次执行到yield处将yield后方的值产出给调用方后就暂停自己的执行，直到调用方下一次驱动它执行。

send

我们知道，生成器函数可以不断的产出值给调用方，那如果想要调用方传递值给生成器函数呢？这就自然而然的引入了send()函数。来看send()函数的使用：

def gen():
    s = yield "hello"
    print("用户传递进来的值为：%s" % s)
    yield s


g = gen()
print(next(g))
print(g.send("world"))

执行上面的代码，我们可以看到结果如下：

来看看上面代码的执行：首先调用gen()得到一个生成器对象，这时候生成器函数还没有开始执行，接着调用next()函数，生成器函数执行到第一个yield处，产出字符串hello后暂停执行，调用方得到产出的值打印输出。然后调用方通过send()发送了一个字符串world给生成器函数，这时候，生成器函数将world赋值给s，继续它的执行，直到第二个yield处，将调用方传递进来的world返回给调用方。

到这里我们可以发现，此时的生成器函数既可以暂停时产出值，又可以接收调用方传递进来的值恢复执行，这就和协程的思想差不多了。

yield from

python3.3中提出了这样一个表达式yield from，我所知道的这个表达式有两个用法：

第一个用法是简化for循环：

def func():
    for x in "ABC":
        yield x

for x in func():
    print(x)

上面的写法等同于：

def func():
    yield from "ABC"

for x in func():
    print(x)

这是yield from 的第一种用法，即后面跟一个可迭代的对象，yield from可以在调用方的驱使下将可迭代对象一个一个的输出。

第二个用法是作为委派生成器使用：

def func():
    """生成器函数"""
    n = 0
    while True:
        s = yield n
        if s is None:
            break
        n += 1
    return n


def deligate():
    """委派生成器"""
    result = yield from func()
    print("the result is : %s" % result)


def main():
    """调用方"""
    g = deligate()
    print(next(g))
    for i in range(3):
        print(g.send(i))
    # 在这里发送None给生成器，生成器不会产出值而抛出StopIteration异常
    try:
        g.send(None)
    except StopIteration:
        pass


if __name__ == '__main__':
    main()

在上面的代码中，委派生成器使用了yield from，这就使得调用方在得到生成器对象时，可以通过send()方法和真正的生成器（这里为func）直接通信。于是我们在调用方中使用for循环了3次，每次传递进去的值都会传递给func函数中的s，当我们最后传递进一个None时，真正的生成器跳出for循环并将n的值返回，这时候委派生成器得到func生成器的返回值并将它赋给result。这样就完成了调用方和真正的生成器函数之间的通信，并且真正的生成器在执行结束之后会将结果返回给委派生成器。

我们可以看到，使用了yield from的委派生成器其实就是为调用方和真正的生成器提供了一个通道，这个通道可以让它们直接通信。

Event Loop

在真正的理解协程之前，还有个东西时我觉得必须要理解的，那就是事件循环（Event Loop）。

协程是单线程的，单线程就意味着所有的任务需要在单线程上排队执行，也就是前一个任务没有执行完成，后一个任务就没有办法执行。在CPU密集型的任务之中，这样其实还行，但是如果我们的任务都是IO密集型的呢？也就是我们大部分的任务都是在等待网络的数据返回，等待磁盘文件的数据，这就会造成CPU一直在等待这些任务的完成再去执行下一个任务。

有没有什么办法能够让单线程的任务执行不这么笨呢？其实我们可以将这些需要等待IO设备的任务挂在一边嘛！这时候，如果我们的任务都是需要等待的任务，那么单线程在执行时遇到一个就把它挂起来，这里可以通过一个数据结构（例如队列）将这些处于执行等待状态的任务放进去，为什么是执行等待状态呢？因为它们正在执行但是又不得不等待例如网络数据的返回等等。直到将所有的任务都放进去之后，单线程就可以开始它的接连不断的表演了：有没有任务完成的小伙伴呀！快来我这里执行！

此时如果有某个任务完成了，它会得到结果，于是发出一个信号：我完成了。那边还在循环追问的单线程终于得到了答复，就会去看看这个任务有没有绑定什么回调函数呀？如果绑定了回调函数就进去把回调函数给执行了，如果没有，就将它所在的任务恢复执行，并将结果返回。

到这里事件循环的大致作用已经说完了，我们可以看到，仅仅有协程是不够的，我们还需要事件循环和它配合使用，这样才能让多个协程可以并发的执行。

Python3.4中，引入了asyncio包，这个包提供了关于事件循环的实现，这就使得在Python中使用协程实现高并发成为可能。我们来模拟一个爬虫：

import asyncio


@asyncio.coroutine
def get_html(url, name):
    print("%s get %s html start" % (name, url))
    yield from asyncio.sleep(2)
    print("%s get %s html end" % (name, url))


if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    # 创建两个协程
    tasks = [
        get_html("http://www.baidu.com", "A"),
        get_html("http://www.souhu.com", "B"),
    ]
    # 启动事件循环并将协程放进去执行
    loop.run_until_complete(asyncio.wait(tasks))

在上面的模拟爬虫的代码中，我们使用了装饰器@asyncio.coroutine来将这个get_html()函数定义为协程，在协程中使用了asyncio.sleep()函数模拟从网络请求数据。在执行的过程中，我们首先使用asyncio提供的get_event_loop()创建一个事件循环，这里我们不需要自己实现事件循环，接着创建两个协程，并将这两个协程扔到事件循环中执行。

运行上面代码，可以看到以下结果：

仔细观察，我们会发现在协程中并没有使用time.sleep()函数，而是使用了asyncio.sleep()函数，是因为time.sleep()函数会将整个线程休眠几秒，而asyncio.sleep()其实也是一个协程，这个协程将和事件循环直接通信并将一个Future对象交给事件循环，事件循环会一直监视着它直到它的任务完成（在这里就是休眠两秒），并不会将整个线程都停止执行。

到现在，我们可以使用基于生成器的协程和事件循环来做到高并发了。但是问题来了，这里是基于生成器的协程，生成器其实有自己的用法，为什么还要给它强加一个协程的用法呢？

async/await

Python3.5中引入了async/await这一组关键词，这就使得python可以定义原生协程了。await的用法和yield from用法类似，但是await后面只能跟Awaitable的对象（实现了__await__魔法方法），而yield from后面可以跟生成器、协程等等。

使用async/await修改上面的代码：

import asyncio


async def get_html(url, name):
    print("%s get %s html start" % (name, url))
    await asyncio.sleep(2)
    print("%s get %s html end" % (name, url))


if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    # 创建两个协程
    tasks = [
        get_html("http://www.baidu.com", "A"),
        get_html("http://www.souhu.com", "B"),
    ]
    # 启动事件循环并将协程放进去执行
    loop.run_until_complete(asyncio.wait(tasks))