当前位置:首页>python>【一起学 Python】第 69 天:Asyncio 基础:async 与 await

【一起学 Python】第 69 天:Asyncio 基础:async 与 await

  • 2026-10-11 08:36:53
【一起学 Python】第 69 天:Asyncio 基础:async 与 await

🎯 学习目标

  • 理解异步编程的核心概念
  • 掌握 async 和 await 的用法
  • 学会使用 asyncio 编写异步程序
  • 理解事件循环的工作原理

📚 前置概念

什么是异步编程?

在传统的同步编程中,任务必须按顺序执行,每个任务必须完成后才能开始下一个任务。这会导致如果某个任务需要等待(如网络请求、文件读写),整个程序都会阻塞。

异步编程允许我们在等待某个任务完成时,转而执行其他任务,充分利用程序的运行时间。

对比示例:

  • 同步方式:调用 4 个 3 秒的网络请求 → 总耗时 12 秒
  • 异步方式:并发调用 4 个 3 秒的网络请求 → 总耗时 3 秒(提升 4 倍!)

🔑 核心概念

1. Coroutine(协程)

协程是异步编程的基础单元,通过 async def 定义:

async def hello():    return "Hello, Asyncio!"

协程的特点:

  • 可以被暂停和恢复执行
  • 不能直接调用,必须通过 await 或事件循环调用
  • 返回一个 Coroutine 对象,不是直接执行结果
async def example():    passcoro = example()print(coro)  # <coroutine object example at 0x...># ⚠️ 这只是创建了对象,还没有执行!

2. Task(任务)

Task 是对协程的包装,告诉事件循环"请调度执行这个协程"。

import asyncioasync def my_task():    print("Task is running")    await asyncio.sleep(1)    print("Task completed")# 创建 Tasktask = asyncio.create_task(my_task())# 或者使用 ensure_future(旧写法)# task = asyncio.ensure_future(my_task())

3. Future(未来对象)

Future 代表一个异步操作的结果,当前可能不可用,但未来会有值:

# Future 通常由底层库自动创建# 例如 asyncio.sleep() 返回的就是一个 Future

4. Event Loop(事件循环)

事件循环是 asyncio 的核心,它管理和调度所有的协程和任务执行:

事件循环的职责:

  1. 初始化和启动
  2. 检查是否有任务等待执行
  3. 选择就绪的任务并执行
  4. 如果任务遇到 await,将其挂起
  5. 切换到下一个待执行任务
  6. 等待被挂起任务的 I/O 操作完成
  7. 恢复任务执行
  8. 重复直到所有任务完成

核心概念关系图

🎓 async 与 await 详解

async 关键字

async 用于定义异步函数(协程):

# ✅ 正确用法async def fetch_data():    return "data"# ❌ 错误用法def fetch_data():  # 这是普通函数,不是协程    return "data"

async 的作用:

  • 将普通函数转换为协程
  • 允许函数体中使用 await 表达式

await 关键字

await 用于暂停当前协程,等待另一个异步操作完成:

async def main():    result = await some_async_function()  # 等待返回结果    print(result)

await 的作用:

  1. 暂停
    当前协程的执行
  2. 将控制权交给事件循环
  3. 事件循环可以去执行其他任务
  4. 当被等待的操作完成时,恢复此协程
  5. 获得操作的结果

重要限制:await 只能在 async def 函数中使用!

# ✅ 正确async def good():    await asyncio.sleep(1)# ❌ 错误def bad():    await asyncio.sleep(1)  # SyntaxError: 'await' outside async function

async/await 语法解析

💻 实战代码示例

示例 1:最简单的异步程序

import asyncioasync def say_hello():    print("你好")    await asyncio.sleep(1)  # 模拟耗时操作    print("世界")# 方式1:使用 asyncio.run()(推荐,Python 3.7+)asyncio.run(say_hello())# 方式2:使用事件循环(旧写法)# loop = asyncio.get_event_loop()# loop.run_until_complete(say_hello())
输出:
你好(等待 1 秒)世界

示例 2:并发执行多个任务

import asyncioasync def fetch_data(url, delay):    print(f"开始获取: {url}")    await asyncio.sleep(delay)  # 模拟网络请求    print(f"完成获取: {url}")    return f"Data from {url}"async def main():    # 并发执行三个任务    task1 = asyncio.create_task(fetch_data("http://api1.com", 1 ))    task2 = asyncio.create_task(fetch_data("http://api2.com", 2 ))    task3 = asyncio.create_task(fetch_data("http://api3.com", 1.5 ))    # 等待所有任务完成    results = await asyncio.gather(task1, task2, task3)    return results# 执行results = asyncio.run(main())print("所有结果:", results)
输出:
开始获取: http://api1.com开始获取: http://api2.com开始获取: http://api3.com完成获取: http://api1.com完成获取: http://api3.com完成获取: http://api2.com所有结果: ['Data from http://api1.com', 'Data from http://api2.com', 'Data from http://api3.com']

关键点:

  • 三个任务几乎同时开始(异步并发 )
  • 总耗时约 2 秒(取决于最长的任务),而不是 4.5 秒

示例 3:async/await 执行流程

