async/await关键字 - 元素码农

发布时间: 2025-03-30 09:51

↑

# async/await关键字

`async`和`await`是Python中用于异步编程的关键字。`async`用于定义协程函数，而`await`用于等待一个协程完成。这两个关键字是Python异步编程的基础。

## 基本用法

```python
import asyncio

async def fetch_data():
    print("开始获取数据...")
    await asyncio.sleep(2)  # 模拟IO操作
    print("数据获取完成！")
    return "数据"

async def main():
    result = await fetch_data()
    print(f"获取到结果：{result}")

# 运行协程
asyncio.run(main())
```

## 工作原理

1. `async def`定义一个协程函数。
2. 协程函数返回一个协程对象。
3. `await`暂停当前协程的执行，等待另一个协程完成。
4. 事件循环调度和管理协程的执行。

## 使用场景

1. **网络IO**：处理HTTP请求、WebSocket等。
2. **文件IO**：异步读写文件。
3. **并发操作**：同时处理多个任务。

## 并发执行

```python
import asyncio

async def task1():
    await asyncio.sleep(1)
    return "任务1完成"

async def task2():
    await asyncio.sleep(2)
    return "任务2完成"

async def main():
    # 并发执行多个任务
    results = await asyncio.gather(task1(), task2())
    print(results)  # ['任务1完成', '任务2完成']

asyncio.run(main())
```

## 异步上下文管理器

```python
class AsyncResource:
    async def __aenter__(self):
        print("获取资源")
        await asyncio.sleep(1)
        return self

async def __aexit__(self, exc_type, exc_val, exc_tb):
        print("释放资源")
        await asyncio.sleep(1)

async def use_resource():
    async with AsyncResource() as resource:
        print("使用资源")
```

## 异步迭代器

```python
class AsyncIterator:
    def __init__(self, stop):
        self.current = 0
        self.stop = stop

def __aiter__(self):
        return self

async def __anext__(self):
        if self.current < self.stop:
            await asyncio.sleep(1)
            self.current += 1
            return self.current - 1
        raise StopAsyncIteration

async def use_iterator():
    async for num in AsyncIterator(3):
        print(num)
```

## 最佳实践

1. **避免阻塞**：不要在协程中使用阻塞操作。
2. **合理分组**：使用`gather`或`as_completed`组织多个协程。
3. **异常处理**：妥善处理异步操作中的异常。

## 常见陷阱

1. **同步阻塞**：在协程中使用同步操作会阻塞事件循环。
2. **忘记await**：调用协程函数时忘记使用await。
3. **嵌套事件循环**：在协程中创建新的事件循环。

## 实际应用

### 1. 异步HTTP请求

```python
import aiohttp
import asyncio

async def fetch_url(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        urls = [
            'http://example.com',
            'http://example.org',
            'http://example.net'
        ]
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        return results
```

### 2. 异步数据库操作

```python
import asyncpg

async def get_user(pool, user_id):
    async with pool.acquire() as conn:
        return await conn.fetchrow(
            'SELECT * FROM users WHERE id = $1',
            user_id
        )

async def main():
    pool = await asyncpg.create_pool(
        user='user',
        password='password',
        database='database',
        host='localhost'
    )
    user = await get_user(pool, 1)
    await pool.close()
```

## 总结

`async`和`await`关键字是Python异步编程的核心。它们提供了一种优雅的方式来编写非阻塞的并发代码。通过使用这些关键字，我们可以编写高效的异步程序，特别是在处理IO密集型任务时。要注意避免常见陷阱，遵循最佳实践，合理组织异步代码的结构。异步编程虽然强大，但也需要谨慎使用，确保在适当的场景下应用。