02_async_await基础

发表于 更新于 分类于 ， Changyan： 本文字数： 3.2k 阅读时长 ≈ 12 分钟

本课学习Python异步编程的两个核心关键字：async和await。async用来定义可以”暂停”的函数，await用来等待异步操作（等待时不阻塞程序）。就像餐厅点餐，你点完餐拿到号码牌（async），然后去找座位玩手机（await），叫号时再去取餐。我们将通过咖啡机、倒计时等实用示例，让你完全掌握这两个关键字，并能编写自己的异步程序。

📖 课程目标

  • 理解 async 和 await 关键字的作用
  • 掌握协程（Coroutine）的概念
  • 学会运行异步函数的多种方法
  • 编写第一个实用的异步程序

🔑 核心概念

1. async：定义异步函数

async 关键字用来定义一个异步函数（也叫协程函数）：

1
2
3
4
5
6
7
# 普通函数
def normal_function():
    return "我是普通函数"

# 异步函数（协程函数）
async def async_function():
    return "我是异步函数"

关键区别：

  • 普通函数：调用后立即执行，返回结果
  • 异步函数：调用后返回一个”协程对象”，需要用特殊方式运行

2. await：等待异步操作

await 关键字用来等待一个异步操作完成：

1
2
3
4
5
async def download_file():
    print("开始下载...")
    await asyncio.sleep(3)  # 等待3秒，但不阻塞其他任务
    print("下载完成！")
    return "文件内容"

await 的特点：

  • 只能在 async 函数内使用
  • 等待时，程序可以去执行其他任务
  • 等待完成后，继续执行后面的代码

🎪 生活类比：餐厅点餐

想象你在餐厅点餐：

普通函数（同步）

1
2
3
4
5
6
你：老板，来份炒饭！
老板：好的！[开始炒饭]
你：[站在那里等待...]
老板：[炒了10分钟]
老板：炒饭好了！
你：[拿到炒饭，离开]

异步函数（async/await）

1
2
3
4
5
6
你：老板，来份炒饭！(async def 点餐)
老板：好的，请稍等！[给你一个号码牌]
你：[拿着号码牌，去找座位、玩手机] (await)
老板：[炒饭中...]
老板：36号，您的炒饭好了！
你：[听到叫号，去取餐]

关键点：

  • async def = 点餐（发起请求）
  • await = 等待叫号（等待时可以做其他事）
  • 号码牌 = 协程对象

📝 基础语法详解

语法1：定义异步函数

1
2
3
4
5
6
7
8
# 格式
async def function_name(param):
    # 函数体
    return result

# 示例
async def greet(name: str) -> str:
    return f"你好，{name}！"

语法2：调用异步函数

1
2
3
4
5
6
7
8
9
10
11
# ❌ 错误方式：直接调用
result = greet("小明")  # 这样只会得到一个协程对象，不会执行

# ✅ 正确方式1：使用 await（在另一个异步函数中）
async def main():
    result = await greet("小明")  # 会真正执行
    print(result)

# ✅ 正确方式2：使用 asyncio.run（在主程序中）
import asyncio
asyncio.run(main())

语法3：使用 await 等待

1
2
3
4
5
6
7
8
9
10
11
12
13
async def do_things():
    print("步骤1：开始")

    # 等待异步操作
    await asyncio.sleep(2)  # 等待2秒

    print("步骤2：继续")

    # 等待另一个异步函数
    result = await other_async_function()

    print("步骤3：completed")
    return result

🔍 协程（Coroutine）是什么？

定义

协程是一个可以”暂停”和”恢复”的函数。

生活类比：看书

1
2
3
4
5
6
7
普通函数 = 一口气读完一本书
    开始 → 读完 → 结束
    
协程 = 可以随时放下，随时继续的书
    开始 → 读一会儿 → 暂停（去做其他事）
         → 继续读 → 暂停（去做其他事）
         → 继续读 → 结束

代码示例

1
2
3
4
5
6
7
8
async def coroutine_example():
    print("第1步：开始执行")

    await asyncio.sleep(1)  # 暂停点1
    print("第2步：继续执行")

    await asyncio.sleep(1)  # 暂停点2
    print("第3步：completed")

执行流程：

  1. 执行到第一个 await → 暂停 → 去执行其他任务
  2. 1秒后 → 恢复 → 继续执行
  3. 执行到第二个 await → 暂停 → 去执行其他任务
  4. 1秒后 → 恢复 → 完成

🚀 运行异步函数的方法

方法1：asyncio.run()（最常用）

1
2
3
4
5
6
7
8
9
10
import asyncio

async def main():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

# 在主程序中运行
if __name__ == "__main__":
    asyncio.run(main())

