面试官问“Python面向对象”，你还在背概念？一文讲透封装、继承、多态的精髓！
在Python编程的世界里，如果问什么思想能让代码从“能用”蜕变为“好用”，那一定是面向对象编程。
很多初学者在学习了class和def之后，就觉得自己掌握了OOP。但当真正开始写大型项目或者面试时，才发现自己对封装、继承、多态这三大特性的理解还停留在表面。
今天，我们不聊枯燥的定义，直接深入底层，结合代码实战，把这三大特性掰开揉碎了讲给你听。看完这篇文章，你将彻底明白：为什么Python的私有属性是“假私有”？多继承下方法到底是怎么找的？以及@property背后隐藏的优雅设计。
第一章：封装 —— 不仅仅是把数据藏起来
封装，从字面理解就是“装”进去，“封”起来。在Python中，我们把变量（属性）和函数（方法）写入类中，这本身就是封装。
但封装的核心目的，其实是隐藏内部实现的复杂性，只暴露必要的接口给外部。就像我们开车，只需要知道方向盘和油门刹车在哪，不需要懂发动机内部的燃烧原理。
1.1 Python 的“私有”与“君子协议”
和其他语言（如Java）不同，Python没有真正的强制私有机制。它依靠的是程序员的“自觉”和一种叫做名称改写的机制。
1) 单下划线_var：非公开的“君子协议”
在变量或方法前加一个下划线，例如_name。
这其实是一个约定：“嘿，这个属性是内部的，外部最好不要直接访问。”
Python解释器并不会阻止你访问它，但它代表着一种默契。如果你在写库给别人用，用_开头，意味着“请别碰这个，否则后果自负”。
2) 双下划线__var：名称改写
这才是Python中的“私有”实现。当你在属性前加两个下划线，比如__name，Python会在背后偷偷给它改个名字：_类名__name。
实战演示：
python
class Person: def __init__(self, name): self.__name = name # 私有属性 def get_name(self): return self.__name p = Person("张三") # 正常通过内部方法获取 print(p.get_name()) # 张三 # 强行通过“改名”后的方式访问（虽然能访问，但极不推荐） print(p._Person__name) # 张三 # 直接访问会报错 print(p.__name) # AttributeError核心解读：
这就解释了为什么子类无法继承父类的私有属性——因为子类不知道父类把名字改成了_父类名__name，所以根本找不到。
1.2@property—— 让方法变成属性的魔法
很多人在写类的时候，会把所有属性都暴露出来。但这很危险，比如年龄不能是负数，名字不能为空。这时，@property就派上用场了。它既能保持访问的便利性（像属性一样直接调用），又能添加业务逻辑（像方法一样校验）。
1) 只读属性
如果你想让某个属性只读，不允许外部修改，就用@property。
python
class Person: def __init__(self, name): self._name = name @property def name(self): return self._name p = Person("张三") print(p.name) # 张三 p.name = "李四" # 报错：AttributeError: can't set attribute2) 读写属性（带校验）
通过@属性名.setter，我们可以在修改属性时加入拦截逻辑。
python
class Person: def __init__(self, name): self.__name = name @property def name(self): return self.__name @name.setter def name(self, name): if name == "李四": print("不许叫李四，换个名字！") else: self.__name = name p = Person("张三") p.name = "李四" # 输出：不许叫李四，换个名字！ print(p.name) # 张三 p.name = "王五" print(p.name) # 王五避坑指南：
千万不要让@property装饰的方法名和实例变量重名，否则会陷入无限递归。
python
# 错误示范 @property def name(self): return self.name # 这里会一直调用自己，导致递归错误
第二章：继承 —— 站在巨人的肩膀上
继承是代码复用的利器。子类可以拥有父类的所有非私有属性和方法，并且可以定义自己独有的内容。
2.1 单继承与super()
Python 支持多继承，但最常用的还是单继承。在子类中重写__init__时，记得调用父类的__init__。
误区：很多人以为子类有了__init__，就会自动执行父类的__init__。错！子类一旦定义了__init__，就必须显式调用父类的初始化方法。
python
class Person: def __init__(self, name): self.name = name class Chinese(Person): def __init__(self, name, area): # 调用父类方法有两种方式： # 1. super().__init__(name) （推荐，无需写父类名） # 2. Person.__init__(self, name) （经典写法） super().__init__(name) self.area = area c = Chinese("张三", "北京") print(c.name, c.area)2.2 多继承与 MRO —— 解决“从哪来”的问题
Python 支持多继承，但这把双刃剑用不好很容易产生“菱形继承”问题。当一个类继承自多个父类，而父类又有共同祖先时，Python 有一套严谨的查找机制：MRO（Method Resolution Order，方法解析顺序）。
案例：
假设我们有Student和YellowRace都继承自Person，而ChineseStudent同时继承了Student和YellowRace。
python
class ChineseStudent(Student, YellowRace): pass print(ChineseStudent.__mro__) # 输出：(ChineseStudent, Student, YellowRace, Person, object)
解读：
MRO 遵循C3 线性化算法。简单来说，它的查找顺序是：
先找子类自身。
然后找第一个父类（
Student）及其继承链。再找第二个父类（
YellowRace）及其继承链。最后找所有类的共同祖先（
object）。
这也是为什么多继承时，父类的顺序至关重要。
第三章：多态 —— “一个接口，多种形态”
多态是面向对象最难理解但也最灵活的特性。它的核心思想是：同一个行为，不同的对象表现出不同的形态。
在 Python 中，多态的实现非常自然，因为 Python 是鸭子类型语言。只要一个对象会“叫”，我们就能把它当作“鸭子”来用，而不必关心它到底是鸭子还是鸡。
案例：动物运动会
python
class Animal: def go(self): pass class Dog(Animal): def go(self): print("狗在跑") class Fish(Animal): def go(self): print("鱼在游") class Bird(Animal): def go(self): print("鸟在飞") # 定义一个函数，接受任何具有 go 方法的对象 def animal_go(animal): animal.go() dog = Dog() fish = Fish() bird = Bird() animal_go(dog) # 狗在跑 animal_go(fish) # 鱼在游 animal_go(bird) # 鸟在飞深度思考：
注意看animal_go函数，它根本不关心传入的是Dog还是Fish。只要传入的对象里有go()方法，它就能正常运行。这就是多态的威力：它让代码更加抽象和通用，降低耦合度。如果你要增加一个Snake（蛇）类，只需要定义go方法，animal_go函数完全不需要修改。
第四章：进阶实战 —— 方法重写与复用
在子类中，我们经常会需要重写父类的方法来实现特定的逻辑。
4.1 方法重写
子类直接定义一个和父类同名的方法，就会覆盖父类的行为。
python
class Person: def eat(self): print("用手吃") class Chinese(Person): # 重写父类方法 def eat(self): print("用筷子吃") c = Chinese() c.eat() # 用筷子吃4.2 在重写中复用父类逻辑
有时候，我们不想完全推翻父类，而是在父类逻辑的基础上“增加”一些功能。这时候可以用super()。
python
class Student(Person): def study(self): print("先吃再学") super().eat() # 调用父类的 eat 方法 print("开始学习") s = Student() s.study() # 输出： # 先吃再学 # 用手吃 # 开始学习总结
Python 的面向对象三大特性，不仅仅是面试八股文，更是我们写出优雅、健壮、可维护代码的基石。
封装：核心在于隐藏实现细节。记住，Python的私有是“君子协议”（
_）和“名称改写”（__）。利用@property优雅地控制属性的访问权限，比直接暴露属性更安全、更专业。继承：核心在于代码复用。单继承用
super()保持调用链完整；多继承要理解 MRO（方法解析顺序），明确方法的查找路径。多态：核心在于接口统一。利用“鸭子类型”，让代码依赖抽象（如
go方法）而不是具体类，从而实现“开闭原则”——对扩展开放，对修改关闭。
掌握这些特性，你会发现 Python 代码的灵活性和强大之处。好的代码，往往不是写了多少行，而是通过精巧的设计，让每一行代码都物尽其用。
希望这篇文章能帮你打通 Python 面向对象的任督二脉。如果你觉得有收获，欢迎点赞、收藏、转发，让更多 Pythoner 看到！