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

最新推荐文章于 2022-07-20 17:43:18 发布
最新推荐文章于 2022-07-20 17:43:18 发布
阅读量172 收藏
点赞数
分类专栏： 异步编程 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/spjrual/article/details/119945719
版权

一、引入

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

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

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

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

import asyncio


@asyncio.coroutine
def func1():
    print(1)
    yield from asyncio.sleep(2)
    print(2)


def func2():
    print(3)
    yield from 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 asyncio


async def func1():
    print(1)
    await asyncio.sleep(2)
    print(2)


async def func2():
    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 requests
import uuid


def get_file_name():
    return str(uuid.uuid4()) + '.png'


def download_image(url):
    print('start download', url)
    response = requests.get(url)
    print('download done')

    file_name = get_file_name()
    with open(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 url in urls:
        download_image(url)

2、协程方式（异步）：

"""
时间:

更改记录:

重要说明:  python3.7+

"""

import uuid

import aiohttp
import asyncio


def get_file_name():
    return str(uuid.uuid4()) + '.png'


async def download_image(session, url):
    print('start download', url)
    async with session.get(url, verify_ssl=False) as response:
        content = response.content.read()
        file_name = get_file_name()
        with open(file_name, mode='wb') as file_obj:
            file_obj.write(content)
        print('download done')


async def main(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [asyncio.create_task(download_image(session, url)) for url in 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】
while True:
		#  可执行的任务列表，已完成的任务列表 = 去任务列表中检查所有的任务，将“可执行”和“已完成”的任务返回
		
		for 就绪任务 in 可执行的任务列表：
		      执行就绪任务()
		
		 for 已完成的任务 in 已完成的任务列表：
		       在任务列表中移除，已完成的任务
		       
		 如果任务列表中所有任务已完成，则终止执行

2 快速上手

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

async def func():
    pass

result = func()

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

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

import asyncio

async def func():
    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 asyncio

async def func():
	print('hello')
	response = await asyncio.sleep(3)
	print('end', response)

asyncio.run(func())

示例２：

import asyncio


async def others():
    print('start')
    await asyncio.sleep(3)
    print('end')
    return '返回值'


async def func():
    print('执行协程函数内部代码')
    # 遇到IO操作挂起当前协程（任务），等IO操作完成之后再继续向下执行，当前协程挂起时，事件循环可以去执行其它协程（任务）
    response = await others()
    print('执行协程函数内部代码')

asyncio.run(func())

示例３：

import asyncio


async def others():
    print('start')
    await asyncio.sleep(3)
    print('end')
    return '返回值'


async def func():
    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 asyncio


async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return '返回值'


async def main():
    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 task2
    print(ret1, ret2)
    
asyncio.run( main() )

示例2:

import asyncio


async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return '返回值'


async def main():
    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 asyncio


async def func():
    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：

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

async.run(main())

示例2：

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

async.run(main())

6 concurrent.futures.Future对象

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

import time
from concurrent.futures import Future
from concurrent.futures.thread import ThreadPoolExecutor
from concurrent.futures.process import ProcessPoolExecutor


def func(value):
    time.sleep(1)
    print(value)


# 创建线程池
pool = ThreadPoolExecutor(max_workers=5)

# 创建进程池
# pool = ProcessPoolExecutor(max_workers=5)


for i in range(10):
    fut = pool.submit(func, i)
    print(fut)

与协程交叉使用：
示例：

import time
import asyncio
import concurrent.futures


def func1():
    # 某个耗时操作
    time.sleep(2)
    return 'func1 done'


async def main():
    loop = asyncio.get_running_loop()
    
    fut = loop.run_in_executor(None, func1)

    result = await fut

    print('default thread pool', result)


asyncio.run(main())

三、异步编程实战案例

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

import asyncio


class AsyncContextManager:
    def __init__(self):
        self.conn = None

    async def do_someting(self):
        return 666

    async def __aenter__(self):
        self.conn = await asyncio.sleep(1)
        return self

    async def __aexit__(self):
        await asyncio.sleep(1)


async def func():
    async with AsyncContextManager() as f:
        result = await f.do_someting()
        print(result)

asyncio.run(func())

2、uvloop

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

import asyncio
import 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框架

pip3 install fastapi
pip3 install uvicorn

总结

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

spjrual
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python协程编程实例_Python异步IO编程之-asyncio协程应用例子
weixin_39936380的博客
12-07 146
前面，我们从大的结构上认识了最新的Python 3.7里面的asyncio标准库。接下来，我们就开始一点一点的来学习asyncio的使用。一、安装 Python 3.7我的系统是 Ubuntu 16.04，里面有 Python 2.7 和 Python 3.6。2.7是系统自带的，其它系统软件对此有依赖，不能破坏。3.6 是通过ppa源apt install的，然后通过 virtualenvwra...
asyncio.get_event_loop().run_until_complete()的简单使用
Major_S的博客
07-08 1472
使用 run_until_complete 方法等待 main 函数执行完成，使用 asyncio.get_event_loop 方法获取事件循环对象，Asyncio 是一个基于事件循环的异步I/O框架，使用高效的协程实现。使用close关闭事件循环。
深入Asyncio（十）异步解析式
weixin_30437481的博客
10-22 133
Async Comprehensions 目前已经学会了如何在Python中进行异步迭代，接下来的问题是这是否适用于解析式？答案是OJBK！该支持在PEP 530中提及，建议去读一下。 >>> import asyncio >>> async def doubler(n): # 1 ... for i in range(n): ... ...
python多任务—协程(asyncio详解) 二
xiaoming0018的博客
08-05 1313
在协程中调用普通函数，可以使用关键字：call_soon, call_later, call_at 1、loop.call_soon(callback, *args, context=None) 从字面上看是调用立即返回。在下一个迭代的事件循环中立即调用回调函数，大部分的回调函数支持位置参数，而不支持关键字参数，如果想用关键字参数，可以使用functools.partial()方法对回调函数进一步封装。可选关键字context允许指定要运行的回调的自定义contextvars.Context，当没有提供上
python基础学习07_循环(while循环、for循环、退出循环)
baidu_41805096的博客
08-28 558
# -*- encoding: utf-8 -*- """ while循环语法如下 while 条件： 符合条件重复执行代码 .... """ ''' 实例1：1-100累加 1、准备做累加运算的数据 1-100，增量为1 2、准备变量保存运算的结果 3、循环加法运算 4、打印结果 ''' # 准备数据 i = 1 # 结果变量 result = 0 # 循环 while i <= 100: # 前面累加的结果加上最新的数据，每计算一次，更新一次result的结果 r
协程 & asyncio &异步编程大纲.md
03-21
python异步
Python异步编程之协程任务的调度操作实例分析
09-18
Python的异步编程是一种高效的资源管理方式，尤其在处理I/O密集型任务时，通过协程（coroutine）可以实现非阻塞的并发执行。协程任务调度是异步编程中的核心部分，它决定了任务之间的执行顺序和切换时机。本文将深入...
详解python异步编程之asyncio(百万并发)
09-20
Python的异步编程是解决高并发问题的有效途径，特别是在IO密集型任务中，如网络请求。asyncio是Python 3.4引入的标准库，专门用于异步I/O编程，它基于协程(coroutine)和事件循环(event loop)的概念。Python 3.5...
Python Asyncio：异步编程和并发指南
最新发布
11-15
Python 的 asyncio 库提供了一种优雅的方式来处理并发和异步编程，特别是在 IO 密集型任务中，可以显著提高程序性能。通过使用 `async` 和 `await` 关键字，开发者可以编写出易于理解和维护的并发代码。异步编程不仅...
Python 异步协程函数原理及实例详解
09-18
Python中的异步编程是通过协程（coroutine）和异步I/O模型（如asyncio库）来实现的，这使得Python程序能够高效地处理I/O密集型任务，避免了传统多线程或多进程中的上下文切换开销。本文将深入探讨Python异步协程函数...
python异步方法asyncio的使用2
m0_47671192的博客
05-11 484
因为这里会说道awaitable对象，我们了解下什么是awaitable，awaitable对象可以理解为可暂停等待的对象，有三类对象是可以等待的，即coroutines, Tasks,Futures. coroutine：本质是一个函数，@asyncio.coroutine装饰器标记一个generator为coroutine类型，然后在generator内部用yield from调用另一个coroutine实现异步操作，这里我们不多做说明 Tasks：任务，顾名思义，就是要完成某件事情，Task用来 并发
python 高性能编程 异步并发编程 asyncio 协程笔记暂记
ResumeProject的博客
06-03 534
异步并发编程-相关概念 同步：按照顺序执行：js同步的实现 异步：非同步。一起执行，但是异步不一定就是多线程，比如JavaScript 的运行时是跑在单线程上的，所有同步任务都在主线程上执行，形成一个执行栈（execution context stack）。主线程之外，还存在一个”任务队列”（task queue）。只要异步任务有了运行结果，就在”任务队列”之中放置一个事件。一旦”执行栈”中的所有同步任务执行完毕，系统就会读取”任务队列”，看看里面有哪些事件。那些对应的异步任务，于是结束等待状态，进入执行
Asyncio之EventLoop笔记
dianyin7770的博客
06-14 764
使用事件循环 Python3.4 采用了一个强大的框架来支持代码的并发执行: asyncio。这个框架使用事件循环来编排回调和异步任务。 事件循环位于事件循环策略的上下文中-这是 asyncio 所特有的概念。 下图是协程，事件循环和策略之间的相互作用 协程可以被认为是可以在明确标记有某种语法元素的阶段“暂停”的函数. 通过任务对象跟踪协程的状态,由相应的事件循环实例化。 事件循环跟踪...
Python asyncio----在多线程中启用多个事件循环
sinat_41292836的博客
06-05 5073
协程多任务通常运行在同一进程的单线程环境中，但如果有要将多个基于asyncio的协程运行在不同线程中的需求，可在主线程中使用asyncio.new_event_loop()创建一个new_loop，在子线程中使用asyncio.set_event_loop(new_loop)为子线程设置其事件循环。 给出如下例子做参考: import threading import asyncio def thread_loop_task(loop): # 为子线程设置自己的事件循环 as.
python3-asyncio 学习笔记 3 -- run_until_complete
weixin_34128534的博客
03-24 8384
2019独角兽企业重金招聘Python工程师标准>>> ...
IO密集型vs计算密集型
_compiling的博客
10-27 1542
经常听到别人说python多线程针对io密集型任务可以提升效率，而针对计算密集型则没有什么效果，那么什么是IO密集型和计算密集型呢？ 任务类型可以分为计算密集型和IO密集型。 计算密集型任务的特点是要进行大量的计算，消耗CPU资源，比如计算圆周率、对视频进行高清解码等等，全靠CPU的运算能力。这种计算密集型任务虽然也可以用多任务完成，但是任务越多，花在任务切换的时间就越多，CPU执行任务的效率
【PYTHON并发学习】多线程Threading+多进程Multiprocessing+多协程Asyncio
Cheryl_Xu的博客
07-20 1297
并发编程，缩短运行时间。哪些程序提速的方法？单线程串行CPU-IO-CPI-IO如此一步一步执行多线程并发CPU与IO可以并行，IO的读取不需要CPU参与，实现并发。原理上仍是单CPU处理。多CPU并行多核CPU的电脑，可实现多任务CPU-IO执行，是真正的并行执行进行加速。多机器并行在多CPU并行的基础上，多机器进行任务运行。...
ext4.0中获取某个function的变量值_Asyncio中的事件循环Event Loop管理
weixin_36440319的博客
12-24 69
Python 3.4版本之后发布了asyncio模块，并提供了事件循环（Event Loop）、协程(Coroutine)、任务（Tasks）以及线程的多种管理工具。asyncio模块Python中的asyncio模块提供了循环事件、协程、任务和线程的多种管理工具，以及编写并发代码的同步原语，其中的主要组件包括：event loop - 异步模型允许每个进程有一个事件循环coroutines - ...
协程asyncio_Python 异步模块 asyncio 中的协程与任务
05-24
在Python异步模块asyncio中，协程和任务都是用于异步编程的重要对象。 协程是一种特殊的函数，可以通过`async def`关键字定义。协程可以通过`await`关键字暂停执行，并在稍后继续执行。协程的定义示例： ```python...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值