Python协程&asyncio&异步编程

概述1、协程简介协程，又称微线程，纤程。协程的作用是在执行函数A时可以随时中断去执行函数B，然后中断函数B继续执行函数A（可以自由切换）。但这一过程并不是函数调用，这一整个过程看似像多线程，然而协程只有一个线程执行。2、实现协程的方法greenlet早期模块yield关键字asyncio装饰 1、协程简介

协程，又称微线程，纤程。协程的作用是在执行函数A时可以随时中断去执行函数B，然后中断函数B继续执行函数A（可以自由切换）。但这一过程并不是函数调用，这一整个过程看似像多线程，然而协程只有一个线程执行。

2、实现协程的方法greenlet早期模块yIEld 关键字asyncio 装饰器(python3.4)async、await关键字(python3.5)[推荐]2.1、 greenlet实现协程

安装greenletpip install greenlet

from greenlet import greenletdef func1():    print(1)  # 第二步 打印1    gr2.switch()  # 第三步，切换到func2函数    print(2)  # 第六步, 打印2    gr2.switch()  # 第七步 切换到fun2函数, 从上一次执行的位置继续向后执行def func2():    print(3)  # 第四步 打印3    gr1.switch()  # 第五步 切换到fun1函数，从上一次执行的位置继续向后执行    print(4)  # 第八部 打印4gr1 = greenlet(func1)gr2 = greenlet(func2)gr1.switch()  # 第一步 去执行func1函数

2.2、yIEld关键字

def fun1():    yIEld 1    yIEld from fun2()    yIEld 2def fun2():    yIEld 3    yIEld 4f1 = fun1()for item in f1:    print(item)

2.3、asyncio

python3.4

import asyncio@asyncio.coroutinedef fun1():    print(1)    yIEld from asyncio.sleep(2)    print(2)@asyncio.coroutinedef fun2():    print(3)    yIEld from asyncio.sleep(2) #遇到IO耗时 *** 作,自动切换到tasks中的其他任务。    print(4)tasks = [    asyncio.ensure_future(fun1()),    asyncio.ensure_future(fun2())]loop = asyncio.get_event_loop()loop.run_until_complete(asyncio.wait(tasks))

2.4、async & await关键字

python3.5

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

3.1、事件循环

理解成一个死循环

# 伪代码任务列表 = [任务1, 任务2, 任务3]while True:	# 可执行的任务列表,已完成的任务列表 = 去任务列表检查所有任务, 将'可执行'和'已完成'的任务返回	for 就绪任务 in 可执行的任务列表:		执行已就绪的任务	for 已完成的任务 in 已完成的任务列表:		在任务列表中移除 已完成的任务	如果任务列表中的任务完成, 则终止循环

import asyncio# 去生成一个事件循环loop = asyncio.get_event_loop()# 将任务放到任务列表loop.run_until_complete(任务)

3.2、快速上手

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

注意: 执行协程函数创建协程对象, 代码内部函数不会执行

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

import asyncioasync def fun():	print('学习协程')result = func()# 去生成一个事件循环loop = asyncio.get_event_loop()# 将任务放到任务列表loop.run_until_complete(result)asyncio.run(result) # python3.7

3.3、await 关键字

await + 可等待的对象(协程对象, Future,Task对象 ->IO等待)

import asyncioasync def other():    print('start')    await asyncio.sleep(2)    print("end")    return '返回值'async def fun():    print('执行协程函数内部代码')    # 遇到IO *** 作挂起当前线程(任务), 等IO *** 作完成之后再继续往下执行。事件循环可以去执行其他协程(任务)    result = await other()    print('IO请求结束,结果为', result)asyncio.run(fun())

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

3.4、Task对象

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

Tasks用于并发调度线程, 通过asyncio.create_task(协程对象)的方式创建Task对象,这样可以让协程加入事件循环中等待被调度执行。除了使用 asyncio.create_task()函数外,还可以用底层级的loop.create_task()或ensure_future()函数。不建议手动实例化Task对象。

import asyncioasync def func():    print(1)    await asyncio.sleep(2)    print(2)    return "返回值"async def main():    print("main开始")    # 创建协程，将协程封装到Task对象中并添加到事件循环的任务列表中，等待事件循环去执行（默认是就绪状态）。    # 在调用    task_List = [        asyncio.create_task(func(), name="n1"),        asyncio.create_task(func(), name="n2")    ]    print("main结束")    # 当执行某协程遇到IO *** 作时，会自动化切换执行其他任务。    # 此处的await是等待所有协程执行完毕，并将所有协程的返回值保存到done    # 如果设置了timeout值，则意味着此处最多等待的秒，完成的协程返回值写入到done中，未完成则写到pending中。    done, pending = await asyncio.wait(task_List, timeout=None)    print(done, pending)asyncio.run(main())

3.5、asyncio.Future对象

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

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

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函数，函数内部在2s之后，会给fut赋值。    # 即手动设置future任务的最终结果，那么fut就可以结束了。    await loop.create_task(set_after(fut))    # 等待 Future对象获取 最终结果，否则一直等下去    data = await fut    print(data)asyncio.run(main())

3.6、concurrent.future.Future对象

这个对象是基于线程池和进程池实现异步 *** 作时使用的对象。

import timefrom concurrent.futures import Futurefrom concurrent.futures.thread import ThreadPoolExecutorfrom concurrent.futures.process import ProcesspoolExecutordef func(value):    time.sleep(1)    print(value)    return 123pool = ThreadPoolExecutor(max_workers=5)# 或 pool = ProcesspoolExecutor(max_workers=5)for i in range(10):    fut = pool.submit(func, i)    print(fut)

4.1、uvloop

uvloop是 asyncio 中的事件循环的替代方案，替换后可以使得asyncio性能提高。事实上，uvloop要比nodeJs、gevent等其他python异步框架至少要快2倍，性能可以比肩Go语言。

#安装pip3 install uvloop

在项目中想要使用uvloop替换asyncio的事件循环也非常简单，只要在代码中这么做就行。

import asyncioimport uvloopasyncio.set_event_loop_policy(uvloop.EventLoopPolicy())# 编写asyncio的代码，与之前写的代码一致。# 内部的事件循环自动化会变为uvloopasyncio.run(...)

总结

以上是内存溢出为你收集整理的Python协程&asyncio&异步编程全部内容，希望文章能够帮你解决Python协程&asyncio&异步编程所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。