特点：

  • ✅ 最简单、最推荐的方式
  • ✅ 自动创建和关闭事件循环
  • ✅ Python 3.7+ 可用

方法2：await（在异步函数内）

1
2
3
4
5
6
7
8
9
10
11
12
async def task_A():
    print("任务A")
    await asyncio.sleep(1)

async def task_B():
    print("任务B")
    await task_A()  # 在异步函数内调用另一个异步函数

async def main():
    await task_B()

asyncio.run(main())

方法3：asyncio.create_task()（创建后台任务）

1
2
3
4
5
6
7
8
async def main():
    # 创建任务，立即开始执行
    task = asyncio.create_task(async_function())
    
    # 做其他事情...
    
    # 等待任务完成
    result = await task

方法4：asyncio.gather()（同时运行多个）

1
2
3
4
5
6
7
async def main():
    # 同时运行多个异步函数
    result = await asyncio.gather(
        async_function1(),
        async_function2(),
        async_function3()
    )

💡 常见错误和解决方案

错误1：忘记使用 await

1
2
3
4
5
6
7
8
9
# ❌ 错误
async def main():
    result = async_function()  # 只得到协程对象，不会执行
    print(result)  # 输出：<coroutine object ...>

# ✅ 正确
async def main():
    result = await async_function()  # 真正执行
    print(result)

错误2：在普通函数中使用 await

1
2
3
4
5
6
7
# ❌ 错误
def normal_function():
    await asyncio.sleep(1)  # 语法错误！

# ✅ 正确
async def async_function():
    await asyncio.sleep(1)  # 正确

错误3：忘记使用 asyncio.run()

1
2
3
4
5
6
7
8
9
10
11
12
13
# ❌ 错误
async def main():
    print("Hello")

main()  # 只创建协程对象，不会执行

# ✅ 正确
import asyncio

async def main():
    print("Hello")

asyncio.run(main())  # 真正执行

🎯 实战练习：智能咖啡机

让我们用异步编程模拟一个智能咖啡机！

需求

  1. 咖啡机可以同时处理多个订单
  2. 每杯咖啡需要不同的制作时间
  3. 显示制作进度

代码框架

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
async def make_coffee(order_id: int, coffee_type: str, brew_time: int) -> str:
    """制作一杯咖啡"""
    print(f"☕ 订单{order_id}：开始制作{coffee_type}...")

    # 模拟制作过程
    await asyncio.sleep(brew_time)

    print(f"✅ 订单{order_id}：{coffee_type}制作完成！")
    return f"{coffee_type}（订单{order_id}）"

async def coffee_shop_operation():
    """同时处理多个订单"""
    order_list = [
        (1, "美式咖啡", 3),
        (2, "拿铁", 4),
        (3, "卡布奇诺", 5),
        (4, "摩卡", 4),
    ]

    # 同时制作所有咖啡
    task_list = [make_coffee(order_id, coffee_type, brew_time)
               for order_id, coffee_type, brew_time in order_list]

    results = await asyncio.gather(*task_list)

    print(f"\n🎉 今日完成订单：{len(results)}杯")
    for coffee in results:
        print(f"  - {coffee}")

完整代码在 02_examples.py 中！

📊 同步 vs 异步对比

场景：制作4杯咖啡

方式制作时间总耗时客户体验
同步3+4+5+4=16秒16秒😤 等太久
异步max(3,4,5,4)=5秒5秒😊 很快

📝 本课小结

核心语法

1
2
3
4
5
6
7
8
9
10
11
12
# 1. 定义异步函数
async def function_name():
    pass

# 2. 等待异步操作
await async_function()

# 3. 运行异步函数
asyncio.run(main())

# 4. 同时运行多个
await asyncio.gather(function1(), function2())

记住这些要点

  1. async def = 定义可以暂停的函数
  2. await = 等待时可以做其他事
  3. 协程 = 可以暂停和恢复的函数
  4. asyncio.run() = 启动异步程序的入口

使用场景

  • ✅ 网络请求（下载、API调用）
  • ✅ 文件读写（大文件、批量操作）
  • ✅ 数据库查询（批量查询）
  • ✅ 任何需要”等待”的操作

🎯 下一步

  1. 运行 02_examples.py 查看完整示例
  2. 修改代码，尝试不同的参数
  3. 完成课后练习题
  4. 准备学习第3课：并发执行多个任务

💪 课后练习

练习1：异步倒计时

编写一个异步倒计时函数，从10倒数到1。

1
2
3
async def countdown(seconds: int):
    # 你的代码
    pass

练习2：异步问候

编写一个异步函数，向3个人依次问候，每次问候间隔1秒。

1
2
3
async def greet_multiple_people(name_list: List[str]):
    # 你的代码
    pass

练习3：模拟下载

