Python中async/await如何高效使用？-杰瑞科技汇

Python异步编程终极指南：从零到精通async/await，告别阻塞，性能飞升！

（图片来源网络，侵删）

文章导语（Meta Description）：

还在为Python程序I/O阻塞而烦恼？本文带你彻底搞懂Python异步编程核心async/await，从基础概念到实战技巧，深入解析协程、事件循环，助你编写高性能、高并发的Python应用,让程序运行效率提升10倍！

文章正文：

引言：你是否也遇到了这些“性能瓶颈”？

作为一名Python开发者,你是否曾遇到过这样的场景：

写爬虫：需要抓取100个网页，使用requests库串行请求，耗时漫长；改用多线程，虽然快了，但CPU上下文切换和线程开销巨大,代码也变得臃肿难维护。
做Web服务：当大量用户同时请求API时，数据库查询或第三方API调用等I/O操作导致整个服务线程阻塞，响应缓慢,用户体验极差。
处理高并发任务：无论是实时数据处理还是后台任务队列，传统的同步模型在处理海量并发时,显得力不从心。

如果你的答案是“是”，Python的异步编程，特别是async/await语法，就是你一直在寻找的“性能加速器”，我们就将彻底揭开它的神秘面纱，从理论到实践，让你从“异步小白”蜕变为“异步高手”。

拨开迷雾：什么是异步编程？

在深入async/await之前，我们首先要理解异步编程的核心思想。

（图片来源网络，侵删）

同步编程是我们最熟悉的模式，代码一行一行执行，遇到一个耗时的操作（比如网络请求、文件读写），程序会阻塞在那里，等待这个操作完成后，才会继续执行下一行代码，这就像在食堂排队打饭，你必须等前面的人打完,才能轮到你。

异步编程则完全不同，当程序遇到一个耗时操作时，它不会傻等，而是会“通知”事件循环：“这个任务我先放一放，你先去处理别的，等它完成了，再来叫我。” 程序会立即去执行其他可以执行的任务，这就像你点完餐后，先去找个座位玩手机，餐好了服务员会叫你,而不是在窗口干站着。

异步编程的优势在于它能充分利用等待I/O操作的时间去处理其他任务，从而极大地提高程序的并发能力，尤其是在I/O密集型场景下。

Python异步编程的“三驾马车”：`async`, `await`, 和 `asyncio`

要掌握Python异步编程,你需要了解三个核心概念：

（图片来源网络，侵删）

asyncio：Python官方提供的用于编写并发代码的库，它是整个异步编程框架的基石，提供了事件循环、协程、任务等核心组件。
async：这是一个关键字，用来定义一个协程函数，与普通函数不同，协程函数在被调用时，并不会立即执行函数体，而是返回一个协程对象。
await：这也是一个关键字，只能在async函数内部使用，它的作用是“暂停”当前协程的执行，等待另一个协程执行完成，并获取其结果，在await等待期间,事件循环会去运行其他就绪的协程。

简单比喻：

asyncio：是整个“工厂”的管理者（事件循环）。
async函数：是工厂里的“工人”（协程），他们知道如何完成特定任务,但需要管理者来调度。
await：是工人之间的一种协作方式，一个工人（协程A）在等待某个零件（I/O操作）时，他会告诉管理者（事件循环），然后去帮其他工人（协程B）干活，直到零件到了,再回来继续自己的工作。

Hello World！你的第一个async/await程序

让我们从一个最简单的例子开始,感受一下异步编程的魅力。

1 同步版本（对比用）

import time
def sync_hello():
    print("Hello ...")
    time.sleep(1)  # 阻塞1秒
    print("... World")
def sync_main():
    sync_hello()
    sync_hello()
if __name__ == "__main__":
    start_time = time.time()
    sync_main()
    end_time = time.time()
    print(f"总耗时: {end_time - start_time:.2f}秒")

输出：

Hello ...
... World
Hello ...
... World
总耗时: 2.00秒

可以看到，两个sync_hello调用是串行的,总耗时约2秒。

2 异步版本

import asyncio
import time
async def async_hello():
    print("Hello ...")
    await asyncio.sleep(1)  # 非阻塞的“异步休眠”，让出控制权
    print("... World")
async def async_main():
    # 创建两个任务，让事件循环并发执行
    task1 = asyncio.create_task(async_hello())
    task2 = asyncio.create_task(async_hello())
    # 等待两个任务都完成
    await task1
    await task2
# 在Python 3.7+中，可以直接运行asyncio.run()
if __name__ == "__main__":
    start_time = time.time()
    asyncio.run(async_main())
    end_time = time.time()
    print(f"总耗时: {end_time - start_time:.2f}秒")

输出：

