Python面向对象：把世界装进类

可视化演示

演示Python面向对象编程的四大核心概念：类与实例、封装与属性、继承与多态、特殊方法，通过交互式可视化展示对象之间的关系和代码组织方式。

类与实例：菜谱与佳肴

餐馆灶台上摞着一本菜谱，第一页写着宫保鸡丁：鸡丁半斤、花生二两、干辣椒段，滑油、爆香、翻炒出锅。菜谱本身不能吃，可老主厨每天照它做三十盘。每一盘都独立放在自己的盘子里，有自己的温度和辣度，谁也不会和谁混在一起。

写脚本的日子里，你像个随手炒饭的路边摊：一把锅、一堆料、一股脑倒进去，反正只做一顿。可 AI 项目不是一顿饭——训练、验证、调参、部署，一个模型要反复用上几十次。这时你就需要把“做法”和“成品”分开：做法沉淀成类（class），成品叫对象（object，也叫实例）。类回答“这类东西有什么属性和行为”，对象回答“这一份具体的数据是什么”。

定义类用 class 关键字。类里通常写一个 __init__ 构造方法，它负责“出锅时自动备料”：把传入参数存到 self 绑定的属性上。之后用 Dish('宫保鸡丁', 3) 就像把菜谱交给厨师，Python 会创建并返回一个全新的对象。每调用一次，就得到一份独立的实例，它们各自持有数据，互不干扰。

一句话总结本节：类是图纸，对象是照图纸盖出来的房子。菜谱可以无限复用，做出来的菜却是一盘盘独立的存在。学会区分这两者，你就迈进了面向对象的大门。

属性与方法：食材与手艺

翻开任何一本菜谱，信息总是两类：要备哪些料，要走哪些步骤。“备料”对应属性——一道菜叫什么、辣不辣、多少钱；“步骤”对应方法——这道菜能上桌、能回锅、能改辣度。属性回答“它是什么”，方法回答“它能做什么”。

属性还能分红白两本账：实例属性挂在每个对象自己身上，像每盘菜各自的辣度；类属性挂在类上，像所有川菜共享的“招牌辣味指数”，所有实例都能读到同一份。方法则按着装分三种：最常见的是实例方法，第一个参数写 self，干活时用自己那份数据；加 @classmethod 的类方法，第一个参数收 cls，处理与整个类相关的统计；加 @staticmethod 的静态方法，连 self 都不要，是后厨公用的一把剪刀。

self 是理解实例方法的钥匙。dish.serve() 写起来像“这盘菜自己报菜名”，实际上 Python 在背后把它改写成 Dish.serve(dish)——self 不过是“自己”这个实参的座位。它不需要你手动传，但定义时必须写在第一个参数位。

备料、炒制、公用工具各归其位，后厨才不会乱。把数据和操作捆进同一个类，让对象“自带说明书”，这是封装（encapsulation）思想的雏形，下一节我们就关上后厨的门。

封装与属性：后厨的秘密

老主厨最得意的是一坛“哑巴辣椒油”，配方锁在后厨最里面的柜子里，外人只看见成品、尝到味道，绝不进柜子翻配方。想调整辣度？找前台备注就行。这份“藏起细节、只留安全入口”的自觉，就是封装。封装让内部怎么改都不影响外部，稳定得像锁起的柜门。

Python 里没有 Java 那种“锁死”的私有关键字，靠命名约定表达“请勿外传”：_x 单下划线是保护属性，相当于“内部文件，非请勿入”，是君子协定；__x 双下划线会触发名称改写（name mangling），Python 把属性悄悄改名为 _类名__x，像把瓶子上标签改写一遍，防止亲人误拿。注意，这只是防呆不防贼，不是加密保险箱。

真正优雅的封装姿势是 @property。给“读辣度”配一个 getter，给“改辣度”配一个 setter，外部代码依然写 dish.spice = 3，但赋值的一瞬间会经过 setter 的质检关卡：辣度超出 0～5 直接抛异常。读写入口被上了轨道，数据访问从此有规有矩。

