面向对象编程（OOP）是Python编程中非常重要的一部分，它通过封装、继承和多态这三大特征，帮助我们更好地组织和管理代码。除此之外，Python还提供了一些其他特性，如类属性、类方法和静态方法，进一步增强了面向对象编程的灵活性和功能性。本文将详细介绍这些特性，并通过代码示例帮助你更好地理解。

一、面向对象有三大特征

1、封装

1.1、封装中的私有属性和私有⽅法

1.2、私有属性

class Person:def __init__(self, name, age):self.__name = name  # 私有属性self.__age = age  # 私有属性def get_name(self):  # 公共方法，用于访问私有属性return self.__namedef set_name(self, name):  # 公共方法，用于修改私有属性self.__name = namedef get_age(self):return self.__agedef set_age(self, age):if age > 0:self.__age = ageelse:print("年龄不能为负数！")# 使用
person = Person("张三", 20)
print(person.get_name())  # 访问私有属性
person.set_name("李四")  # 修改私有属性
print(person.get_name())

class People:def __init__(self, name, age):self.__name = nameself.__age = agedef tell_info(self):print('name:<%s> age:<%s>' % (self.__name, self.__age))def set_info(self, name, age):if not isinstance(name, str):print('名字必须是字符串类型')returnif not isinstance(age, int):print('年龄必须是数字类型')returnself.__name = nameself.__age = age# 创建实例并调用方法
p = People('jack', 38)
p.tell_info()  # 输出：name:<jack> age:<38>p.set_info('jennifer', 18)
p.tell_info()  # 输出：name:<jennifer> age:<18>p.set_info(123, 35)  # 输出：名字必须是字符串类型
p.tell_info()  # 输出：name:<jennifer> age:<18>

1.3、私有方法

class ATM:def __card(self):print('插卡')def __auth(self):print('用户认证')def __input(self):print('输入取款金额')def __print_bill(self):print('打印账单')def __take_money(self):print('取款')# 定义一个对外提供服务的公共方法def withdraw(self):self.__card()self.__auth()self.__input()self.__print_bill()self.__take_money()# 创建实例并调用公共方法
atm = ATM()
atm.withdraw()

运行结果：

1.4、封装的意义

• 数据隐藏：通过将属性设置为私有（使用双下划线__），可以防止外部直接访问和修改对象的内部数据。

• 接口暴露：通过提供公共方法（如get_xx和set_xx），可以控制外部对私有属性的访问和修改。

2、继承

2.1、什么是继承？

继承是面向对象编程的另一个重要特征。它允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码的重用和扩展。

继承几个基本概念：

2.2、继承的基本语法

class B(object):pass
class A(B):pass
a = A()
a.B中的所有公共属性
a.B中的所有公共⽅法

2.3、单继承

单继承是指一个子类只能继承一个父类。通过继承，子类可以复用父类的属性和方法，同时还可以扩展自己的属性和方法。

class Animal:def __init__(self, name):self.name = namedef speak(self):print(f"{self.name} 在叫")class Dog(Animal):  # 继承自Animal类def bark(self):print(f"{self.name} 汪汪汪！")# 实例化Dog对象
dog = Dog("旺财")
dog.speak()  # 调用父类方法
dog.bark()  # 调用子类方法

运行结果：

2.4、单继承的传递性

class C(object):def func(self):print('我是C类中的相关⽅法func')class B(C):passclass A(B):passa = A()
a.func()

2.5、多继承

Python支持多继承，即一个子类可以同时继承多个父类。虽然多继承允许我们同时继承⾃多个类，但是实际开发中，应尽量避免使⽤多继承，因为如果两个类中出现了相同的属性和⽅法就会产⽣命名冲突。

class you_car(object):y_name = "油车"def use_you(self):print("我是油车，我使用的是汽油驱动！！！")class dian_car(object):d_name = "电车"def use_dian(self):print("我是电车，我使用的是电力驱动")class hunhe_car(you_car,dian_car):yd_name = "油电混动"def use_hunhe(self):print("我是油电混懂，我既能够使用汽油驱动，又能够使用电力驱动")hh = hunhe_car()
hh.use_hunhe()
hh.use_you()
hh.use_dian()
print(hh.y_name)
print(hh.d_name)
print(hh.yd_name)

运行结果：

2.6、⼦类扩展：重写⽗类属性和⽅法

什么是重写？

如果⼦类中的属性和⽅法与⽗类中的属性或⽅法同名 则⼦类中的属性或⽅法会对⽗类中同名的属性或⽅法进⾏覆盖（重写）

