python协程 & asyncio & 异步编程（一） 协程

一、引入

协程不是计算机提供，程序员人为创造

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

实现协程有几种方法：
1、greenlet，早期模块（了解即可）
2、yield 关键字　（了解即可）
3、asyncio 标准库 装饰器 （python3.4＋引入）
4、async、await关键字 （python3.５＋推荐）

1.1 asyncio
在python3.4及之后的版本

import asyncio@asyncio.coroutinedeffunc1():print(1)yieldfrom asyncio.sleep(2)print(2)deffunc2():print(3)yieldfrom asyncio.sleep(2)print(4)


tasks=[asyncio.ensure_future(func1()),
         asyncio.ensure_future(func2()),]

loop= asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

注意：遇到IO阻塞自动切换

1.2 async & await 关键字

import asyncioasyncdeffunc1():print(1)await asyncio.sleep(2)print(2)asyncdeffunc2():print(3)await asyncio.sleep(2)print(4)


tasks=[asyncio.ensure_future(func1()),
         asyncio.ensure_future(func2()),]

loop= asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

二、协程的意义

在一个线程中如果遇到IO等待时间，线程不会等待，利用空闲时间，再去完成其它任务。
案例，下载三张图片：

1、普通方式（同步）：

"""
时间:

更改记录:

重要说明:

"""import requestsimport uuiddefget_file_name():returnstr(uuid.uuid4())+'.png'defdownload_image(url):print('start download', url)
    response= requests.get(url)print('download done')

    file_name= get_file_name()withopen(file_name, mode='wb')as file_obj:
        file_obj.write(response.content)if __name__=='__main__':
    urls=['https://t7.baidu.com/it/u=813347183,2158335217&fm=193&f=GIF','https://t7.baidu.com/it/u=1819644070,1305753509&fm=193&f=GIF','https://t7.baidu.com/it/u=124476473,2583135375&fm=193&f=GIF']for urlin urls:
        download_image(url)

2、协程方式（异步）：

"""
时间:

更改记录:

重要说明:  python3.7+

"""import uuidimport aiohttpimport asynciodefget_file_name():returnstr(uuid.uuid4())+'.png'asyncdefdownload_image(session, url):print('start download', url)asyncwith session.get(url, verify_ssl=False)as response:
        content= response.content.read()
        file_name= get_file_name()withopen(file_name, mode='wb')as file_obj:
            file_obj.write(content)print('download done')asyncdefmain(urls):asyncwith aiohttp.ClientSession()as session:
        tasks=[asyncio.create_task(download_image(session, url))for urlin urls]await asyncio.wait(tasks)if __name__=='__main__':
    urls=['https://t7.baidu.com/it/u=813347183,2158335217&fm=193&f=GIF','https://t7.baidu.com/it/u=1819644070,1305753509&fm=193&f=GIF','https://t7.baidu.com/it/u=124476473,2583135375&fm=193&f=GIF']
    
    asyncio.run(main(urls))

三、异步编程

1 事件循环
asyncio原理，可以理解为一个死循环，去检测并执行某些代码

伪代码理解：

任务列表= 【任务1， 任务2，任务3】whileTrue:#  可执行的任务列表，已完成的任务列表 = 去任务列表中检查所有的任务，将“可执行”和“已完成”的任务返回for 就绪任务in 可执行的任务列表：
		      执行就绪任务()for 已完成的任务in 已完成的任务列表：
		       在任务列表中移除，已完成的任务
		       
		 如果任务列表中所有任务已完成，则终止执行

2 快速上手

(1) 协程函数： 定义函数时： async def 函数名
(2) 协程对象： 执行协程函数 得到的就是协程对象

asyncdeffunc():pass

result= func()

注意：这样执行协程函数时，函数内部代码不会执行，会返回创建的协程对象

如果想要运行协程函数内部代码，必须要将协程对象交给事件循环来处理

import asyncioasyncdeffunc():print('123456')

result= func()# 让事件循环执行协程函数
loop= asyncio.get_event_loop()
loop.run_until_complete(result)# python3.7+简便写法
asyncio.run(result)

3 await
await + 可等待的对象（协程对象、FUTURE对象、TASK对象）

示例１：

import asyncioasyncdeffunc():print('hello')
	response=await asyncio.sleep(3)print('end', response)

asyncio.run(func())

示例２：

import asyncioasyncdefothers():print('start')await asyncio.sleep(3)print('end')return'返回值'asyncdeffunc():print('执行协程函数内部代码')# 遇到IO操作挂起当前协程（任务），等IO操作完成之后再继续向下执行，当前协程挂起时，事件循环可以去执行其它协程（任务）
    response=await others()print('执行协程函数内部代码')