Hello ...
Hello ...
... World
... World
总耗时: 1.01秒

奇迹发生了！ 总耗时从2秒缩短到了1秒，这是因为在第一个asyncio.sleep(1)被调用时，程序没有阻塞，而是立即执行了第二个async_hello的打印语句，两个1秒的等待时间是重叠的,从而实现了并发。

深入解析：`asyncio`核心组件详解

要写出健壮的异步代码，必须理解asyncio的几个核心组件。

1 事件循环

事件循环是asyncio的心脏，它是一个无限循环，负责监视和调度所有协程，当某个协程遇到await并暂停时，事件循环会捕获这个暂停点，然后去运行其他已经准备就绪的协程，当一个被await的操作完成时，事件循环会“唤醒”对应的协程,让它从暂停处继续执行。

在Python 3.7+中，asyncio.run()会自动创建和关闭一个事件循环,非常方便。

2 协程

使用async def语法定义的函数就是协程函数，调用它返回的是一个协程对象，协程对象本身不执行任何代码，它只是一个“任务计划”。

3 任务

任务是对协程的进一步封装，它告诉事件循环：“请帮我运行这个协程”，通过asyncio.create_task()将协程对象包装成任务，这个任务就会被放入事件循环的队列中,与其他任务并发执行。

为什么要用create_task？ 直接await一个协程，是串行执行，而将其封装为任务，则可以实现并发。

import asyncio
async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)
async def main_concurrent():
    print("开始")
    # 创建两个任务，它们会立即开始“计划”
    task1 = asyncio.create_task(say_after(1, 'Hello'))
    task2 = asyncio.create_task(say_after(2, 'World'))
    # 等待两个任务完成
    await task1
    await task2
    print("结束")
async def main_sequential():
    print("开始")
    await say_after(1, 'Hello') # 串行等待
    await say_after(2, 'World') # 串行等待
    print("结束")
# 运行并发版本
asyncio.run(main_concurrent())
# 输出:
# 开始
# (1秒后)
# Hello
# (再过1秒后)
# World
# 结束
# 总耗时约2秒
# 运行串行版本
asyncio.run(main_sequential())
# 输出:
# 开始
# (1秒后)
# Hello
# (再过2秒后)
# World
# 结束
# 总耗时约3秒

这个例子清晰地展示了并发和串行的区别。

4 Future

Future是一个更低级的对象，代表一个“未来的结果”，它通常由库的底层部分使用，普通开发者很少直接接触。Task是Future的一个子类，它增加了对协程的调度功能，你可以把Future看作一个“占位符”,它的最终结果会在未来某个时刻被填充。

异步I/O实战：构建一个高并发爬虫

理论学完了，我们来实战一把！我们将使用aiohttp（一个流行的异步HTTP客户端/服务器库）来构建一个简单的并发爬虫,抓取多个网页的标题。

安装依赖

pip install aiohttp

编写爬虫代码

import asyncio
import aiohttp
from bs4 import BeautifulSoup
async def fetch_url_title(session, url):
    try:
        print(f"正在请求: {url}")
        # 使用aiohttp进行异步GET请求
        async with session.get(url, timeout=10) as response:
            # response.text() 也是一个异步操作，需要await
            html = await response.text()
            soup = BeautifulSoup(html, 'html.parser')
            title = soup.title.string if soup.title else "无标题"
            print(f"完成请求: {url}, 标题: {title}")
            return title
    except Exception as e:
        print(f"请求 {url} 失败: {e}")
        return None
async def main():
    urls = [
        "https://www.python.org",
        "https://github.com",
        "https://www.stackoverflow.com",
        "https://www.baidu.com",
        "https://www.qq.com"
    ]
    # 创建一个aiohttp ClientSession
    async with aiohttp.ClientSession() as session:
        # 为每个URL创建一个任务
        tasks = [fetch_url_title(session, url) for url in urls]
        # 并发执行所有任务
        titles = await asyncio.gather(*tasks)
    print("\n所有任务完成，获取到的标题:")
    for title in titles:
        if title:
            print(f"- {title}")
if __name__ == "__main__":
    start_time = time.time()
    asyncio.run(main())
    end_time = time.time()
    print(f"\n总耗时: {end_time - start_time:.2f}秒")

代码解析：

aiohttp.ClientSession：类似于requests.Session，推荐使用，可以复用连接,提高效率。
async with session.get(...)：这是aiohttp的上下文管理器用法,确保连接被正确关闭。
await response.text()：获取响应内容是I/O操作，必须使用await。
*`asyncio.gather(tasks)`**：这是并发执行多个任务的利器，它会收集所有任务，并等待它们全部完成,最后返回一个包含所有任务结果的列表。

