Python 异步与面向对象：从“指令”到“架构”的范式跃迁
文章目录
序幕：代码的两次进化
第一模块：异步编程 —— 让代码学会“一心多用”
1.1 同步 vs 异步：从“排队”到“并行等待”
同步：你点了一杯咖啡，站着干等
异步：同时下单，谁先好先拿谁
1.2 三大核心概念
1.3 关键语法对比表
第二模块：面向对象 —— 从函数到蓝图，从蓝图到生命
2.1 为什么需要面向对象？
2.2 类与对象：蓝图与实体的关系
2.3 类的定义与实例化
2.4 __init__ 初始化方法 —— 对象诞生的第一声啼哭
self 是什么？
2.5 完整示例：一个活的学生类
2.6 类的属性与实例的属性
🎯 今日核心知识速查
异步模块
面向对象模块
终章：你站在了哪里
序幕：代码的两次进化
如果把写代码比作盖房子，那你之前学的东西——变量、函数、循环、装饰器——都是在搬砖。你把一块块砖码得整整齐齐，房子能住人，但经不起大风大浪。
今天我们要完成两次跃迁：
第一次跃迁：异步编程—— 把代码从“单线程苦力”变成“多任务总管”。以前你写代码是干完一件事再干下一件，现在你能同时等好几件事，谁先准备好就先处理谁，效率直接拉满。
第二次跃迁：面向对象编程（OOP）—— 把代码从“一堆散装函数”变成“一个有血有肉的系统”。你不再写“先做A再做B再做C”，而是创造一个世界，里面住着各种“对象”，它们各有属性、各有技能，互相协作完成目标。
如果说之前的你是个会写脚本的程序员，今天之后，你就是一个能设计系统的架构师。
这不是风格的微调，是维度的提升。准备好了吗？开始。🚀
第一模块：异步编程 —— 让代码学会“一心多用”
1.1 同步 vs 异步：从“排队”到“并行等待”
同步：你点了一杯咖啡，站着干等
python
import time def make_coffee(): time.sleep(3) # 咖啡机工作3秒 return "☕ 咖啡好了" def toast_bread(): time.sleep(2) # 烤面包机工作2秒 return "🍞 吐司好了" def breakfast(): coffee = make_coffee() # 先做咖啡，干等3秒 toast = toast_bread() # 再做吐司，干等2秒 return coffee, toast start = time.time() print(breakfast()) print(f"总耗时：{time.time() - start:.1f}秒")输出：
text
('☕ 咖啡好了', '🍞 吐司好了') 总耗时：5.0秒📌 同步的问题是：CPU在等，但你无能为力。咖啡机工作的时候，CPU什么都不干，就在那儿等着。5秒钟做两件事，效率极低。
异步：同时下单，谁先好先拿谁
python
import asyncio async def make_coffee(): await asyncio.sleep(3) # 模拟等待，但CPU不闲着 return "☕ 咖啡好了" async def toast_bread(): await asyncio.sleep(2) return "🍞 吐司好了" async def breakfast(): # 同时发起两个任务 coffee_task = asyncio.create_task(make_coffee()) toast_task = asyncio.create_task(toast_bread()) # 等待两个都完成 coffee = await coffee_task toast = await toast_task return coffee, toast start = time.time() result = asyncio.run(breakfast()) print(result) print(f"总耗时：{time.time() - start:.1f}秒")输出：
text
('☕ 咖啡好了', '🍞 吐司好了') 总耗时：3.0秒📌 异步的威力：同时发起两个任务，总耗时等于最慢的那个，而不是相加。咖啡3秒，吐司2秒，总耗时3秒。省了2秒。
1.2 三大核心概念
| 概念 | 写法 | 作用 |
|---|---|---|
| 异步函数 | async def func(): | 定义一个可暂停的函数 |
| 等待 | await 异步操作 | 在异步函数里等待另一个异步操作完成 |
| 任务 | asyncio.create_task() | 把一个异步函数包装成“可并发执行的任务” |
1.3 关键语法对比表
| 同步写法 | 异步写法 | 区别 |
|---|---|---|
def func(): | async def func(): | 函数变“异步” |
time.sleep(1) | await asyncio.sleep(1) | 等待时不阻塞 |
result = func() | result = await func() | 等待异步结果 |
func() | asyncio.run(func()) | 启动异步入口 |
第二模块：面向对象 —— 从函数到蓝图，从蓝图到生命
2.1 为什么需要面向对象？
你之前写的代码，都是“先做A，再做B，再做C”的过程式代码。函数多了之后，你会发现：
数据到处乱飞，不知道哪个函数改了哪个变量
想复用一段逻辑，复制粘贴改来改去
需求一变，改一个地方要牵连十几个函数
面向对象编程（OOP）把世界拆解成“对象”。每个对象有自己的属性（数据）和方法（行为）。对象之间通过消息通信，各司其职。
📌 打个比方：面向对象不是“做菜流程”，而是“一个厨房”。厨房里有厨师、烤箱、冰箱、刀具。每个东西都有自己的属性和功能，你只需要说“做一顿饭”，它们自己协作完成。
2.2 类与对象：蓝图与实体的关系
| 概念 | 比喻 | 代码层面 |
|---|---|---|
| 类（Class） | 建筑图纸 | class Student: |
| 对象（Object） | 根据图纸盖出来的楼 | s1 = Student() |
| 属性（Attribute） | 楼的高度、颜色 | s1.name = "小明" |
| 方法（Method） | 楼能干什么（开灯、关门） | s1.study() |
类是抽象的模板，对象是具体的实体。一份图纸可以盖一万栋楼，一个类可以创建无数个对象。
2.3 类的定义与实例化
python
class Student: """学生类 —— 所有学生的蓝图""" pass # 实例化：根据蓝图创造具体的学生 s1 = Student() s2 = Student() print(s1) # <__main__.Student object at 0x...> print(s2) # <__main__.Student object at 0x...>
2.4__init__初始化方法 —— 对象诞生的第一声啼哭
__init__是 Python 里的构造方法，在对象被创建时自动调用，用来给对象设置初始属性。
python
class Student: def __init__(self, name, age, score): """初始化方法：对象诞生时自动执行""" self.name = name # 属性：姓名 self.age = age # 属性：年龄 self.score = score # 属性：分数 # 创建对象时，传入的参数会自动交给 __init__ s1 = Student("王小明", 18, 95) s2 = Student("李小红", 19, 88) print(s1.name) # 王小明 print(s2.name) # 李小红self是什么？
self代表当前对象本身。调用s1.study()时，self就是s1；调用s2.study()时，self就是s2。
text
s1 = Student("王小明", 18) ↓ __init__(self, name, age) ↓ self = s1 self.name = "王小明" self.age = 182.5 完整示例：一个活的学生类
python
class Student: """学生类 —— 包含属性、方法、内部逻辑""" def __init__(self, name, age, score): self.name = name self.age = age self.score = score self.is_active = True # 默认属性 def study(self, hours): """学习方法：传入学习时长""" self.score += hours * 0.5 print(f"{self.name} 学习了 {hours} 小时，分数提升到 {self.score:.1f}") def info(self): """打印学生信息""" status = "在读" if self.is_active else "已毕业" print(f"姓名：{self.name}，年龄：{self.age}，成绩：{self.score}，状态：{status}") # 使用 s1 = Student("王小明", 18, 80) s2 = Student("李小红", 19, 75) s1.study(5) # 王小明 学习了 5 小时，分数提升到 82.5 s1.info() # 姓名：王小明，年龄：18，成绩：82.5，状态：在读2.6 类的属性与实例的属性
python
class School: # 类属性：属于类本身，所有实例共享 school_name = "Python 中学" total_students = 0 def __init__(self, name): # 实例属性：属于每个对象自己 self.name = name School.total_students += 1 print(School.school_name) # Python 中学（类属性，不依赖实例） s1 = School("王小明") s2 = School("李小红") print(s1.name) # 王小明（实例属性，每个对象不同） print(School.total_students) # 2（类属性，记录了总人数）🎯 今日核心知识速查
异步模块
| 概念 | 写法 | 作用 |
|---|---|---|
| 异步函数 | async def func(): | 定义异步函数 |
| 等待操作 | await asyncio.sleep(1) | 非阻塞等待 |
| 创建任务 | asyncio.create_task() | 包装为并发任务 |
| 启动入口 | asyncio.run(main()) | 运行异步程序 |
面向对象模块
| 概念 | 写法 | 作用 |
|---|---|---|
| 定义类 | class Student: | 创建蓝图 |
| 构造方法 | def __init__(self): | 初始化对象 |
| 实例属性 | self.name = name | 每个对象独有的数据 |
| 类属性 | class_var = 10 | 所有实例共享 |
| 实例方法 | def study(self): | 对象的行为 |
| 实例化 | s = Student() | 根据蓝图创建对象 |
self | 方法第一个参数 | 指向当前对象 |
终章：你站在了哪里
今天，你完成了两次跃迁。
异步让你摆脱了“等待”的束缚，程序不再是单线程苦力，而是能同时盯着多个任务的总管。
面向对象让你摆脱了“散装函数”的束缚，代码不再是堆积木，而是搭建系统。你开始设计蓝图、创造对象、让它们各司其职、互相协作。
如果你能理解并运用今天的内容，你就已经从一个“写脚本的人”，变成了一个“设计系统的人”。这是程序员成长路上最重要的一道分水岭。
你手里的，不再是砖块，是蓝图。你面前的，不再是页面，是架构。
架构师，你好。下期见。👋🐍