asyncio.run(func())

示例３：

import asyncioasyncdefothers():print('start')await asyncio.sleep(3)print('end')return'返回值'asyncdeffunc():print('执行协程函数内部代码')# 遇到IO操作挂起当前协程（任务），等IO操作完成之后再继续向下执行，当前协程挂起时，事件循环可以去执行其它协程（任务）
    response1=await others()print('执行协程函数内部代码1', response1)
    response2=await others()print('执行协程函数内部代码2', response2)
    
asyncio.run(func())

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

4 Task对象
在事件循环中添加多个任务的。
TASK用于并发调度协程，通过asynic.create_task（协程对象）的方式创建TASK对象，这样可以让协程加入事件循环中等待被调度执行，除了使用asyncio.create_task()函数以外，还可以用低层级的loop.create_task() 或ensure_future() 函数，不建议手动实例化Task对象。
注意：asyncio.create_task()函数在Python3.7中被加入，3.7之前可以改用低层级的asyncio.ensure_future()函数

示例1

import asyncioasyncdeffunc():print(1)await asyncio.sleep(2)print(2)return'返回值'asyncdefmain():print('main start')# 创建TASK对象，将当前执行func函数任务添加到事件循环
    task1= asyncio.create_task(func())

    task2= asyncio.create_task(func())print('main end')# 当执行某协程遇到IO操作时，会自动化切换很乖其他任务# 此处的await是等待相对应的协程全部执行完并获取结果
    ret1=await task1
    ret2=await task2print(ret1, ret2)
    
asyncio.run( main())

示例2:

import asyncioasyncdeffunc():print(1)await asyncio.sleep(2)print(2)return'返回值'asyncdefmain():print('main start')

    task_list=[
        asyncio.create_task(func()),
        asyncio.create_task(func())]print('main end')# done是返回值的集合
    done, pending=await asyncio.wait(task_list, timeout=None)print(done, pending)


asyncio.run( main())

示例3

import asyncioasyncdeffunc():print(1)await asyncio.sleep(2)print(2)return'返回值'


task_list=[
    func(),
    func()]


done, pending= asyncio.run(asyncio.wait(task_list))print(done)

5 Future对象

Task类的基类，Task类内部await结果和处理基于Future类来的

示例1：

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

示例2：

asyncdefset_after(fut):await asyncio.sleep(2)
    fut.set_result("12")asyncdefmain():# 获取当前事件循环
    loop= asyncio.get_running_loop()# 创建一个任务（FUTURE对象），这个任务什么都不干
    fut= loop.create_future()# 即手动设置FUTURE任务的最终结果,fut就可以结束 了await loop.create_task(set_after(fut))# 等待任务最终结果（FUTURE对象），没有结果则会一直等下去
	data=await futprint(data)async.run(main())

6 concurrent.futures.Future对象

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

import timefrom concurrent.futuresimport Futurefrom concurrent.futures.threadimport ThreadPoolExecutorfrom concurrent.futures.processimport ProcessPoolExecutordeffunc(value):
    time.sleep(1)print(value)# 创建线程池
pool= ThreadPoolExecutor(max_workers=5)# 创建进程池# pool = ProcessPoolExecutor(max_workers=5)for iinrange(10):
    fut= pool.submit(func, i)print(fut)

与协程交叉使用：
示例：

import timeimport asyncioimport concurrent.futuresdeffunc1():# 某个耗时操作
    time.sleep(2)return'func1 done'asyncdefmain():
    loop= asyncio.get_running_loop()
    
    fut= loop.run_in_executor(None, func1)

    result=await futprint('default thread pool', result)


asyncio.run(main())

三、异步编程实战案例

１、异步上下文管理器
此种对象通过定义__aenter__()和__aexit__() 方法来对async with语句中的环境进行控制

import asyncioclassAsyncContextManager:def__init__(self):
        self.conn=Noneasyncdefdo_someting(self):return666asyncdef__aenter__(self):
        self.conn=await asyncio.sleep(1)return selfasyncdef__aexit__(self):await asyncio.sleep(1)asyncdeffunc():asyncwith AsyncContextManager()as f:
        result=await f.do_someting()print(result)

asyncio.run(func())

2、uvloop

是asyncio中事件循环的替代方案，第三方框架，事件循环效率更高

import asyncioimport uvloop# 设置为使用uvloop代替默认loop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

3、异步操作redis
在使用python代码操作redis时，链接、操作、断开都是网络IO

import aioredis

4、异步操作MySql

import aiomysql

5、FastAPI框架

以fastAPI框架为例，了解异步WEB框架

pip3install fastapi
pip3install uvicorn

总结

最大的意义：通过一个线程利用其IO等待时间去做一些其他事情。