Python中最简单的异步/等待示例

Question

我已经读了很多例子，博客文章，问题/答案关于asyncio/async/wait在Python 3.5中，许多是复杂的，我发现最简单的可能是这个。
仍然使用ensure_future，为了学习Python中的异步编程，我想看一个更小的示例，以及执行基本异步/等待示例所需的最小工具是什么。

问题：是否可以给出一个简单的示例，说明async/await是如何工作的，只使用这两个关键字code运行异步循环—其他Python代码，而不使用其他asyncio函数？

例如：类似这样的东西：

import asyncio

async def async_foo():
    print("async_foo started")
    await asyncio.sleep(5)
    print("async_foo done")

async def main():
    asyncio.ensure_future(async_foo())  # fire and forget async_foo()
    print('Do some actions 1')
    await asyncio.sleep(5)
    print('Do some actions 2')

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

但如果没有，则确保未来的，并仍然演示wait/async是如何工作的。




Answer 1

Python3.7现在有了一个更简单的API（在我看来）和一个更简单的措辞（比“确保未来”更容易记住）：您可以使用create\u task，它返回一个任务对象（如果需要的话，以后可以使用它来取消任务）。

import asyncio

async def hello(i):
    print(f"hello {i} started")
    await asyncio.sleep(4)
    print(f"hello {i} done")

async def main():
    task1 = asyncio.create_task(hello(1))  # returns immediately, the task is created
    await asyncio.sleep(3)
    task2 = asyncio.create_task(hello(2))
    await task1
    await task2

asyncio.run(main())  # main loop

结果:

你好1开始了你好2开始了你好1结束了你好2结束了

如果需要获取这些异步函数的返回值，那么聚集是有用的。下面的示例是受留档的启发，但不幸的是，文档没有显示什么聚集是真正有用的：获取返回值！

import asyncio

async def factorial(n):
    f = 1
    for i in range(2, n + 1):
        print(f"Computing factorial({n}), currently i={i}...")
        await asyncio.sleep(1)
        f *= i
    return f

async def main():
    L = await asyncio.gather(factorial(2), factorial(3), factorial(4))
    print(L)  # [2, 6, 24]

asyncio.run(main())

预期产出：

计算阶乘（2），当前i=2…
计算阶乘（3），当前i=2…
计算阶乘（4），当前i=2…
计算阶乘（3），当前i=3…
计算阶乘（4），当前i=4…
[2,6,24]

PS：即使您使用的是asyncio，而不是trio，后者的教程也有助于我学习Python异步编程。

Answer 2

有没有可能给出一个简单的例子来展示async/wait是如何工作的，只使用这两个关键字asyncio.get_event_loop（）run_until_complete其他Python代码，但没有其他asyncio函数？

这样就可以编写工作代码：

import asyncio


async def main():
    print('done!')


if __name__ ==  '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

但这样就不可能说明为什么需要asyncio。

顺便问一下，为什么需要asyncio，而不仅仅是纯代码？答案是-asyncio允许您在并行化I/O阻塞操作（如读取/写入网络）时获得性能优势。为了编写有用的示例，您需要使用这些操作的异步实现。

请阅读此答案以获得更详细的解释。

Upd：

好的，下面的示例使用asyncio.sleep模拟I/O阻塞操作和asyncio.gather演示如何同时运行多个阻塞操作：

import asyncio


async def io_related(name):
    print(f'{name} started')
    await asyncio.sleep(1)
    print(f'{name} finished')


async def main():
    await asyncio.gather(
        io_related('first'),
        io_related('second'),
    )  # 1s + 1s = over 1s


if __name__ ==  '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

输出：

first started
second started
first finished
second finished
[Finished in 1.2s]

注意io_related是如何开始的，仅仅一秒钟后，两个都完成了。

Answer 3

为了回答您的问题，我将为同一问题提供3种不同的解决方案。

案例1：普通python

import time

def sleep():
    print(f'Time: {time.time() - start:.2f}')
    time.sleep(1)