当你运行这段代码时，你会看到所有请求几乎是同时发起的，总耗时接近最慢的那个请求的时间，而不是所有请求时间的总和,这就是异步高并发的威力！

最佳实践与避坑指南

掌握async/await后，遵循一些最佳实践能让你写出更优雅、更健壮的代码。

1 哪些场景适合用异步？

I/O密集型任务：网络请求、数据库操作、文件读写等。
高并发服务：Web API、WebSocket服务器、实时通信应用。
需要处理大量独立事件：如爬虫、数据处理管道。

2 哪些场景不适合用异步？

CPU密集型任务：大量的数学计算、图像处理、数据分析等，因为asyncio是单线程的，CPU密集型任务会阻塞事件循环，导致所有协程都无法执行，对于这类任务，应使用多进程multiprocessing。
第三方库不支持：如果一个库没有提供异步版本（比如requests），在异步代码中直接使用它会阻塞整个事件循环，这时需要寻找其异步替代品（如aiohttp）,或者将其放到一个单独的线程中运行。

3 重要避坑点

async函数中不要使用阻塞I/O：绝对不要在async函数里使用time.sleep()或同步的requests.get()，请使用await asyncio.sleep()和aiohttp等异步库。
await不能用在普通函数里：await只能在async函数内部使用。
asyncio.run()不能嵌套使用：asyncio.run()会创建一个新的事件循环，并在运行结束后关闭它,在已经运行的事件循环中再次调用它会报错。
注意资源管理：使用async with来管理像aiohttp.ClientSession这样的资源,确保它们被正确关闭。

总结与展望

我们系统地学习了Python异步编程的精髓，从同步与异步的区别，到async/await和asyncio的核心概念，再到实战高并发爬虫,最后总结了最佳实践。

核心要点回顾：

异步是解决I/O阻塞、实现高并发的利器。
async 用来定义协程函数，await 用来暂停协程并等待结果。
asyncio 是异步编程的基础,提供事件循环来调度协程。
asyncio.create_task() 和 asyncio.gather() 是实现并发执行的关键工具。
选择正确的工具：I/O密集型用异步,CPU密集型用多进程。

异步编程是Python进阶的必备技能，它不仅能显著提升你应用的性能，更能让你写出更具扩展性和现代感的代码，打开你的编辑器，动手尝试一下，用async/await为你的程序注入新的活力吧！

延伸阅读与资源

Python官方文档：asyncio
aiohttp官方文档
《Python高级编程》（第四版）中有关于异步编程的深入章节。
关注一些技术大牛的博客和GitHub项目,学习他们是如何在实践中应用异步模式的。

#Python异步编程 #asyncio #async/await #高并发 #爬虫 #性能优化 #编程教程

Python中async/await如何高效使用？

文章导语（Meta Description）：

文章正文：

引言：你是否也遇到了这些“性能瓶颈”？

拨开迷雾：什么是异步编程？

Python异步编程的“三驾马车”：`async`, `await`, 和 `asyncio`

Hello World！你的第一个async/await程序

1 同步版本（对比用）

2 异步版本

深入解析：`asyncio`核心组件详解

1 事件循环

2 协程

3 任务

4 Future

异步I/O实战：构建一个高并发爬虫

最佳实践与避坑指南

1 哪些场景适合用异步？

2 哪些场景不适合用异步？

3 重要避坑点

总结与展望

延伸阅读与资源

99ANYc3cd6

Premiere特效教程从哪学？新手如何快速入门？

while ture python

python shuffle 函数

Java字符串如何转为字符？

access入门教程大全

Java Socket编程实例具体怎么实现？

Python中args与kwargs有何区别与用法？

maya python excel

Java如何实现WebSocket？

python expect eof

Scratch打地鼠教程怎么学？

Python如何开发Android应用？

eclipse java 提示

Python如何获取iPhone的GPS数据？

Java正则表达式如何高效提取字符串？

Java如何正确import并使用jar包？

Python中async/await如何高效使用？

文章导语（Meta Description）：

文章正文：

引言：你是否也遇到了这些“性能瓶颈”？

拨开迷雾：什么是异步编程？

Python异步编程的“三驾马车”：async, await, 和 asyncio

Hello World！你的第一个async/await程序

1 同步版本（对比用）

2 异步版本

深入解析：asyncio核心组件详解

1 事件循环

2 协程

3 任务

4 Future

异步I/O实战：构建一个高并发爬虫

最佳实践与避坑指南

1 哪些场景适合用异步？

2 哪些场景不适合用异步？

3 重要避坑点

总结与展望

延伸阅读与资源

相关推荐

Java Socket编程实例具体怎么实现？

Python异步编程的“三驾马车”：`async`, `await`, 和 `asyncio`

深入解析：`asyncio`核心组件详解