协程高并发 - asyncio异步

置顶 已于 2024-06-17 15:41:43 修改
阅读量10w+ 收藏 17
点赞数 3
分类专栏： 协程 文章标签： python
于 2020-08-01 21:08:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MarkAdc/article/details/107736445
版权

1 - 协程基础知识

2 - 执行协程函数中的代码

3 - 实现异步的正确方式

4 - 获取协程函数的返回值

5 - 协程的高并发实例


协程函数 


# 定义协程函数
async def func():
    print("这是一个协程函数")


协程对象 


# 定义协程函数
async def func():
    print("这是一个协程函数")
    

if __name__ == '__main__':
	# coro: 协程对象
	# 此时 func函数 里面的代码 并不会像普通函数一样 被执行
	coro = func()


await关键字 


import asyncio

"""
	await 只能在协程中使用
    await + 可等待的对象
    比如 await 协程对象/task对象/future对象 
    使用create_task方法 可以把协程对象 封装成task对象
    官方建议使用task对象
"""


async def job():
    print("正在下载")
    await asyncio.sleep(1)                  # 协程中的睡眠
    print("下载完成")


async def run():
    print("开始执行")
    await job()                             # 此处是 await 协程对象
    await asyncio.create_task(job())        # 此处是 await task对象
    await asyncio.ensure_future(job())      # 此处是 await future对象
    print("执行完成")


协程的顶层入口 


import asyncio


# 定义协程函数
async def func():
    print("这是一个协程函数")


if __name__ == '__main__':
	# run方法: 协程的顶层入口
	# 这样func函数中的代码就会执行
	asyncio.run(func())


协程调用协程 

import asyncio


async def job(param):
    print("job执行了, 参数是", param)


# 在协程中调用另一个协程
async def run():

    # await 一个协程对象 就能执行这个协程
    await job("python newbee")

   
if __name__ == '__main__':
    asyncio.run(run())

运行结果 

job执行了, 参数是 python newbee


创建task对象 

import asyncio


async def job(param):
    print("job执行了, 参数是", param)


# 在协程中调用另一个协程
async def run():
    # 把协程对象 封装成 task对象 也能执行协程
    asyncio.create_task(job("task对象"))


if __name__ == '__main__':
    asyncio.run(run())

运行结果 

job执行了, 参数是 task对象


错误的调用写法 

import asyncio
import time


async def job(a):
    print("正在下载 参数是", a, time.time())
    print("下载完成 参数是", a, time.time())
    print()
    await asyncio.sleep(1)

# 使用了3次await
async def run():
    coro1 = job(1)
    await coro1
    coro2 = job(2)
    await coro2
    coro3 = job(3)
    await coro3


if __name__ == '__main__':
    t1 = time.time()

    asyncio.run(run())

    print("耗时:", time.time() - t1)

运行结果

很明显是同步效果，一个任务执行消耗1秒，三个就是3秒

正在下载 参数是 1 1614138123.2335
下载完成 参数是 1 1614138123.2335

正在下载 参数是 2 1614138124.234306
下载完成 参数是 2 1614138124.234306

正在下载 参数是 3 1614138125.2348037
下载完成 参数是 3 1614138125.2348037

耗时: 3.0022435188293457


wait方法放在协程函数中 

import asyncio
import time


async def job(a):
    print("正在下载 参数是", a, time.time())
    print("下载完成 参数是", a, time.time())
    print()
    await asyncio.sleep(1)


# 用了1次await
async def run():
    coros = [job(a) for a in range(3)]
    await asyncio.wait(coros)


if __name__ == '__main__':
    t1 = time.time()

    asyncio.run(run())

    print("耗时:", time.time() - t1)

运行结果

执行的时间戳一模一样，达到了真正的异步

正在下载 参数是 1 1614140614.450291
下载完成 参数是 1 1614140614.450291

正在下载 参数是 0 1614140614.450291
下载完成 参数是 0 1614140614.450291

正在下载 参数是 2 1614140614.450291
下载完成 参数是 2 1614140614.450291

耗时: 1.0004453659057617


wait方法放在顶层入口 

import asyncio
import time


async def job(a):
    print("正在下载 参数是", a, time.time())
    print("下载完成 参数是", a, time.time())
    print()
    await asyncio.sleep(1)


if __name__ == '__main__':
    t1 = time.time()

    coros = [job(a) for a in range(3)]
    asyncio.run(asyncio.wait(coros))

    print("耗时:", time.time() - t1)

运行结果

执行的时间戳一模一样，达到了真正的异步

正在下载 参数是 1 1614138389.9913373
下载完成 参数是 1 1614138389.9913373

正在下载 参数是 2 1614138389.9913373
下载完成 参数是 2 1614138389.9913373

正在下载 参数是 0 1614138389.9913373
下载完成 参数是 0 1614138389.9913373