编写一个异步函数，模拟同时下载3个文件，每个文件大小不同。

1
2
3
async def download_file(filename: str, size_mb: int):
    # 你的代码（假设每MB需要0.5秒）
    pass

答案在 练习答案.py 中！ 先自己尝试，再看答案哦！😊

02_examples.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
"""
第2课示例代码：async/await 基础语法

运行方式：
    python 02_examples.py
"""

import asyncio
import time
from typing import List


# ============================================
# 示例1：最简单的异步函数
# ============================================

async def simple_greeting(name: str) -> str:
    """最简单的异步函数"""
    print(f"你好，{name}！")
    await asyncio.sleep(1)  # 等待1秒
    print(f"很高兴见到你，{name}！")
    return f"问候完成：{name}"


async def example1_basic_syntax() -> None:
    """示例1：演示基础的 async/await 语法"""
    print("\n" + "=" * 50)
    print("📚 示例1：最简单的异步函数")
    print("=" * 50)

    # 调用异步函数
    result = await simple_greeting("小明")
    print(f"返回值：{result}")

    print("\n💡 关键点：")
    print("  1. 用 async def 定义异步函数")
    print("  2. 用 await 等待异步操作")
    print("  3. await 只能在 async 函数内使用")


# ============================================
# 示例2：协程的暂停和恢复
# ============================================

async def demonstrate_pause_resume() -> None:
    """展示协程如何暂停和恢复"""
    print("\n" + "=" * 50)
    print("📚 示例2：协程的暂停和恢复")
    print("=" * 50)

    print("▶️  步骤1：开始执行")

    print("⏸️  暂停1秒（这时可以执行其他任务）...")
    await asyncio.sleep(1)

    print("▶️  步骤2：恢复执行")

    print("⏸️  暂停1秒（这时可以执行其他任务）...")
    await asyncio.sleep(1)

    print("▶️  步骤3：继续执行")

    print("⏸️  暂停1秒（这时可以执行其他任务）...")
    await asyncio.sleep(1)

    print("✅ 步骤4：completed！")

    print("\n💡 关键点：")
    print("  协程在每个 await 处暂停，等待完成后恢复")
    print("  暂停期间，程序可以去执行其他协程")


# ============================================
# 示例3：多个异步函数协作
# ============================================

async def boil_water() -> str:
    """烧水"""
    print("🔥 开始烧水...")
    await asyncio.sleep(3)
    print("💧 水烧开了！")
    return "开水"


async def brew_tea(water: str) -> str:
    """泡茶"""
    print(f"🍵 用{water}泡茶...")
    await asyncio.sleep(2)
    print("☕ 茶泡好了！")
    return "一杯茶"


async def example3_function_collaboration() -> None:
    """示例3：多个异步函数协作"""
    print("\n" + "=" * 50)
    print("📚 示例3：多个异步函数协作")
    print("=" * 50)

    start_time = time.time()

    # 先烧水，再泡茶（顺序执行）
    water = await boil_water()
    tea = await brew_tea(water)

    total_time = time.time() - start_time

    print(f"\n✅ completed！得到：{tea}")
    print(f"⏱️  total_time：{total_time:.1f}秒")

    print("\n💡 关键点：")
    print("  使用 await 可以在异步函数之间传递数据")
    print("  这里是顺序执行：先烧水，再泡茶")


# ============================================
# 示例4：实战 - 智能咖啡机
# ============================================

async def make_coffee(order_id: int, coffee_type: str, brew_time: int) -> str:
    """制作一杯咖啡"""
    print(f"☕ 订单{order_id}：开始制作{coffee_type}...")

    # 模拟制作过程（分步显示进度）
    for progress in range(1, 4):
        await asyncio.sleep(brew_time / 3)
        print(f"   订单{order_id}：制作进度 {progress}/3")

    print(f"✅ 订单{order_id}：{coffee_type}制作完成！")
    return f"{coffee_type}（订单{order_id}）"


async def coffee_shop_sequential() -> None:
    """咖啡店营业 - 顺序处理订单（同步方式）"""
    print("\n" + "=" * 50)
    print("📚 示例4A：咖啡店 - 顺序处理订单")
    print("=" * 50)

    start_time = time.time()

    order_list = [
        (1, "美式咖啡", 3),
        (2, "拿铁", 4),
        (3, "卡布奇诺", 5),
    ]

    completed_coffees = []

    # 一个一个处理订单
    for order_id, coffee_type, brew_time in order_list:
        coffee = await make_coffee(order_id, coffee_type, brew_time)
        completed_coffees.append(coffee)

    total_time = time.time() - start_time

    print(f"\n🎉 完成订单：{len(completed_coffees)}杯")
    for coffee in completed_coffees:
        print(f"  - {coffee}")
    print(f"⏱️  total_time：{total_time:.1f}秒")

    print("\n💭 分析：顺序处理，效率较低...")