import asyncioasync def task_a():    print("[A] 开始执行")    await asyncio.sleep(1)    print("[A] 完成执行")    return "A的结果"async def task_b():    print("[B] 开始执行")    await asyncio.sleep(0.5)    print("[B] 完成执行")    return "B的结果"async def main():    # 顺序等待(同步风格)    result_a = await task_a()  # 等待 1 秒    result_b = await task_b()  # 再等待 0.5 秒,总共 1.5 秒    print(f"结果A: {result_a}")    print(f"结果B: {result_b}")asyncio.run(main())
vs 并发方式:
async def main_concurrent():    # 并发执行(推荐)    results = await asyncio.gather(task_a(), task_b())  # 总共只需 1 秒!    print(f"结果: {results}")asyncio.run(main_concurrent())

示例 4:处理异常

import asyncioasync def risky_task():    await asyncio.sleep(0.5)    raise ValueError("发生了一个错误")async def safe_main():    try:        await risky_task()    except ValueError as e:        print(f"捕获异常: {e}")asyncio.run(safe_main())

🛠️ 常用 asyncio 函数

函数

用途

示例

asyncio.run()

运行异步程序的入口

asyncio.run(main())

asyncio.create_task()

将协程包装为 Task

task = asyncio.create_task(coro())

asyncio.gather()

等待多个任务完成

await asyncio.gather(task1, task2)

asyncio.sleep()

异步延迟

await asyncio.sleep(1)

asyncio.wait()

等待任务集合

done, pending = await asyncio.wait(tasks)

asyncio.get_event_loop()

获取当前事件循环

loop = asyncio.get_event_loop()

⚡ 常见陷阱

1. 忘记 await

# ❌ 错误:没有 await,协程没有执行async def main():    fetch_data()  # 这只是创建了协程对象,并未执行# ✅ 正确async def main():    await fetch_data()  # 执行协程

2. 混淆 Coroutine 和 Task

# Coroutine:还没有被调度执行coro = fetch_data()# Task:已被调度,等待执行task = asyncio.create_task(fetch_data())# 在 asyncio.gather 中,两者都可以用await asyncio.gather(fetch_data(), fetch_data())
3. 在同步代码中调用异步函数
# ❌ 错误def synchronous_function():    result = await async_function()  # SyntaxError# ✅ 正确:需要在异步上下文中async def wrapper():    result = await async_function()    return result

📊 同步 vs 异步对比

特性

同步(Synchronous)

异步(Asynchronous)

执行方式

顺序执行,一个接一个

并发执行,交错进行

等待处理

阻塞整个程序

切换到其他任务

性能

低效(I/O 密集型)

高效(I/O 密集型)

代码复杂度

简单,易理解

相对复杂,需学习 async/await

适用场景

CPU 密集型任务

I/O 密集型任务


🎉 进阶阶段完结!

恭喜你!完成了 进阶阶段:类型提示与工程化(第 51-69 天) 的全部学习!

阶段回顾

┌─────────────────────────────────────────────────────────┐│              进阶阶段学习成果                             │├─────────────────────────────────────────────────────────┤│                                                           ││  📊 类型提示模块(第 52-56 天)                          ││     ├─ 联合类型、类型别名、泛型                          ││     └─ 让代码更安全、更易维护                            ││                                                           ││  🛡️ 异常与文件模块(第 57-64 天)                        ││     ├─ 异常处理、文件 I/O、上下文管理器                  ││     └─ 编写健壮的错误处理机制                            ││                                                           ││  ⚡ 并发与迭代模块(第 65-69 天)                        ││     ├─ 迭代器、生成器、GIL、Asyncio                      ││     └─ 高效的数据处理与并发编程                          ││                                                           │└─────────────────────────────────────────────────────────┘

恭喜你完成了 进阶阶段:类型提示与工程化(第 51-69 天) 的全部学习!从今天开始,我们将进入 网络编程模块:Socket编程基础(第 70-73 天)。

这是Python网络编程的核心基础!掌握Socket编程,你将能够:

  • 理解网络通信的底层原理
  • 构建TCP/UDP网络应用
  • 实现客户端-服务器架构
  • 为学习Web开发、分布式系统打下基础

📚 本模块学习路线(第 70-73 天)

第 70 天:Socket API基础:创建TCP与UDP连接

  • Socket的基本概念
  • TCP vs UDP协议区别
  • 创建Socket连接
  • 客户端-服务器模型

第 71 天:Python 3.14中的异步Socket编程(asyncio与Socket)

  • 结合asyncio实现异步网络编程
  • 高并发Socket服务器
  • 异步客户端实现

第 72 天:Socket错误处理与超时机制

  • 网络异常处理
  • 连接超时设置
  • 重连机制
  • 健壮的网络应用设计

第 73 天:基于Socket的简单聊天应用实现

  • 综合实战项目
  • 多客户端聊天室
  • 消息广播机制
  • 完整应用架构

🎯 模块核心目标

目标

说明

理解网络基础

TCP/IP协议、端口、IP地址

掌握Socket API

socket模块的核心方法

实现网络应用

从理论到实践

异步编程

结合asyncio提升性能

错误处理

构建健壮的网络程序

💡 提前思考

  1. 什么是Socket?
    • 为什么被称为"网络通信的基石"?
  2. TCP和UDP有什么区别?
    • 什么场景用TCP?什么场景用UDP?
  3. 客户端和服务器如何建立连接?
    • 三次握手是什么?
  4. 如何同时处理多个客户端?
    • 多线程?多进程?异步IO?

🔧 预备知识检查

在学习Socket编程前,请确保你已掌握:

  • ✅ 函数与异常处理(第 57-64 天)
  • ✅ 异步编程基础(async/await,第 69 天)
  • ✅ 线程与并发概念(了解即可)

最新文章

随机文章