耗时: 1.0014846324920654


使用回调函数 

import asyncio
from functools import partial


# 回调函数
def callback(task):
    print("返回的结果是: ", task.result())


async def job():
    print("job执行了")
    print("job结束了")
    return 100


async def run():
    task = asyncio.create_task(job())
    # 协程任务完成后, 回调函数才会执行    	
    task.add_done_callback(partial(callback))


if __name__ == '__main__':
    asyncio.run(run())

运行结果 

job执行了
job结束了
返回的结果是:  100


最简单的接收 

import asyncio


async def job(param):
    print("job执行了, 参数是", param)
    return 100


async def run():
    result1 = await job("coroutine")
    print(result1)
    result2 = await asyncio.create_task(job("task"))
    print(result2)


if __name__ == '__main__':
    asyncio.run(run())

运行结果 

job执行了, 参数是 coroutine
100
job执行了, 参数是 task
100


使用wait方法 


import asyncio
import time

'''
	wait方法会自动将协程对象 封装成task对象进行处理
	wait方法在内部用set保存 它创建的task对象
	因为set是无序的, 所以任务不是顺序执行
'''


now = lambda: time.time()


async def func(idx):
    print(f"func执行了, 参数: {idx}, 时间戳: {now()}")
	await asyncio.sleep(1)
    return 100


async def run1():
    tasks = [asyncio.create_task(func(idx)) for idx in range(10)]
    # 等待返回结果
    await asyncio.wait(tasks)
    # 获取返回值
    for task in tasks:
        print(task.result())


async def run2():
    coros = [func(a) for a in range(10)]

    # wait方法会自动 把coros中的协程对象 封装成task对象
    # wait方法返回一个元组, 元组中有两个集合
    # done: 	已经完成任务的task对象集合
    # pending: 	未完成任务的task对象集合
    # 调用task对象的result方法可以获取 协程的返回结果
    done, pending = await asyncio.wait(coros) 
    for task in done:
        print(tasks.result())
        

if __name__ == '__main__':
    # 执行协程
    asyncio.run(run1())


使用gather方法 


import asyncio
import time

'''
	gather方法的任务是顺序执行的
'''


now = lambda: time.time()


async def func(idx):
    print(f"func执行了, 参数: {idx}, 时间戳: {now()}")
    return 100


async def run1():
    tasks = [asyncio.create_task(func(idx)) for idx in range(10)]
    # 等待返回结果
    await asyncio.gather(*tasks)
    # 获取返回值
    for task in tasks:
        print(task.result())


async def run2():
    # 把多个协程对象装到一个列表中
    coros = [func(a) for a in range(10)]

    # gather方法返回一个列表
    # 列表中的每一个元素就是协程的返回结果
    results = await asyncio.gather(*coros)
    for result in results:
        print(result)


if __name__ == '__main__':
    # 执行协程
    asyncio.run(run1())


使用as_completed方法 

import asyncio
from random import randint


async def job(delay):
    print("开始下载", delay)
    await asyncio.sleep(delay)
    print("下载完成", delay)
    return delay


async def use_as_completed():
    tasks = [
        asyncio.create_task(job(randint(1, 3)))
        for _ in range(6)
    ]

    # 使用as_completed方法的好处
    # 任务先完成就立即返回, 而不是等待所有任务完成后再一起返回
    for coro in asyncio.as_completed(tasks):
        result = await coro
        print("返回:", result)
    print("上面使用as_completed")


async def use_wait():
    tasks = [
        asyncio.create_task(job(randint(1, 3)))
        for _ in range(6)
    ]
    # 使用wait方法
    # 单个任务执行完了, 也要等待所有任务完成后, 再一起返回
    done, pending = await asyncio.wait(tasks)
    for task in done:
        print("返回:", task.result())
    print("上面使用wait")
    

if __name__ == '__main__':
    asyncio.run(use_wait())
    print()
    asyncio.run(use_as_completed())

运行结果 

开始下载 1
开始下载 2
开始下载 1
开始下载 3
开始下载 3
开始下载 3
下载完成 1
下载完成 1
下载完成 2
下载完成 3
下载完成 3
下载完成 3
返回: 3
返回: 1
返回: 3
返回: 1
返回: 3
返回: 2
上面使用wait

开始下载 1
开始下载 3
开始下载 3
开始下载 2
开始下载 3
开始下载 1
下载完成 1
下载完成 1
返回: 1
返回: 1
下载完成 2
返回: 2
下载完成 3
下载完成 3
下载完成 3
返回: 3
返回: 3
返回: 3
上面使用as_completed


执行5000个相同的协程 


import asyncio
import time


"""
    一共有5000个 parse_detail 执行
"""


# 返回时间戳, 方便记录 程序执行完毕 所消耗的时间
now = lambda: time.time()


