python -- 异步、asyncio

本文主要是介绍python -- 异步、asyncio，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

协程

协成不是操作系统提供的，是程序员人为创造的。

协成（Coroutine）, 也可以被称为微线程，是一种用户态内的上下文切换技术，简而言之，其实就是通过一个线程实现代码块相互切换执行。

举个例子：

def func1():print(1)...print(2)def func2():print(3)...print(4)func1()
func2()

正常运行： 1 2 3 4
协程运行效果：1 3 2 4

实现协成的方法

• greenlet， 早期模块。
• yield 关键字
• asyncio 装饰器（python3.4）
• async、await（python3.7）[推荐，主讲]

greenlet实现协程

pip install greenlet

运行结果： 1 3 2 4

yield 关键字

def func1():yield 1yield from func2()yield 2def func2():yield 3yield 4f1 = func1()
for item in f1:print(item)

运行结果： 1 3 4 2

asyncio async & await（重点）

• 遇到IO阻塞自动切换

import asyncioasync def func1():print(1)await asyncio.sleep(2)print(2)async def func2():print(3)print(4)tasks = [asyncio.ensure_future( func1() ),asyncio.ensure_future( func2() ),
]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

先尝试运行理解，后面详细讲解

协程的意义

在一个线程中如果遇到IO等待时间，线程不会傻傻等待，利用空闲时间再去干点其他事。

案例：去下载三张图片（网络IO）

• 普通三张图片（同步）

import requestsdef download_img(url):print('开始下载：', url)# 发送请求response = requests.get(url)# 保存图片file_name = url.split('/')[-1]with open(file_name, mode='wb') as f:f.write(response.content)if __name__ == '__main__':url_list = ['url1', 'url2', 'url3']for url in url_list:download_img(url)

结果：url1（下载，结束）–>url2（下载，结束）–>url3（下载，结束）

• 协程方式（异步）

import asyncio
import aiohttpasync def download_img(session, url):print('开始下载：', url)# 发送请求async with session.get(url, verify_ssl=False) as response:content = await response.content.read()# 保存图片file_name = url.split('/')[-1]with open(file_name, mode='wb') as f:f.write(content)async def main():async with aiohttp.client() as session:url_list = ['url1', 'url2', 'url3']tasks = [asyncio.create_task(download_img(session, url)) for url in url_list]await asyncio.wait(tasks)if __name__ == '__main__':asyncio.run(main())

结果： 下载（url1, url2, url3） -同时下载->完成（url1, url2, url3）

协程是实现异步的一种方式！！！不是唯一方式。

异步编程

事件循环

理解成为一个死循环，去检测并执行某些代码。

以上描述的是以下代码：

# 去生成或获取一个时间循环
loop = asyncio.get_event_loop()
# 将任务放到“任务列表”
loop.run_until_complete(任务)

快速上手

协程函数，定义函数时，async def 函数名
协程对象，执行协程函数()得到的协程对象。

async def func():pass
result = func()

注意：执行协程函数对象，函数内部代码不会执行。

async def func():print('执行我吧')
result = func()loop = asyncio.get_event_loop()
loop.run_until_complete(result)# 或者 python3.7以上
asyncio.run(result)

await

await + 可等待的对象（协程对象、Future、Task对象–>IO等待）

import asyncioasync def func():print('执行我吧')response = await asyncio.sleep(2)print('结束：', response)result = func()
asyncio.run(result)

结果：

执行我吧
结束： None

await 就是等待对象得到结果之后再继续向下走

Task对象

在事件循环中，添加多个任务

• 示例1

# 示例1
import asyncioasync def func():print(1)response = await asyncio.sleep(2)print('2')return '结束func'async def main():print('main开始')# 创建task对象task1 = asyncio.create_task(func())# 再次创建task2 = asyncio.create_task(func())print('main结束')re1 = await task1re2 = await task2print(re1, re2)asyncio.run(main())

结果：

main开始
main结束
1
1
2
2
结束func 结束func

• 示例2:

# 示例2
import asyncioasync def func():print(1)response = await asyncio.sleep(2)print('2')return '结束func'async def main():print('main开始')# 创建task对象task_list = [asyncio.create_task(func())]print('main结束')done,pending = await asyncio.wait(task_list, timeout=2) # 最多等2秒print(done) # 已完成集合print(pending) # 未完成集合asyncio.run(main())

asyncio.Future对象

Task 继承 Future，Task 对象内部await 结果的处理基于Future对象来的。

• 示例1

import asyncioasync def main():# 获取当前循环loop = asyncio.get_running_loop()# 创建一个任务（Future对象），这个任务什么都不干fut = loop.create_future()# 等待任务最终结果（Future对象），没有结果则会一直等待下去await futasyncio.run(main())

• 示例2

import asyncioasync def set_after(fut):await asyncio.sleep(2)fut.set_result('666')async def main():# 获取当前循环loop = asyncio.get_running_loop()# 创建一个任务（Future对象），这个任务什么都不干fut = loop.create_future()# 创建一个任务（Task对象），绑定了set_after函数# fut.set_result('666')await loop.create_task(set_after(fut))# 等待Future对象获取最终结果，否则一直等待下去data = await futprint(data)# 等待任务最终结果（Future对象），没有结果则会一直等待下去await futasyncio.run(main())

concurrent.futures.Future 对象

使用线程池、进程池实现异步操作时用到的对象。

import time
from concurrent.futures import Future
from concurrent.futures.thread import ThreadPoolExecutor
from concurrent.futures.process import ProcessPoolExecutordef func(value):time.sleep(1)print(value)return 1# 创建线程池
pool = ThreadPoolExecutor(max_workers=5)# 创建进程池
# pool = ThreadPoolExecutor(max_workers=5)for i in range(10):fut = pool.submit(func, i)print(fut)

以后写代码可能多线程、进程和协程交叉使用。

这篇关于python -- 异步、asyncio的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---