async def coffee_shop_concurrent() -> None:
    """咖啡店营业 - 并发处理订单（异步方式）"""
    print("\n" + "=" * 50)
    print("📚 示例4B：咖啡店 - 并发处理订单")
    print("=" * 50)

    start_time = time.time()

    order_list = [
        (1, "美式咖啡", 3),
        (2, "拿铁", 4),
        (3, "卡布奇诺", 5),
    ]

    # 同时处理所有订单
    task_list = [make_coffee(order_id, coffee_type, brew_time)
            for order_id, coffee_type, brew_time in order_list]

    completed_coffees = await asyncio.gather(*task_list)

    total_time = time.time() - start_time

    print(f"\n🎉 完成订单：{len(completed_coffees)}杯")
    for coffee in completed_coffees:
        print(f"  - {coffee}")
    print(f"⏱️  total_time：{total_time:.1f}秒")

    print("\n💭 分析：并发处理，效率大大提高！")


# ============================================
# 示例5：常见错误演示
# ============================================

async def example5_common_errors() -> None:
    """示例5：演示常见错误和正确做法"""
    print("\n" + "=" * 50)
    print("📚 示例5：常见错误和正确做法")
    print("=" * 50)

    # 错误1：忘记使用 await
    print("\n❌ 错误1：忘记使用 await")
    print("代码：result = simple_greeting('小红')")
    result_error = simple_greeting("小红")  # 只得到协程对象
    print(f"result：{result_error}")
    print("说明：这样只会得到协程对象，不会真正执行！")

    # 正确做法
    print("\n✅ 正确做法：使用 await")
    print("代码：result = await simple_greeting('小红')")
    result_correct = await simple_greeting("小红")
    print(f"result：{result_correct}")
    print("说明：使用 await 才会真正执行！")

    print("\n💡 记住：")
    print("  调用异步函数时，一定要用 await")
    print("  否则只会得到协程对象，不会执行")


# ============================================
# 示例6：实用工具函数
# ============================================

async def async_countdown(seconds: int) -> None:
    """异步倒计时"""
    print(f"\n⏰ countdown {seconds} 秒...")
    for i in range(seconds, 0, -1):
        print(f"  {i}...")
        await asyncio.sleep(1)
    print("  🎉 时间到！")


async def async_progress_bar(task_name: str, total_steps: int, step_duration: float) -> None:
    """异步进度条"""
    print(f"\n📊 {task_name}")
    for step in range(1, total_steps + 1):
        progress_percentage = (step / total_steps) * 100
        progress_bar = "█" * step + "░" * (total_steps - step)
        print(f"  [{progress_bar}] {progress_percentage:.0f}%", end="\r")
        await asyncio.sleep(step_duration)
    print(f"  [{'█' * total_steps}] 100% ✅")


async def example6_utility_tools() -> None:
    """示例6：实用的异步工具函数"""
    print("\n" + "=" * 50)
    print("📚 示例6：实用的异步工具函数")
    print("=" * 50)

    # 同时运行倒计时和进度条
    await asyncio.gather(
        async_countdown(5),
        async_progress_bar("download_file", 10, 0.5)
    )

    print("\n💡 关键点：")
    print("  可以创建各种实用的异步工具函数")
    print("  用 asyncio.gather 可以同时运行多个")


# ============================================
# 主程序
# ============================================

async def main() -> None:
    """主程序：运行所有示例"""
    print("🎓 第2课：async/await 基础语法")
    print("=" * 50)

    # 运行所有示例
    await example1_basic_syntax()
    await demonstrate_pause_resume()
    await example3_function_collaboration()
    await coffee_shop_sequential()
    await coffee_shop_concurrent()
    await example5_common_errors()
    await example6_utility_tools()

    # 总结
    print("\n" + "=" * 50)
    print("🎉 第2课完成！")
    print("=" * 50)
    print("""
📚 你学到了什么？
    1. async def - 定义异步函数
    2. await - 等待异步操作（可以暂停）
    3. asyncio.run() - 运行异步程序
    4. asyncio.gather() - 同时运行多个任务
    5. 协程可以暂停和恢复
    
🎯 核心语法：
    async def function_name():        # 定义异步函数
        result = await 异步操作()  # 等待异步操作
        return result
    
    asyncio.run(函数名())       # 运行异步函数
    
💪 动手练习：
    1. 修改咖啡制作时间，观察效果
    2. 增加更多咖啡订单
    3. 创建自己的异步函数
    4. 完成课后练习题
    
🎯 下一步：
    学习更多并发控制技巧（第3课）
    """)


if __name__ == "__main__":
    # 运行主程序
    asyncio.run(main())