顾客永远只碰菜单，不碰后厨的坛坛罐罐。@property 就是那份菜单——外面看着是普通文字，里面每道工序都被主厨严格控制。把私密藏好，把门面做漂亮，封装让代码经得起换人、改版、被调用一万次。

继承机制：菜谱的传承

学徒想学“宫保鸡丁”，老主厨说：别从零开始。你把“辣子鸡”的菜谱拿过去，鸡换成鸡腿丁，多加一把花生米，滑油、爆香、翻炒全部照旧。五分钟，一份新菜谱诞生了。这就是继承：站在老菜谱的肩膀上改出新菜谱。

被继承的叫父类（基类），新生成的叫子类。子类自动获得父类的所有属性和方法，代码瞬间少写一大半。子类还能重写（override）父类方法——“上菜”的报菜名换套台词；或者用 super() 先调用父类的原版流程，再追加自己的新步骤。在 AI 工程里，MyModel(nn.Module)、MyDataloader(BaseLoader) 全是这个套路。

Python 还允许一个子类有多个父类，叫多重继承。查找方法时按 MRO（方法解析顺序，由 C3 线性化算法算出）逐层寻找。多继承功能强，但也容易让人迷路：深度继承的排查体验，堪比在五层阁楼里找一把菜刀。经验之谈：组合优于继承——“菜里有花生”（组合）通常比“花生是菜的孙子”（深层继承）清晰得多。

继承传的是菜谱，不是厨房。把公共逻辑沉淀进父类，把变化留给子类，再用 super() 保持血脉通畅；同时记住，层级越浅越香，必要时用组合替代继承，大厨房才不乱。

多态与鸭子：只要会叫就是鸭

餐厅有条不成文的规矩：只要能端上桌的，服务员就敢报给客人。鸡是菜，鱼是菜，嫩豆腐也是菜。客人只关心“上菜”，从不管背后是煎是炒是炖。同一个动作、不同对象各有各的演法，这叫多态（polymorphism）。

Python 的多态实现靠鸭子类型（duck typing）：“如果它走起来像鸭子，叫起来像鸭子，那它就是鸭子。”只要对象身上有 serve() 方法，函数就能放心调用它，不管它是 Dish 本尊、还是隔壁摊子端来的远房亲戚。Python 不在编译期检查户口，只在运行期伸手一摸——摸得到方法就干，摸不到就抛 AttributeError。

这也是 Python 没有方法重载的原因：同名方法只有一个，后写的覆盖先写的。想要“必须是真鸭子”的保证？用 abc 模块的抽象基类（ABC）定义必须实现的方法骨架，子类不实现就实例化失败。这像餐厅规定：凡自封“主菜”的，必须会报菜名。

多态让“新增菜品”不必改动点单系统。你只管面向接口编程：调用方永远说“上菜”，每个对象自己决定怎么上。餐厅越开越大，前厅系统却纹丝不动——这就是多态给大型 AI 项目带来的伸缩自由。

特殊方法：餐厅的服务仪式

高档餐厅的仪式感藏在细节里：菜单印得精致漂亮（print 出来像样）；服务员报出菜名和份量（len 拿得到数字）；客人问“这桌和那桌是不是同一道菜”（== 能比）。这些动作不需要客人专门说“请调用 display 函数”，一切自然而然地发生。Python 里让“自然动作”生效的，是特殊方法，也叫魔术方法或双下划线方法（dunder）。

它们的名字被前后两个下划线包住：__str__、__repr__、__len__、__getitem__、__eq__……你一 print(dish)，Python 自动去调 dish.str()；你一 len(dish)，自动去调 len()；两个对象一"=="，自动去调 eq()。你的类从此接通了 Python 的内置电路。

运算符重载同出一源：+ 走 add，< 走 lt，d[0] 走 getitem。把这些方法写进类，你的对象就好像会读心术，for 循环、print、sorted、dict 键值全都认得它。这就是“把世界装进类之后，世界还照常运转”的秘密——特殊方法是类与 Python 生态之间的通用插座。