# 重写2：类⽅法的调⽤顺序，当我们在⼦类中重构⽗类的⽅法后，Cat⼦类的实例先会在⾃⼰的类 Cat 中查找该⽅法，
# 当找不到该⽅法时才会去⽗类 Animal 中查找对应的⽅法。
class Animal():def call(self):print("我是动物类中叫方法")class Cat(Animal):# 自定义def cat_call(self):print("我是猫类中喵喵叫的方法")# 重写方法def call(self):print("我是猫类中喵喵叫的方法")
# 父类中的方法功能不够，在子类中的解决方法：
# 1、重写
# 2、定义一个新的方法
c = Cat()
c.call()

运行结果：

2.7、super()调⽤⽗类属性和⽅法

在子类中，可以通过super()函数调用父类的方法，尤其是在重写父类方法时，仍然希望保留父类的行为。在Python3以 后版本中，调⽤⽗类的属性和⽅法我们只需要使⽤ super().属性 或 super().⽅法名() 就可以完 成调⽤了。

class Car:def __init__(self, brand, model):self.brand = brand   # 品牌self.model = model  # 型号def run(self):print(f"{self.brand} {self.model} 在行驶！")class ElectricCar(Car):# 重写构造函数def __init__(self, brand, model, battery):super().__init__(brand, model)  # 调用父类的构造方法self.battery = battery# 重写run方法def run(self):super().run()  # 调用父类的run方法print(f"在以 {self.battery} 千米每小时的速度在行驶")tesla = ElectricCar("Tesla", "Model S", 75)
tesla.run()

运行结果：

2.8.MRO属性或MRO⽅法：⽅法解析顺序

当多个父类中有同名方法时，Python 需要确定调用哪个父类的方法，这就涉及到方法解析顺序（MRO）。Python 使用 C3 线性化算法来计算 MRO。可以使用__mro__属性或mro()方法查看类的 MRO。

class A:def method(self):print("Method from A")class B(A):def method(self):print("Method from B")class C(A):def method(self):print("Method from C")class D(B, C):pass# 查看D类的MRO
print(D.__mro__)# 创建D类的实例
d = D()
# 调用method方法
d.method()

class Parent1:def __init__(self):print("Parent1 __init__")class Parent2:def __init__(self):print("Parent2 __init__")class Child(Parent1, Parent2):def __init__(self):# 调用父类的__init__方法super().__init__()print("Child __init__")# 创建Child类的实例
child = Child()
print(Child.__mro__)

 运行结果：

3、多态

3.1、什么是多态？

# ⽗类Fruit
class Fruit(object):def makejuice(self):print('i can make juice')# ⼦类：苹果
class Apple(Fruit):# 重写⽗类⽅法def makejuice(self):print('i can make apple juice')# ⼦类：⾹蕉
class Banana(Fruit):# 重写⽗类⽅法def makejuice(self):print('i can make banana juice')# ⼦类：橘⼦
class Orange(Fruit):# 重写⽗类⽅法def makejuice(self):print('i can make orange juice')# 定义⼀个公共接⼝（专⻔⽤于实现榨汁操作）
def service(obj):# obj要求是⼀个实例化对象，可以传⼊苹果对象/⾹蕉对象obj.makejuice()# 调⽤公共⽅法
service(Orange())

# 数值相加
print(1 + 2)  # 输出：3# 字符串拼接
print("Hello" + " World")  # 输出：Hello World# 列表合并
print([1, 2] + [3, 4])  # 输出：[1, 2, 3, 4]

class Person(object):# 定义类属性count，⽤于记录⽣成的Person类对象的个数count = 0# 定义⼀个__init__魔术⽅法，⽤于进⾏初始化操作def __init__(self, name):self.name = name# 对count类属性进⾏+1操作，⽤于记录这个Person类⼀共⽣成了多少个对象Person.count += 1# 1、实例化对象p1
p1 = Person('Tom')
p2 = Person('Harry')
p3 = Person('Jennifer')# 2、在类外部输出类属性
print(f'我们共使⽤Person类⽣成了{Person.count}个实例对象')

class Tool(object):# 定义⼀个类属性countcount = 0# 定义⼀个__init__初始化⽅法def __init__(self, name):self.name = nameTool.count += 1# 封装⼀个类⽅法：专⻔实现对Tool.count类属性进⾏操作@classmethod  # 声明为类⽅法，⽤于对类属性进⾏操作def get_count(cls):  # cls代表类对象print(f'我们使⽤Tool类共实例化了{cls.count}个⼯具')t1 = Tool('斧头')
t2 = Tool('榔头')
t3 = Tool('铁锹')Tool.get_count()

class Game:@staticmethoddef menu():print("1. 开始游戏")print("2. 游戏暂停")print("3. 退出游戏")# 调用静态方法
Game.menu()