Python进阶-day12:异步编程(asyncio 和 async/await)

学习内容：异步编程（asyncio 和 async/await）

1. 异步编程基础

• 什么是异步编程？ 异步编程允许程序在等待某些操作（如网络请求、文件读写）完成时，不阻塞主线程，而是继续执行其他任务，从而提高效率。
• asyncio：Python 提供的高级异步I/O框架，用于编写并发代码。
• async/await 语法： async def：定义一个异步函数（协程）。 await：暂停协程的执行，等待某个异步操作完成。
• 事件循环（Event Loop）：asyncio 的核心，负责调度和运行异步任务。

2. 关键概念

• 协程（Coroutine）：使用 async def 定义的函数，运行时不会立即执行，而是返回一个协程对象，需通过事件循环调度。
• 任务（Task）：将协程包装为任务，交给事件循环运行。
• Future：表示尚未完成的操作，await 会等待其结果。
• 并发 vs 并行： 异步编程实现并发（单线程内快速切换任务）。 并行则是多线程/多进程同时执行。

3. 异步编程的优势

• 适合 I/O 密集型任务（如网络请求、文件操作）。
• 提高程序效率，尤其在处理大量等待时间的任务时。

练习：异步抓取多个网页的标题

以下是一个完整的示例代码，使用 asyncio 和 aiohttp（异步 HTTP 客户端库）抓取多个网页的标题，包含详细注释。

安装依赖

运行以下命令安装必要的库：

bash

pip install aiohttp beautifulsoup4

示例代码

python

import asyncio
import aiohttp
from bs4 import BeautifulSoup
import time

# 定义异步函数来抓取单个网页的标题
async def fetch_title(session, url):
    """
    异步获取指定 URL 的网页标题
    参数:
        session: aiohttp 的异步会话对象
        url: 要抓取的网页地址
    返回:
        网页标题（字符串）或错误信息
    """
    try:
        # 使用异步 GET 请求获取网页内容
        async with session.get(url, timeout=10) as response:
            # 确保请求成功
            if response.status != 200:
                return f"无法访问 {url}，状态码: {response.status}"

            # 读取网页的 HTML 内容
            html = await response.text()

            # 使用 BeautifulSoup 解析 HTML
            soup = BeautifulSoup(html, 'html.parser')

            # 获取标题（<title> 标签内容）
            title = soup.title.string.strip() if soup.title else "无标题"
            return f"{url} 的标题: {title}"

    except Exception as e:
        # 捕获可能的异常（如网络错误、超时等）
        return f"抓取 {url} 失败: {str(e)}"

# 主函数，协调多个异步任务
async def main():
    """
    主函数，异步抓取多个网页的标题
    """
    # 定义要抓取的网页 URL 列表
    urls = [
        "<https://www.python.org>",
        "<https://www.github.com>",
        "<https://www.stackoverflow.com>",
    ]

    # 创建一个异步 HTTP 会话
    async with aiohttp.ClientSession() as session:
        # 创建任务列表，每个任务抓取一个网页的标题
        tasks = [fetch_title(session, url) for url in urls]

        # 并发运行所有任务，并等待它们完成
        results = await asyncio.gather(*tasks, return_exceptions=True)

        # 输出结果
        for result in results:
            print(result)

# 程序入口
if __name__ == "__main__":
    # 记录开始时间
    start_time = time.time()

    # 获取事件循环并运行异步主函数
    asyncio.run(main())

    # 计算并输出运行时间
    print(f"\\n总耗时: {time.time() - start_time:.2f} 秒")

代码说明

1. 异步函数 fetch_title： 使用 async def 定义，接收 session（异步 HTTP 会话）和 url。 使用 aiohttp 发起异步 GET 请求，设置 10 秒超时。 使用 BeautifulSoup 解析 HTML，提取 <title> 标签内容。 包含错误处理，返回错误信息而不是抛出异常。
2. 主函数 main： 定义一个 URL 列表，包含要抓取的网页。 使用 aiohttp.ClientSession 创建一个异步会话，管理 HTTP 请求。 使用列表推导式创建任务列表，调用 fetch_title。 使用 asyncio.gather 并发运行所有任务，并收集结果。
3. 程序入口： 使用 asyncio.run 运行主协程。 记录程序运行时间，展示异步编程的效率。
4. 关键点： aiohttp.ClientSession 必须在 async with 上下文中使用，确保正确关闭连接。 asyncio.gather 允许并发运行多个协程，显著减少总耗时。 使用 timeout 参数防止请求挂起太久。

运行结果示例

运行代码后，输出可能如下（具体标题因网站而异）：

<https://www.python.org> 的标题: Welcome to Python.org
<https://www.github.com> 的标题: GitHub: Let’s build from here
<https://www.stackoverflow.com> 的标题: Stack Overflow - Where Developers Learn, Share, & Build Careers
<https://www.example.com> 的标题: Example Domain

总耗时: 1.23 秒

同步 vs 异步对比

为了突出异步的优势，下面是一个同步版本的代码（仅供参考）：

python

import requests
from bs4 import BeautifulSoup
import time

def fetch_title_sync(url):
    try:
        response = requests.get(url, timeout=10)
        if response.status_code != 200:
            return f"无法访问 {url}，状态码: {response.status_code}"
        soup = BeautifulSoup(response.text, 'html.parser')
        title = soup.title.string.strip() if soup.title else "无标题"
        return f"{url} 的标题: {title}"
    except Exception as e:
        return f"抓取 {url} 失败: {str(e)}"

urls = [
    "<https://www.python.org>",
    "<https://www.github.com>",
    "<https://www.stackoverflow.com>",
    "<https://www.example.com>",
]

start_time = time.time()
for url in urls:
    print(fetch_title_sync(url))
print(f"\\n总耗时: {time.time() - start_time:.2f} 秒")

同步版本输出：

• 运行时间可能为 4-5 秒，因为每个请求按顺序等待完成。
• 异步版本通常只需 1-2 秒，因为所有请求并发执行。

学习总结

1. 掌握了 async/await 语法： async def 定义协程，await 等待异步操作。
2. 理解了 asyncio 的使用： 使用 asyncio.run 运行协程，asyncio.gather 实现并发。
3. 学会了 aiohttp： 异步 HTTP 请求库，适合网络爬虫等任务。
4. 体验了异步编程的优势： 并发处理 I/O 密集任务，显著提高效率。

进阶练习建议

1. 扩展功能： 添加代理支持，处理需要代理的网站。 抓取网页的其他元素（如 meta 描述、h1 标题）。
2. 错误重试： 为失败的请求添加自动重试机制。
3. 保存结果： 将抓取的标题保存到文件或数据库。
4. 性能优化： 使用 asyncio.Semaphore 限制并发数量，防止过多请求压垮服务器。

如果你有其他问题或想深入某个部分，请告诉我！