def sum(name, numbers):
    total = 0
    for number in numbers:
        print(f'Task {name}: Computing {total}+{number}')
        sleep()
        total += number
    print(f'Task {name}: Sum = {total}\n')

start = time.time()
tasks = [
    sum("A", [1, 2]),
    sum("B", [1, 2, 3]),
]
end = time.time()
print(f'Time: {end-start:.2f} sec')

输出：

Task A: Computing 0+1
Time: 0.00
Task A: Computing 1+2
Time: 1.00
Task A: Sum = 3

Task B: Computing 0+1
Time: 2.01
Task B: Computing 1+2
Time: 3.01
Task B: Computing 3+3
Time: 4.01
Task B: Sum = 6

Time: 5.02 sec

案例2：异步/等待做错了

import asyncio
import time

async def sleep():
    print(f'Time: {time.time() - start:.2f}')
    time.sleep(1)

async def sum(name, numbers):
    total = 0
    for number in numbers:
        print(f'Task {name}: Computing {total}+{number}')
        await sleep()
        total += number
    print(f'Task {name}: Sum = {total}\n')

start = time.time()

loop = asyncio.get_event_loop()
tasks = [
    loop.create_task(sum("A", [1, 2])),
    loop.create_task(sum("B", [1, 2, 3])),
]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

end = time.time()
print(f'Time: {end-start:.2f} sec')

输出：

Task A: Computing 0+1
Time: 0.00
Task A: Computing 1+2
Time: 1.00
Task A: Sum = 3

Task B: Computing 0+1
Time: 2.01
Task B: Computing 1+2
Time: 3.01
Task B: Computing 3+3
Time: 4.01
Task B: Sum = 6

Time: 5.01 sec

案例3:async/wait done right（与案例2相同，除了sleep功能）

import asyncio
import time

async def sleep():
    print(f'Time: {time.time() - start:.2f}')
    await asyncio.sleep(1)

async def sum(name, numbers):
    total = 0
    for number in numbers:
        print(f'Task {name}: Computing {total}+{number}')
        await sleep()
        total += number
    print(f'Task {name}: Sum = {total}\n')

start = time.time()

loop = asyncio.get_event_loop()
tasks = [
    loop.create_task(sum("A", [1, 2])),
    loop.create_task(sum("B", [1, 2, 3])),
]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

end = time.time()
print(f'Time: {end-start:.2f} sec')

输出：

Task A: Computing 0+1
Time: 0.00
Task B: Computing 0+1
Time: 0.00
Task A: Computing 1+2
Time: 1.00
Task B: Computing 1+2
Time: 1.00
Task A: Sum = 3

Task B: Computing 3+3
Time: 2.00
Task B: Sum = 6

Time: 3.01 sec

案例1与案例2给出相同的5秒，而案例3仅3秒。因此，async/await done right更快。

差异的原因在于sleep功能的实现。

# case 1
def sleep():
    print(f'Time: {time.time() - start:.2f}')
    time.sleep(1)

# case 2
async def sleep():
    print(f'Time: {time.time() - start:.2f}')
    time.sleep(1)

# case 3
async def sleep():
    print(f'Time: {time.time() - start:.2f}')
    await asyncio.sleep(1)

sleep在case1和case2中的功能是“相同的”。他们在不允许他人使用资源的情况下“睡觉”。而案例3允许在资源处于Hibernate状态时访问资源。

在案例2中我们将异步添加到了正常函数中。但是，事件循环将不中断地运行它。为什么？因为我们没有告诉在哪里允许循环中断函数来运行另一个任务。

在案例3中，我们告诉事件循环在何处中断函数以运行另一个任务。具体在哪里？

# case 3
async def sleep():
    print(f'Time: {time.time() - start:.2f}')
    await asyncio.sleep(1) # <-- Right here!

更多关于这一点，请阅读这里

更新02/五月/2020

考虑阅读

• 异步编程搭便车指南
• Asyncio期货和协同程序