python 如何异步调用

在Python中，异步调用可以通过多种方式实现，主要方法包括使用asyncio库、concurrent.futures库以及第三方库如aiohttp。使用asyncio库、使用concurrent.futures库、使用第三方库（如aiohttp）。下面我们将详细讨论这几种方法中的一种——asyncio库的使用方法。

使用asyncio库可以简化异步编程，在Python 3.5以后，asyncio库引入了async和await关键字，使得异步编程更加直观和易用。我们通过以下几个小标题详细讲解如何使用asyncio库来实现异步调用。

一、`asyncio`库概述

asyncio是Python标准库中的一个模块，用于编写并发代码。asyncio使用事件循环来调度和执行异步任务。事件循环不断运行并检查是否有可执行的任务，如果有，它会将任务调度到适当的时间执行。

二、`async`和`await`关键字

async和await是Python异步编程的两个关键字。async用于定义一个异步函数，await用于暂停异步函数的执行，等待另一个异步调用的结果。通过这两个关键字，可以简化异步编程，使代码更具可读性。

1. 定义异步函数

使用async关键字可以定义一个异步函数。异步函数在定义时与普通函数类似，但它们的执行是异步的。以下是一个简单的例子：

import asyncio
async def hello_world():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

在这个例子中，hello_world函数是一个异步函数，它使用async关键字定义，并且在函数内部使用了await关键字来暂停函数的执行，等待asyncio.sleep(1)的结果。

2. 调用异步函数

要调用异步函数，需要使用事件循环。可以通过asyncio.run()函数来执行异步函数。以下是调用hello_world函数的例子：

asyncio.run(hello_world())

这个调用会启动事件循环，并在事件循环中执行hello_world异步函数。

三、并发执行多个异步任务

asyncio库提供了多种方法来并发执行多个异步任务，包括asyncio.gather、asyncio.create_task等。

1. 使用`asyncio.gather`

asyncio.gather函数可以并发地执行多个异步任务，并返回所有任务的结果。以下是一个示例：

import asyncio
async def task1():
    await asyncio.sleep(1)
    return "Task 1 completed"
async def task2():
    await asyncio.sleep(2)
    return "Task 2 completed"
async def main():
    result = await asyncio.gather(task1(), task2())
    print(result)
asyncio.run(main())

在这个例子中，main函数使用asyncio.gather并发地执行task1和task2异步任务，并等待它们完成。最后，main函数打印出所有任务的结果。

2. 使用`asyncio.create_task`

asyncio.create_task函数可以创建一个任务，并将其加入事件循环中执行。以下是一个示例：

import asyncio
async def task1():
    await asyncio.sleep(1)
    print("Task 1 completed")
async def task2():
    await asyncio.sleep(2)
    print("Task 2 completed")
async def main():
    task1_coro = task1()
    task2_coro = task2()
    task1_task = asyncio.create_task(task1_coro)
    task2_task = asyncio.create_task(task2_coro)
    await task1_task
    await task2_task
asyncio.run(main())

在这个例子中，main函数使用asyncio.create_task创建了两个任务，并将它们加入事件循环中执行。最后，main函数等待所有任务完成。

四、超时控制

在异步编程中，有时需要控制任务的执行时间，以防止任务无限期地运行。asyncio库提供了asyncio.wait_for函数来实现这一点。以下是一个示例：

import asyncio
async def long_running_task():
    await asyncio.sleep(5)
    return "Task completed"
async def main():
    try:
        result = await asyncio.wait_for(long_running_task(), timeout=2)
        print(result)
    except asyncio.TimeoutError:
        print("Task timed out")
asyncio.run(main())

在这个例子中，main函数使用asyncio.wait_for来限制long_running_task任务的执行时间。如果任务在2秒内没有完成，asyncio.wait_for会引发asyncio.TimeoutError异常。

五、取消任务

有时需要取消正在执行的任务。asyncio库提供了取消任务的方法。以下是一个示例：

import asyncio
async def long_running_task():
    try:
        await asyncio.sleep(5)
        return "Task completed"
    except asyncio.CancelledError:
        print("Task was cancelled")
        raise
async def main():
    task = asyncio.create_task(long_running_task())
    await asyncio.sleep(1)
    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        print("Task was indeed cancelled")
asyncio.run(main())

在这个例子中，main函数创建了一个long_running_task任务，并在1秒后取消它。long_running_task在取消时会引发asyncio.CancelledError异常，并且main函数捕获该异常以确认任务已被取消。

六、与同步代码集成

在实际应用中，有时需要将异步代码与同步代码集成。可以使用asyncio.run_in_executor函数来运行阻塞的同步代码。以下是一个示例：

import asyncio
import time
def blocking_io():
    time.sleep(2)
    return "Blocking IO completed"
async def main():
    loop = asyncio.get_running_loop()
    result = await loop.run_in_executor(None, blocking_io)
    print(result)
asyncio.run(main())

在这个例子中，main函数使用asyncio.run_in_executor函数将blocking_io函数作为阻塞的同步代码运行。asyncio.run_in_executor函数返回一个Future对象，main函数等待该Future对象完成并打印结果。

七、使用`asyncio`实现网络请求

在异步编程中，网络请求是一个常见的应用场景。asyncio库可以与aiohttp库结合使用来实现异步网络请求。以下是一个示例：

import asyncio
import aiohttp
async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()
async def main():
    url = "http://httpbin.org/get"
    html = await fetch(url)
    print(html)
asyncio.run(main())

在这个例子中，fetch函数使用aiohttp库来异步发送HTTP请求，并获取响应内容。main函数调用fetch函数并打印响应内容。

八、错误处理

在异步编程中，需要处理任务中的错误。可以使用try/except语句来捕获异常，并处理任务中的错误。以下是一个示例：

import asyncio
async def error_task():
    raise ValueError("An error occurred")
async def main():
    try:
        await error_task()
    except ValueError as e:
        print(f"Caught error: {e}")
asyncio.run(main())

在这个例子中，error_task函数引发一个ValueError异常，main函数使用try/except语句捕获该异常并打印错误信息。