Python 异步编程实战：async/await 从入门到精通

前言

在如今的 Web 开发和网络编程中，异步编程已经成为必备技能。Python 3.5+ 引入的 `async/await` 语法让异步代码变得像同步代码一样易读。本文将带你从零开始掌握 Python 异步编程的核心概念和实战技巧。

一、什么是异步编程？

异步编程是一种编程范式，允许程序在等待某些操作（如网络请求、文件读写）完成时，转而执行其他任务，而不是阻塞等待。

同步 vs 异步

```python

同步代码 - 阻塞式

import time

def fetch_data_sync():

print("开始获取数据...")

time.sleep(2) # 阻塞 2 秒

print("数据获取完成")

return "data"

fetch_data_sync()

fetch_data_sync() # 必须等第一个完成才能执行第二个

总耗时：4 秒

```

```python

异步代码 - 非阻塞式

import asyncio

async def fetch_data_async():

print("开始获取数据...")

await asyncio.sleep(2) # 非阻塞等待

print("数据获取完成")

return "data"

async def main():

两个任务并发执行

results = await asyncio.gather(

fetch_data_async(),

fetch_data_async()

)

return results

asyncio.run(main())

总耗时：2 秒

```

二、核心概念解析

1. async 和 await

`async`：定义一个协程函数
`await`：等待一个协程执行完成

```python

import asyncio

async def say_hello():

await asyncio.sleep(1)

return "Hello"

async def say_world():

await asyncio.sleep(1)

return "World"

async def main():

顺序执行 - 耗时 2 秒

result1 = await say_hello()

result2 = await say_world()

print(f"{result1} {result2}")

并发执行 - 耗时 1 秒

results = await asyncio.gather(

say_hello(),

say_world()

)

print(f"{results $0$ } {results $1$ }")

asyncio.run(main())

```

2. Task - 调度和管理协程

```python

import asyncio

async def worker(name, delay):

for i in range(3):

await asyncio.sleep(delay)

print(f"{name} 执行第 {i+1} 次")

async def main():

创建任务

task1 = asyncio.create_task(worker("任务 A", 1))

task2 = asyncio.create_task(worker("任务 B", 1.5))

等待所有任务完成

await asyncio.gather(task1, task2)

print("所有任务完成")

asyncio.run(main())

```

三、实战案例：异步网络请求

使用 aiohttp 进行并发 HTTP 请求

```python

import asyncio

import aiohttp

async def fetch_url(session, url):

"""异步获取单个 URL 内容"""

try:

async with session.get(url) as response:

content = await response.text()

return f"{url}: {len(content)} 字节"

except Exception as e:

return f"{url}: 错误 - {e}"

async def fetch_all_urls(urls):

"""并发获取多个 URL"""

async with aiohttp.ClientSession() as session:

tasks = $fetch_url(session, url) for url in urls$

results = await asyncio.gather(*tasks)

return results

async def main():

urls = [

"https://www.python.org",

"https://www.github.com",

"https://www.stackoverflow.com"

]

results = await fetch_all_urls(urls)

for result in results:

print(result)

asyncio.run(main())

```

四、异步编程最佳实践

1. 避免阻塞操作

```python

❌ 错误示例 - 在异步函数中使用同步阻塞

async def bad_example():

import time

await asyncio.sleep(0)

time.sleep(1) # 这会阻塞整个事件循环！

✅ 正确示例 - 使用异步替代方案

async def good_example():

await asyncio.sleep(1) # 非阻塞等待

```

2. 使用 Semaphore 控制并发数

```python

async def fetch_with_limit(sem, url):

async with sem: # 限制同时进行的请求数

return await fetch_url(url)

async def main():

sem = asyncio.Semaphore(5) # 最多 5 个并发

urls = $"http://example.com"$ * 100

tasks = $fetch_with_limit(sem, url) for url in urls$

await asyncio.gather(*tasks)

```

3. 超时处理

```python

async def fetch_with_timeout(url, timeout=5):

try:

async with asyncio.timeout(timeout):

return await fetch_url(url)

except asyncio.TimeoutError:

return f"{url} 请求超时"

```

五、性能对比

| 场景 | 同步方式 | 异步方式 | 提升 |

|------|---------|---------|------|

| 100 个 HTTP 请求 | ~100 秒 | ~2 秒 | 50 倍 |

| 数据库批量查询 | ~50 秒 | ~3 秒 | 16 倍 |

| 文件并发读写 | ~20 秒 | ~5 秒 | 4 倍 |

总结

Python 异步编程的核心优势：

**高并发**：单线程处理大量 I/O 密集型任务
**资源节省**：不需要为每个连接创建线程
**代码清晰**：async/await 让异步代码像同步一样易读
**生态成熟**：aiohttp、asyncpg、aiomysql 等库支持完善

**适用场景**：

Web 爬虫
API 网关
实时数据处理
WebSocket 服务

**不适用场景**：

CPU 密集型计算（考虑多进程）
简单的脚本任务

掌握异步编程，让你的 Python 应用性能起飞！🚀

*如果觉得本文有帮助，欢迎点赞收藏！有问题请在评论区留言~*