🎯 学习目标
📚 前置概念
什么是异步编程？
在传统的同步编程中，任务必须按顺序执行，每个任务必须完成后才能开始下一个任务。这会导致如果某个任务需要等待（如网络请求、文件读写），整个程序都会阻塞。
异步编程允许我们在等待某个任务完成时，转而执行其他任务，充分利用程序的运行时间。
对比示例：
- 同步方式：调用 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 的核心，它管理和调度所有的协程和任务执行：
事件循环的职责：
核心概念关系图
🎓 async 与 await 详解
async 关键字
async 用于定义异步函数（协程）：
# ✅ 正确用法async def fetch_data(): return "data"# ❌ 错误用法def fetch_data(): # 这是普通函数，不是协程 return "data"
async 的作用：
await 关键字
await 用于暂停当前协程，等待另一个异步操作完成：
async def main(): result = await some_async_function() # 等待返回结果 print(result)
await 的作用：
- 暂停
重要限制：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())
示例 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())
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())
# ❌ 错误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提升性能 |
错误处理 | 构建健壮的网络程序 |
💡 提前思考
- 什么是Socket？
- TCP和UDP有什么区别？
- 客户端和服务器如何建立连接？
- 如何同时处理多个客户端？
🔧 预备知识检查
在学习Socket编程前，请确保你已掌握：
- ✅ 函数与异常处理（第 57-64 天）
- ✅ 异步编程基础（async/await，第 69 天）
- ✅ 线程与并发概念（了解即可）
