异步学习（二）

asyncio.run()

asyncio.run() 函数用来运行最高层级的入口点 “main()” 函数

asyncio.run(main())

但是在带IPython内核的jupyter中不能使用，因为会出现这样一句报错

RuntimeError: asyncio.run() cannot be called from a running event loop

其本身已经运行，网上有说直接用await调用就行，但是我试着没用（我用的python3.7），还是老老实实用最常见的这个吧。

asyncio.create_task() （3.7之后出现，之前版本可用低层级的 asyncio.ensure_future() ）

然后是asyncio.create_task() 并行运行，两个同时运行比预期快1秒

import asyncio
import time
import nest_asyncio
nest_asyncio.apply()
async def main():#协程函数: 定义形式为 async def 的函数;
    task1 = asyncio.create_task(#协程对象: 调用 协程函数 所返回的对象。
            say_after(1,'hello'))
    task2 = asyncio.create_task(#协程对象: 调用 协程函数 所返回的对象。
            say_after(3,'world'))
    print(f"time:{time.strftime('%X')}")
    await task1
    await task2
    print(f"time:{time.strftime('%X')}")
asyncio.run(main())

如果一个对象可以在 await 语句中使用，那么它就是可等待对象。上一章提到的三个名称在这便可用上，可等待对象有三种主要类型:Future,Task和coroutine。

import asyncio

async def nested():
	print(12138)
    return 10

async def main():
    print(await nested())#协程
    task = asyncio.create_task(nested())#创建task
    await task#等待task完成

asyncio.run(main())

asyncio.sleep（）

休眠函数，除了等待外还有个比较重要的作用：将 delay 设为 0 将提供一个经优化的路径以允许其他任务运行。 这可供长期间运行的函数使用以避免在函数调用的全过程中阻塞事件循环。

asyncio.sleep(delay, result=None, *, loop=None)

asyncio.gather（）

并发 运行 aws 序列中的 可等待对象。都成功完成后结果是一个由所有返回值聚合而成的列表

asyncio.gather(*aws, loop=None, return_exceptions=False)
return_exceptions为False所引发的首个异常会立即传播给等待 gather() 的任务。aws 序列中的其他可等待对象 不会被取消 并将继续运行。

return_exceptions为True，异常会和成功的结果一样处理，并聚合至结果列表。

```python#官网实例
import asyncio

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

async def main():
    # Schedule three calls *concurrently*:
    L = await asyncio.gather(
        factorial("A", 2),
        factorial("B", 3),
        factorial("C", 4),
    )
    print(L)

asyncio.run(main())
# Expected output:
#
#     Task A: Compute factorial(2), currently i=2...
#     Task B: Compute factorial(3), currently i=2...
#     Task C: Compute factorial(4), currently i=2...
#     Task A: factorial(2) = 2
#     Task B: Compute factorial(3), currently i=3...
#     Task C: Compute factorial(4), currently i=3...
#     Task B: factorial(3) = 6
#     Task C: Compute factorial(4), currently i=4...
#     Task C: factorial(4) = 24
#     [2, 6, 24]

结果并发运行，但又互不干涉