# 解析详情页
async def parse_detail(id):
	print(f"正在解析 详情页{id} --> {now()}")
    await asyncio.sleep(1) 	 # 睡眠1秒
	print(f"详情页{id} 解析完成 --> {now()}")


# 解析列表页
async def parse_page(page):
    print(f"正在解析 列表页{page} --> {now()}")
    
    # 内层的任务列表
    # 每一个页面有1000个详情页
    detail_coros = [
    	parse_detail(f"{page}/{id}") 
    	for id in range(1, 1001)
    ]
    await asyncio.wait(detail_coros)
    
	print(f"列表页{page} 解析完成 --> {now()}")


async def run():
	# 外层的任务列表
	# 构造了5个列表页
    page_coros = [
    	parse_page(page) 
    	for page in range(1, 6)
    ]
    await asyncio.wait(page_coros)


if __name__ == '__main__':
	t1 = now()

    asyncio.run(run())

    print(f"耗时: {now() - t1}")

是大嘟嘟呀
关注
  • 3
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python的协程异步IO（asyncio）详解_python asyncio
2401_84010061的博客
04-13 503
asyncio 是用来编写并发代码的库，使用 async/await 语法。asyncio 被用作多个提供高性能 Python 异步框架的基础，包括网络和网站服务，数据库连接库，分布式任务队列等等。asyncio 往往是构建 IO 密集型和高层级 结构化 网络代码的最佳选择。并发地运行 Python 协程 并对其执行过程实现完全控制;执行网络 IO 和 IPC;控制子进程;通过队列实现分布式任务;同步并发代码;
Python协程 & 异步编程(asyncio) 入门介绍
行者AI
07-02 612
本文首发于：行者AI 在近期的编码工作过程中遇到了async和await装饰的函数，查询资料后了解到这种函数是基于协程的异步函数。这类编程方式称为异步编程，常用在IO较频繁的系统中，如：Tornado web框架、文件下载、网络爬虫等应用。协程能够在IO等待时间就去切换执行其他任务，当IO操作结束后再自动回调，那么就会大大节省资源并提供性能。接下来便简单的讲解一下异步编程相关概念以及案例演示。 1. 协程简介 1.1 协程的含义及实现方法 协程（Coroutine），也可以被称为微线程，是一种用户态内的.
Python3.7的新API:asyncio.run()
sometime here
04-29 9479
Python3.7的新API:asyncio.run() Python3.7的正式版本已经发布有一段时间了，出了内置的breakpoint()断点函数，颇受争议的dataclass,自定义模块里的__getattr__()和__dir__()魔法方法等新特性外以及一些底层的改进外，还添加了一些新的api。其中我个人比较喜欢的一个新API是asyncio.run()方法，可以省去显式的定义事...
python-asyncio异步基础
刚入职的Android系统工程师小白
10-14 4139
python-asyncio异步基础学习
python异步编程----asyncio 库协程理解
最新发布
wltyh的博客
04-26 842
链接。
asyncio 协程 异步执行
zyk_php的博客
09-09 583
将代码进行异步后发现，爬取信息的速度加快，但网站拥有反扒等措施，同时大量多次访问会显示‘‘访问速度限制’’，无法正常访问，虽然异步后因为网站反扒限制没能解决爬取时间过长的问题，但是异步的方法还是很值得记录一下。网站内的linux开源软件时，同一款软件有多个版本和对应的多个不同格式的包，按照以往的线性模式，爬取一页29款软件需花费33分钟。事件循环是单线程运行的，所以当sleep之后阻塞单线程，没办法继续运行，所以只能变成同步调用，所以你会看到2个download任务同步返回，耗时4s。结局真的让人很头大。
lolcats-asyncio:最短的异步教程
05-20
在Python编程领域，异步I/O...这个教程将帮助你更好地理解如何在Python中编写高效的异步代码，以应对高并发场景和I/O密集型任务。学习并掌握`asyncio`不仅能够提升你的编程技能，还能为你的项目带来更好的性能优化。
Python-asyncio源码注解
08-10
**Python-asyncio源码注解** `asyncio` 是 Python 的一个标准库，用于编写异步并发代码，尤其在处理I/O密集型任务时表现...通过阅读这些注解，开发者可以更好地掌握如何高效地利用 `asyncio` 实现高性能的异步应用。
awesome-asyncio：精选的Python异步框架，库，软件和资源的精选清单
02-01
`asyncio`是Python标准库提供的一种异步I/O框架，它基于协程（coroutines）和事件循环（event loop）的概念，允许程序员以同步代码风格编写非阻塞的异步程序。`awesome-asyncio`项目是一个精心整理的资源集合，包含...
WebScrapper-using-python-asyncio
03-14
Python 的 asyncio 库是 Python 3.4 引入的一个核心特性，它基于协程（coroutines）和事件循环（event loop）的概念，为编写并发代码提供了高级接口。在爬虫中，当我们需要等待多个网络请求时，asyncio 可以让我们在...
Python-Python3爬虫系列的理论验证比较同步依序下载多进程并发多线程并发和asyncio异步编程之间的效率差别
08-12
本主题将深入探讨Python3中四种不同的并发模型：同步依序下载、多进程（multiprocessing）、多线程（multithreading）以及asyncio异步编程，并通过理论分析和实际案例对比它们之间的效率差异。 1. 同步依序下载： ...
asyncio 概念和用法
zyy247796143的博客
07-05 6863
声明：本文针对的是python3.4以后的版本的，因为从3.4开始才引入asyncio，后面的3.5 3.6 3.7版本是向前兼容的，只不过语法上面有稍微的改变。比如在3.4版本中使用装饰器和语句，但是在3.5以后的版本中使用、两个关键字代替，虽然语法上稍微有所差异，但是原理是一样的。本文用最通俗的语言解释了python asyncio背后的一些核心概念，简要解析了asyncio的设计架构，并给出了使用python进行asyncio异步编程的一般模板。对于其他的并发模型大多数采取的都是线性的方式编写。并且依
python asyncio 中 asyncio.run()和asyncio.create_task()的区别
weixin_42581003的博客
02-13 458
asyncio.run() 和 asyncio.create_task() 都可以用来运行一个协程，但是它们之间有一些重要的区别。asyncio.run() 用来运行一个协程，并且会自动处理异常，还可以控制协程的运行时间和返回值。而 asyncio.create_task() 则是创建一个异步任务，它可以把一个协程放入到一个任务中，并且可以控制任务的状态，而不用关心协程的细节。 ...
asyncio异步io并发编程
爱吃辣椒的锅包肉
12-15 1345
一、关于asyncio asyncio是解决异步io高并发编程的核心模块，python3.4后开始引用，可以说是python中最具野心的一个模块，无论是高并发web服务器还是高并发爬虫都可以胜任。 asyncio提供了异步IO编程的一整套方案，包括: 包含各种特定系统都能够兼容的模块化事件循环。 传输和协议抽象。 实现了对TCP、UDP、SSL、子进程、延时调用等的具体支持。 模仿futures模块但适用于事件循环使用的Future类。 基于yield from的协议和任务，可以使用同步编码的方式编写异步
Python编程：使用asyncio包处理并发
weixin_56051592的博客
01-06 427
Python经典进阶教程！
从IO模型到协程（六） asyncio和协程实现高并发
jqsfjqsf的博客
02-12 609
本系列文章目录 展开/收起 从IO模型到协程（一） 什么是IO，用户进程与内核 从IO模型到协程（二） BIO模型和NIO模型 从IO模型到协程（三） 多路复用之select、poll和epoll 从IO模型到协程（四） 用python实现一个多路复用程序 从IO模型到协程（五） python中的协程（coroutin...
python asyncio 协程异步【1】详解
爱死亡机器人
05-28 2119
asyncio介绍 异步IO：就是发起一个IO操作（如：网络请求，文件读写等），这些操作一般是比较耗时的，不用等待它结束，可以继续做其他事情，结束时会发来通知。 协程：又称为微线程，在一个线程中执行，执行函数时可以随时中断，由程序（用户）自身控制，执行效率极高，与多线程比较，没有切换线程的开销和多线程锁机制。 python中异步IO操作是通过asyncio来实现的。 协程基础 从语句上看，协程和生成器类似，都是包含了yield关键字，不同之处在于协程中yield关键词通常出现在=右边，可以产出值a（y =
Python黑魔法 --- 协程分解与封装
ronon77的专栏
02-03 1125
    首页 所有文章 观点与动态 基础知识 系列教程 实践项目 工具与框架 工具资源 Python小组 - 导航条 - 首页 所有文章 观点与动态 基础知识 系列教程 实践项目 工具与框架 工具资源 Python小组     伯乐在线 > Python - 伯乐在线 > 所有文章 > 基础知识 > Python黑魔...
asyncio- 异步
chikun8177的博客
05-17 198
asyncio是一个使用async / await语法编写并发代码的库。 asyncio用作多个Python异步框架的基础，这些框架提供高性能的网络和Web服务器，数据库连接库，分布式任务队列等。 asyncio通常非常适合IO绑定和高级结构化网络代码。 asyncio提供了一组高级...
asyncio 异步任务和协程有什么区别
04-02
asyncio异步任务和协程的区别在于： - 异步任务（coroutine function）是一种特殊的Python函数，它使用async关键字定义，可以在其中使用await语句来等待其他异步任务或协程的完成。异步任务可以看作是一种携带状态...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值