仪式感不是花架子。__str__ 让日志可读，__eq__ 让模型对象可比较，__len__ 让数据集对象能数样本数。做 AI 项目时，把打印、比较、长度这些“人味”接口补齐，你的类才算真正接客。

语言差异：中餐大厨与法餐大厨

同样开一家餐厅，Python 大厨和 Java 大厨是两种物种。Python 大厨口袋里揣着草稿：“盐少许、油适量”，凭手感下料，边炒边尝，上菜飞快；Java 大厨白手套、计时器、温度计三件套，每道菜精确到克，每道工序持证上岗，不合格食材在进门那刻就被拒之门外。

落到技术上：语法风格上，Python 用缩进定义代码块，追求“写得快、读得懂”；Java 用花括号和强制类型，追求“查得严、跑得稳”。类型系统上，Python 是动态类型，变量像贴纸，运行时才确定贴的是什么；Java 是静态类型，变量声明即锁定，编译期就报错拦截。

访问控制上，Java 靠 public/protected/private 三个关键字由编译器强制执行私有；Python 靠 _x/__x 命名约定，靠团队自觉。接口上，Java 的 interface 是硬契约——没实现就编译失败；Python 的 ABC 抽象基类是软契约——只是运行时提醒。AI 领域常见分工是：Python 快写原型、快速训练，Java 或 Go 承接需要高稳定性的在线服务，各取所长。

中餐大厨的随性成就了上菜速度，法式厨房的严谨保证了出品稳定。语言没有高低，只有合不合场。你学 Python OOP，不是要跟 Java 比谁锁得严，而是要明白：动态与静态、约定与强制，都是工具，场景说了算。

AI 应用场景

Python 演示

class Dish:    """菜谱: 一份菜的蓝图"""     def __init__(self, name, spice, price):        self.name = name        self._spice = spice          # 保护属性, 请走 property 入口        self.price = price     @property    def spice(self):        """getter: 读辣度时自动调用"""        return self._spice     @spice.setter    def spice(self, level):        """setter: 写辣度时先质检再落库"""        if 0 <= level <= 5:            self._spice = level        else:            raise ValueError("辣度必须是 0 到 5")     def serve(self):        return "{} 上桌, 辣度 {}, 价格 {} 元".format(self.name, self._spice, self.price)     def __str__(self):        return "【{}】辣{}/{}元".format(self.name, self._spice, self.price)     def __eq__(self, other):        return self.name == other.name and self.price == other.price  class SichuanDish(Dish):    """川菜: 继承 Dish, 再加一味麻"""     def __init__(self, name, spice, price, numbing):        super().__init__(name, spice, price)        self.numbing = numbing     def serve(self):        return super().serve() + ", 麻度 {}".format(self.numbing)  def duck_test(thing):    """鸭子类型: 只要有 serve 方法就能上桌"""    return thing.serve()  if __name__ == "__main__":    kungpao = SichuanDish("宫保鸡丁", 3, 28, 4)    mapo = Dish("麻婆豆腐", 5, 22)    print(duck_test(kungpao))    print(duck_test(mapo))    print(len(duck_test(kungpao)) > 0)    print(kungpao == SichuanDish("宫保鸡丁", 3, 28, 4))    kungpao.spice = 4                # 走 setter 入口    print(kungpao)

1. class Dish:定义菜谱模板，所有菜品共享这份蓝图。
2. def __init__(self, name, spice, price):构造方法，出锅时自动备料。
3. self._spice = spice单下划线保护属性，提醒外部别直闯。
4. @property def spice(self):getter，让 dish.spice 看起来像普通属性。
5. @spice.setter def spice(self, level):setter 质检，辣度超范围直接拒绝。
6. class SichuanDish(Dish):继承父类，子类自动拿到全部能力。
7. super().__init__(name, spice, price)先让父类完成初始化，再补川菜自己的麻度。
8. def duck_test(thing): return thing.serve()鸭子类型，不查户口只查手艺。
9. kungpao == SichuanDish("宫保鸡丁", 3, 28, 4)触发 __eq__，按菜名和价格比对。

常见误区

面试题