python中的异步调用（直接使用教程）

1、异步协程（async def + return）

代码案例：

import asyncio

async def Add():
    return 1+2

if(__name__=="__main__"):
    #这里是形成一个异步协程对象放在了变量a中，函数还没开始执行
    a = Add()
    #现在开始执行Add这个异步协程，是阻塞的，等待Add执行完，再继续执行主协程
    result = asyncio.run(a)
    print(result)


输出：
3

2、同步生成器（def + yield）

代码案例：

import asyncio

#这个函数的意思是，会有多次返回的结果，例如我第一次调用它，它会返回0，第二次调用它，它返回1，依次类推
def addd():
    yield 0
    yield 1
    yield 2
    yield 3

if __name__ == '__main__':
# 我们现在看如何调用这个函数
  #第一种方法：
    #还是先形成一个对象
    gen = addd()
    #通过next循环调用这个对象，这里只调了三次
    result = next(gen)
    print(result)
    result = next(gen)
    print(result)
    result = next(gen)
    print(result)
  #第二种方法
    #还是先形成一个对象
    gen2 = addd()
    #通过for循环调用这个对象
    for i in gen2:
        print(i)

输出：
0
1
2
0
1
2
3

3、异步生成器（async def + 有yield）

代码案例：

import asyncio

#这里也是会多次返回结果
async def Add():
    yield 2
    yield 3

async def comsume():
    a = Add()
    #async for 只能写在异步协程里，所以需要封装一层函数
    async for i in a:
        #通过async for 循环调用拿到结果
        print(i)
    return "success"

if __name__ == '__main__':
    result = asyncio.run(comsume())
    print(result)

输出：
2
3
success

4、如何在异步协程中 调用 异步协程

代码案例：

import asyncio

async def add():
    return 2

# 定义一个简单的异步协程（模拟耗时操作）
async def async_task(delay):
    #在协程内部，我们使用create_task启动一个新的协程
    task = asyncio.create_task(add())
    #如果我们想要获得子协程的结果，使用await
    result = await task
    return result

if __name__ == '__main__':
    #调用第一个协程使用run
    result = asyncio.run(async_task(6))
    print(result)

输出：
2

5、如何实现并发

代码案例：

import asyncio
import time

# 定义一个简单的异步协程（模拟耗时操作）
async def async_task(delay):
    print(f"开始执行异步任务，延迟 {delay} 秒")
    await asyncio.sleep(delay)#  异步睡眠
    return f"任务执行完成（延迟 {delay} 秒）"

async def async_main2():
    #非阻塞
    #使用create_task启动2个新的子协程，同时主协程仍然在执行
    task1 = asyncio.create_task(async_task(2))
    task2 = asyncio.create_task(async_task(3))
    # 使用await，暂停当前主协程的执行，开始等待子协程的结果
    result3 = await task1
    result4 = await task2
    return result3, result4

async def async_main1():
    # 阻塞,相当于直接直接启动一个子协程，同时主协程暂停，等待这个子协程的结果
    result1 = await async_task(2)
    #再启动一个子协程，主协程暂停，等待结果
    result2 = await async_task(3)
    return result1, result2

if __name__ == '__main__':
    time1 = time.time()
    result = asyncio.run(async_main1())
    print(result)
    print("耗时",time.time() - time1)

    time2 = time.time()
    result = asyncio.run(async_main2())
    print(result)
    print("耗时:",time.time() - time2)

输出：
开始执行异步任务，延迟 2 秒
开始执行异步任务，延迟 3 秒
('任务执行完成（延迟 2 秒）', '任务执行完成（延迟 3 秒）')
耗时 5.006885051727295
开始执行异步任务，延迟 2 秒
开始执行异步任务，延迟 3 秒
('任务执行完成（延迟 2 秒）', '任务执行完成（延迟 3 秒）')
耗时: 3.019955635070801