python3 协程实战（python3经典编程案例）

柔光的暖阳◎ 2022-09-08 06:17 142阅读 0赞

1.  [python3多进程实战（python3经典编程案例）][python3_python3]
2.  [python3多线程实战（python3经典编程案例）][python3_python3 1]
3.  [python3 协程实战（python3经典编程案例）][python3 _python3]

## 一. 定义协程 ##

协程是轻量级线程，拥有自己的寄存机上下文和栈。  
协程调度切换时，将寄存器上下文和栈保存到其他地方，再切回来时，恢复先前保存的寄存器上下文和栈。

协程的应用场景：I/O密集型任务，和多线程类似，但协程调用时在一个线程内进行的，是单线程，切换的开销小，因此，效率上略高于多线程。

python3.4加入了协程，以生成器对象为基础，python3.5加了async/await，使用协程更加方便。

python中使用协程最方便的库是asyncio，引入该库才能使用async和await关键字

*  async: 定义一个协程；async定义的方法无法直接执行，必须注册到时间循环中才能执行。
 *  await: 用于临时挂起一个函数或方法的执行。

根据官方文档，await后面的对象必须是如下类型之一：

*  一个原生的coroutine对象；
 *  一个由types.coroutine()修饰的生成器，这个生成器可以返回coroutine对象；
 *  一个包含await方法的对象返回的一个迭代器。

案例1：

import asyncio
    import time
    
    
    async def task():
        print(f"{ time.strftime('%H:%M:%S')} task 开始 ")
        time.sleep(2)
        print(f"{ time.strftime('%H:%M:%S')} task 结束")
    
    
    coroutine = task()
    print(f"{ time.strftime('%H:%M:%S')} 产生协程对象 { coroutine},函数并未被调用")
    loop = asyncio.get_event_loop()
    print(f"{ time.strftime('%H:%M:%S')} 开始调用协程任务")
    start = time.time()
    loop.run_until_complete(coroutine)
    end = time.time()
    print(f"{ time.strftime('%H:%M:%S')} 结束调用协程任务, 耗时{ end - start} 秒")

案例2：  
为任务绑定回调函数

import asyncio
    import time
    
    
    async def _task():
        print(f"{ time.strftime('%H:%M:%S')} task 开始 ")
        time.sleep(2)
        print(f"{ time.strftime('%H:%M:%S')} task 结束")
        return "运行结束"
    
    
    def callback(task):
        print(f"{ time.strftime('%H:%M:%S')} 回调函数开始运行")
        print(f"状态：{ task.result()}")
    
    
    coroutine = _task()
    print(f"{ time.strftime('%H:%M:%S')} 产生协程对象 { coroutine},函数并未被调用")
    task = asyncio.ensure_future(coroutine)  # 返回task对象
    task.add_done_callback(callback)  # 为task增加一个回调任务
    loop = asyncio.get_event_loop()
    print(f"{ time.strftime('%H:%M:%S')} 开始调用协程任务")
    start = time.time()
    loop.run_until_complete(task)
    end = time.time()
    print(f"{ time.strftime('%H:%M:%S')} 结束调用协程任务, 耗时{ end - start} 秒")

## 二. 并发 ##

如果需要执行多次协程任务并尽可能的提高效率，这时可以定义一个task列表，然后使用asyncio的wait()方法执行即可。

import asyncio
    import time
    
    
    async def task():
        print(f"{ time.strftime('%H:%M:%S')} task 开始 ")
        # 异步调用asyncio.sleep(1):
        await asyncio.sleep(2)
        # time.sleep(2)
        print(f"{ time.strftime('%H:%M:%S')} task 结束" )
    
    # 获取EventLoop:
    loop = asyncio.get_event_loop()
    # 执行coroutine
    tasks = [task() for _ in range(5)]
    start = time.time()
    loop.run_until_complete(asyncio.wait(tasks))
    loop.close()
    end = time.time()
    print(f"用时 { end-start} 秒")

## 三. 异步请求 ##

先启动一个简单的web服务器

from flask import Flask
    import time
    
    app = Flask(__name__)
    
    
    @app.route('/')
    def index():
        time.sleep(3)
        return 'Hello World!'
    
    
    if __name__ == '__main__':
        app.run(threaded=True)

案例1：请求串行走下来，没有实现挂起。

import asyncio
    import requests
    import time
    
    start = time.time()
    
    
    async def request():
        url = 'http://127.0.0.1:5000'
        print(f'{ time.strftime("%H:%M:%S")} 请求 { url}')
        response = requests.get(url)
        print(f'{ time.strftime("%H:%M:%S")} 得到响应 { response.text}')
    
    tasks = [asyncio.ensure_future(request()) for _ in range(5)]
    loop = asyncio.get_event_loop()
    loop.run_until_complete(asyncio.wait(tasks))
    
    end = time.time()
    print(f'耗时 { end - start} 秒')

使用await将耗时等待的操作挂起，让出控制权。  
当协程执行时遇到await, 时间循环就会将本协程挂起，转而去执行别的协程，知道其他的协程挂起或者执行完毕。

案例2：异步IO请求实例  
将请求页面的代码封装成一个coroutine对象，在requests中尝试使用await挂起当前执行的I/O.

import asyncio
    import requests
    import time
    
    
    async def get(url):
        return requests.get(url)
    
    
    async def request():
        url = "http://127.0.0.1:5000"
        print(f'{ time.strftime("%H:%M:%S")} 请求 { url}')
        response = await get(url)
        print(f'{ time.strftime("%H:%M:%S")} 得到响应 { response.text}')
    
    
    start = time.time()
    tasks = [asyncio.ensure_future(request()) for _ in range(5)]
    loop = asyncio.get_event_loop()
    loop.run_until_complete(asyncio.wait(tasks))
    end = time.time()
    print(f"耗时 { end - start} 秒")

上面的带动并未达到预期的并发效果。原因是requests不是异步请求，无论如何改封装都无济于事，因此需要找真正的IO请求，aiohttp是一个支持异步请求的库，可以用它和anyncio配合，实现异步请求操作。  
案例3：使用aiohttp库

import asyncio
    import aiohttp
    import time
    
    now = lambda: time.strftime("%H:%M:%S")
    
    
    async def get(url):
        session = aiohttp.ClientSession()
        response = await session.get(url)
        result = await response.text()
        await session.close()
        return result
    
    
    async def request():
        url = "http://127.0.0.1:5000"
        print(f"{ now()} 请求 { url}")
        result = await get(url)
        print(f"{ now()} 得到响应 { result}")
    
    
    start = time.time()
    tasks = [asyncio.ensure_future(request()) for _ in range(5)]
    loop = asyncio.get_event_loop()
    loop.run_until_complete(asyncio.wait(tasks))
    
    end = time.time()
    print(f"耗时 { end - start } 秒")

运行结果符合预期要求，耗时由15秒变成了3秒，实现了并发访问。

将任务数5改成100，运行时间也在3秒多一点，多出来的时间就是I/O时延了。  
可见，使用异步协程之后，几乎可以在相同时间内实现成百上千次的网络请求。

把这个技术用在爬虫中，速度提升会非常的可观。

[python3_python3]: https://cuiyonghua.blog.csdn.net/article/details/119915966
[python3_python3 1]: https://cuiyonghua.blog.csdn.net/article/details/119917182
[python3 _python3]: https://cuiyonghua.blog.csdn.net/article/details/119917906