【Python】面向对象之三大特性
目录
1.封装
1.1私有化
1.2私有属性
1.3私有方法
1.4property
2.继承
2.1单继承
2.2多继承
2.3复用父类方法
2.4方法解析顺序
2.5MRO顺序说明
2.6方法重写
3.多态
1.封装
将变量和函数写入类中的操作即为封装，即类中封装了属性和方法。
通过封装，我们可以将一些细节隐藏起来（私有），只暴露出必要的接口供调用者使用。
1.1私有化
有时为了限制属性和方法只能在类内访问，外部无法访问；或父类中某些属性和方法不希望被子类继承。可以将其私有化。
单下划线：非公开API
大多数Python代码都遵循这样一个约定：有一个前缀下划线的变量或方法应被视为非公开的API，例如_var1。这种约定不具有强制力。
双下划线：名称改写
有两个前缀下划线，并至多一个后缀下划线的标识符，例如__x，会被改写为_类名__x。只有在类内部可以通过__x访问，其他地方无法访问或只能通过_类名__x访问。
1.2私有属性
通过双下划线定义私有属性。
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) # 报错1.3私有方法
通过双下划线定义私有方法。
class Person: # 定义私有方法 def __private_method(self): print("private method") # 定义实例方法，调用私有方法 def do_something(self): self.__private_method() p = Person() p.do_something() # private method p._Person__private_method() # private method p.__private_method() # 报错1.4property
方法转换为属性
可通过@property装饰器将一个方法转换为属性来调用。转换后可直接使用.方法名来使用，而无需使用.方法名() 。
class Person: def __init__(self, name): self.name = name @property def eat(self): print(f"{self.name} is eating...") p = Person("张三") p.eat # 张三 is eating...只读属性
将方法名设置为去掉双下划线的私有属性名，方法中返回私有属性。
class Person: def __init__(self, name): self.__name = name @property def name(self): return self.__name p = Person("张三") print(p.name) # 张三 p.name = "李四" # 报错读写属性
将方法名设置为去掉双下划线的私有属性名，使用属性名.setter装饰。
class Person: def __init__(self, name): self.__name = name @property def name(self): return self.__name @name.setter def name(self, name): self.__name = name p = Person("张三") print(p.name) # 张三 p.name = "李四" print(p.name) # 李四也可以在写方法中设置一些拦截条件来规范私有属性的写入。
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("张三") print(p.name) # 张三 p.name = "李四" # 提示 “不许叫李四” print(p.name) # 张三 p.name = "王五" print(p.name) # 王五注意
@property装饰的方法不要和变量重名，否则可能导致无限递归。
class Person: @property def name(self): return self.name p = Person() p.name # 报错：RecursionError: maximum recursion depth exceeded2.继承
子类（派生类）继承父类（基类）中的属性和方法，实现代码重用。子类可以新增自己特有的方法，也可以重写父类的方法。
子类不能继承父类的私有属性和私有方法，因为存在名称改写，但是可以通过改写后的名称直接访问父类的私有成员，不过，这种做法违背了封装原则，不建议使用。
2.1单继承
语法
class 类名(父类): 类体在类名后括号内指定要继承的父类。
案例
class Person: """人的类""" home = "earth" # 定义类属性 def __init__(self, name): self.name = name # 定义实例属性 def eat(self): print("eating...") class YellowRace(Person): """黄种人""" color = "yellow" # 定义类属性 class WhiteRace(Person): """白种人""" color = "white" # 定义类属性 class BlackRace(Person): """黑种人""" color = "black" # 定义类属性 y1 = YellowRace("张三") print(y1.home) # earth print(y1.color) # yellow print(y1.name) # 张三 y1.eat() # eating... w1 = WhiteRace("李四") print(w1.home) # earth print(w1.color) # white print(w1.name) # 李四 w1.eat() # eating... b1 = BlackRace("王五") print(b1.home) # earth print(b1.color) # black print(b1.name) # 王五 b1.eat() # eating...2.2多继承
调用方法时先在子类中查找，若不存在则从左到右依次查找父类中是否包含方法。
语法
class 类名(父类1, 父类2, ...): 类体案例
class Person: """人的类""" home = "earth" def __init__(self, name): self.name = name def eat(self): print("eating...") class YellowRace(Person): """黄种人""" color = "yellow" def run(self): print("runing...") class Student(Person): """学生""" def __init__(self, name, grade): self.name = name self.grade = grade def study(self): print("studying...") class ChineseStudent(Student, YellowRace): # 继承了Student和YellowRace """中国学生""" country = "中国" y1 = ChineseStudent("张三", "三年级") print(y1.home, y1.color, y1.country, y1.name, y1.grade) y1.eat() y1.run() y1.study()2.3复用父类方法
子类可以在类中使用super().方法名()或父类名.方法名()来调用父类的方法。
super().方法名()
class Person: """人的类""" home = "earth" def __init__(self, name): self.name = name def eat(self): print("eating...") class YellowRace(Person): """黄种人""" color = "yellow" def run(self): print("runing...") class Student(Person): """学生""" def __init__(self, name, grade): self.name = name self.grade = grade def study(self): print("先吃再学") super().eat() # 子类中调用父类的方法 print("studying...") class ChineseStudent(Student, YellowRace): # 继承了Student和YellowRace """中国学生""" country = "中国" y1 = ChineseStudent("张三", "三年级") print(y1.home, y1.color, y1.country, y1.name, y1.grade) y1.study()父类名.方法名()
class Person: """人的类""" home = "earth" def __init__(self, name): self.name = name def eat(self): print("eating...") class YellowRace(Person): """黄种人""" color = "yellow" def run(self): print("runing...") class Student(Person): """学生""" def __init__(self, name, grade): self.name = name self.grade = grade def study(self): print("先吃再学") Person.eat(self) # 子类中调用父类的方法 print("studying...") class ChineseStudent(Student, YellowRace): # 继承了Student和YellowRace """中国学生""" country = "中国" y1 = ChineseStudent("张三", "三年级") print(y1.home, y1.color, y1.country, y1.name, y1.grade)2.4方法解析顺序
方法解析顺序（mro—Method Resolution Order）。可使用类名.__mro__访问类的继承链来查看方法解析顺序。super() 不是简单的 “调用父类”，而是基于方法解析顺序（MRO） 调用 “当前类在 MRO 链中的下一个类”。
super() 的正确用法有两种：
- 无参形式（推荐）：super().__init__() → 自动绑定当前类和实例，找 MRO 链的下一个类。
- 有参形式：super(MRO上的类, 实例对象).__init__() → 显式指定 “从哪个类的下一个位置开始找”。
- 具体使用哪个mro,取决于实例对象所属的类型
class Person: """人的类""" home = "earth" def __init__(self, name): self.name = name def eat(self): print("eating...") class YellowRace(Person): """黄种人""" color = "yellow" def run(self): print("runing...") class Student(Person): """学生""" def __init__(self, name, grade): self.name = name self.grade = grade def study(self): print("先吃再学") Person.eat(self) print("studying...") class ChineseStudent(Student, YellowRace): """中国学生""" country = "中国" y1 = ChineseStudent("张三", "三年级") print( ChineseStudent.__mro__ ) # (<class '__main__.ChineseStudent'>, <class '__main__.Student'>, <class '__main__.YellowRace'>, <class '__main__.Person'>, <class 'object'>)2.5MRO顺序说明
""" class Parent1: def __init__(self, value1): print("Initializing Parent1") self.value1 = value1 class Parent2: def __init__(self, value2): print("Initializing Parent2") self.value2 = value2 class Child(Parent1, Parent2): def __init__(self, value1, value2): print("Initializing Child") # 直接调用 Parent1 的 __init__ 方法 Parent1.__init__(self, value1) # 直接调用 Parent2 的 __init__ 方法 Parent2.__init__(self, value2) child = Child("value from Parent1", "value from Parent2") print(child.value1) print(child.value2) """ """ class Parent1: def __init__(self, value1): print("Initializing Parent1") self.value1 = value1 class Parent2: def __init__(self, value2): print("Initializing Parent2") self.value2 = value2 class Child(Parent1, Parent2): def __init__(self, value1, value2): print("Initializing Child") # 调用 Parent1 的 __init__ 方法 super().__init__(value1) # 调用 Parent2 的 __init__ 方法 Parent1 之后开始查找 MRO 链，调用下一个父类（即 Parent2）的 __init__ 方法，把 value2 传递进去。 # super(Parent1, self).__init__(value2) super().__init__(value2) child = Child("value from Parent1", "value from Parent2") print(child.value1) print(child.value2) """ """ class Parent1: def __init__(self, value1, **kwargs): print("Initializing Parent1") super().__init__(**kwargs) self.value1 = value1 class Parent2: def __init__(self, value2, **kwargs): print("Initializing Parent2") super().__init__(**kwargs) self.value2 = value2 class Child(Parent1, Parent2): def __init__(self, value1, value2): print("Initializing Child") super().__init__(value1=value1, value2=value2) child = Child("value from Parent1", "value from Parent2") print(child.value1) # 输出: value from Parent1 print(child.value2) # 输出: value from Parent2 """ """ class A: def __init__(self, a,b,c): self.a = a self.b = b self.c = c class B: def __init__(self, d,e,f): self.d = d self.e = e self.f = f class C(A,B): def __init__(self, a,b,c,d,e,f): # super().__init__(a,b,c) # A.__init__(self,a,b,c) # B.__init__(self,d,e,f) # super(A,self).__init__(d,e,f) """ # 使用 super()：适用于遵循 MRO 顺序的场景，代码可维护性和扩展性较好，特别是在复杂的多重继承结构中。 # 直接调用父类方法：代码逻辑较为直观，但在多重继承结构发生变化时，可能需要手动调整调用顺序，可维护性较差。 # 直接继承父类的钻石继承问题 class GrandParent: def __init__(self): print("Initializing GrandParent") class Parent1(GrandParent): def __init__(self): super().__init__() # 方式2：父类也用 super() print("Initializing Parent1") class Parent2(GrandParent): def __init__(self): super().__init__() # 方式2：父类也用 super() print("Initializing Parent2") class Child(Parent1, Parent2): def __init__(self): Parent1.__init__(self) Parent2.__init__(self) Child() # 执行 Child()：GrandParent 被初始化2次（错误） # 输出：Initializing GrandParent → Initializing Parent1 → Initializing GrandParent → Initializing Parent2 # 这是直接继承的致命问题：钻石继承时基类会被重复初始化，而 super() 会自动避免这个问题。 # class Child(Parent1, Parent2): # def __init__(self): # # 方式2：仅需调用一次 super()，MRO 自动处理所有父类/祖父类 # super().__init__() # # Child() # 执行 Child()：GrandParent 仅初始化1次（正确） # 输出：Initializing GrandParent → Initializing Parent2 → Initializing Parent12.6方法重写
在子类中定义与父类方法重名的方法，调用时会调用子类中重写的方法。
class Person: home = "earth" def __init__(self, name): self.name = name def eat(self): print("eating...") class Chinese(Person): color = "yellow" # 重写父类方法 def eat(self): print("用筷子吃") y1 = Chinese("张三") y1.eat()注意：子类重写__init__()并调用时，不会执行父类的__init__()方法。如有必要，需在子类__init__()中使用super().__init__()来调用父类的__init__()方法。
class Person: def __init__(self, name): self.name = name class Chinese(Person): def __init__(self, name, area): super().__init__(name) # 调用父类的__init__() self.area = area y1 = Chinese("张三", "北京") print(y1.name, y1.area)3.多态
同一事物在不同场景下呈现不同状态。
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("飞") def go(animal): animal.go() # 将不同的实例传入，执行不同的方法 dog = Dog() fish = Fish() bird = Bird() go(dog) go(fish) go(bird)