Python入门12：面向对象的三大特征与高级特性详解

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

一、面向对象有三大特征

三种：封装性、继承性、多态性

1、封装

在Python代码中，封装有两层含义：

① 把现实世界中的主体中的属性和⽅法书写到类的⾥⾯的操作即为封装。

② 封装可以为属性和⽅法添加为私有权限，不能直接被外部访问。

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

在⾯向对象代码中，我们可以把属性和⽅法分为两⼤类：公有（属性、⽅法）、私有（属性、⽅法）

Python：公有（属性、⽅法），私有（属性、⽅法）

公有属性和公有⽅法：⽆论在类的内部还是在类的外部我们都可以对属性和⽅法进⾏操作。

但是有些情况下，我们不希望在类的外部对类内部的属性和⽅法进⾏操作。我们就可以把这个属性或⽅法封装成私有形式。

1.2、私有属性

设置私有属性和私有⽅法的⽅式⾮常简单：在属性名和⽅法名前⾯加上两个下划线 __ 即可。设置私有属性后，不能直接在类的外面访问私有属性，但是如果我们在在类外部访问私有属性，那么我们需要再类的内部定义访问的“接口”（函数），专门实现私有属性的访问。接⼝就是我们通常说的⼀个函数，这个函数可以实现对某些属性的访问（设置与获取）。在Python中，⼀般定义函数名' get_xx '⽤来获取私有属性，定义' set_xx '⽤来修改私有属性值。

class Person:
 def __init__(self, name, age):
  self.__name = name  # 私有属性
  self.__age = age  # 私有属性

 def get_name(self):  # 公共方法，用于访问私有属性
  return self.__name

 def set_name(self, name):  # 公共方法，用于修改私有属性
  self.__name = name

 def get_age(self):
  return self.__age

 def set_age(self, age):
  if age > 0:
   self.__age = age
  else:
   print("年龄不能为负数！")

# 使用
person = Person("张三", 20)
print(person.get_name())  # 访问私有属性
person.set_name("李四")  # 修改私有属性
print(person.get_name())

运行结果：

对私有属性间接的进行访问：

class People:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def tell_info(self):
        print('name:<%s> age:<%s>' % (self.__name, self.__age))

    def set_info(self, name, age):
        if not isinstance(name, str):
            print('名字必须是字符串类型')
            return
        if not isinstance(age, int):
            print('年龄必须是数字类型')
            return
        self.__name = name
        self.__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、什么是继承？

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

继承几个基本概念：

1、继承：⼀个类从另⼀个已有的类获得其成员的相关特性，就叫作继承！

2、派⽣：从⼀个已有的类产⽣⼀个新的类，称为派⽣！

很显然，继承和派⽣其实就是从不同的⽅向来描述的相同的概念⽽已，本质上是⼀样的！

3、⽗类：也叫作基类，就是指已有被继承的类！

4、⼦类：也叫作派⽣类或扩展类

5、扩展：在⼦类中增加⼀些⾃⼰特有的特性，就叫作扩展，没有扩展，继承也就没有意义了！

6、单继承：⼀个类只能继承⾃⼀个其他的类，不能继承多个类，单继承也是⼤多数⾯向对象语⾔的特性！

7、多继承：⼀个类同时继承了多个⽗类，（C++、Python等语⾔都⽀持多继承）

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 = name

    def 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、单继承的传递性

在Python继承中，如A类继承了B类，B类⼜继承了C类。则根据继承的传递性，则A类也会⾃动继承C类中所有属性和⽅法（公共）

class C(object):
    def func(self):
     print('我是C类中的相关⽅法func')

class B(C):
    pass

class A(B):
    pass

a = 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__)

运行结果：

说明：有MRO⽅法解析顺序可知，在类的继承中，当某个类创建了⼀个对象时，调⽤属性或⽅法，⾸先在⾃身类中去寻找，如找到，则直接使⽤，停⽌后续的查找。如果未找到，继续向上⼀级继承的类中去寻找，如找到，则直接使⽤，没有找到则继续向上寻找...直到object类，这就是Python类继承中，其⽅法解析顺序。

3、多态

3.1、什么是多态？

多态指的是⼀类事物有多种形态。

定义：多态是⼀种使⽤对象的⽅式，⼦类重写⽗类⽅法，调⽤不同⼦类对象的相同⽗类⽅法，可以产⽣不同的执⾏结果。

① 多态依赖继承（不是必须的）

② ⼦类⽅法必须要重写⽗类⽅法。

好处：调⽤灵活，有了多态，更容易编写出通⽤的代码，做出通⽤的编程，以适应需求的不断变化！

3.2多态原理图

3.3、多态代码的实现

# ⽗类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())

运行结果：

3.4、在Python中还有哪些多态的案例呢？

# 数值相加
print(1 + 2)  # 输出：3

# 字符串拼接
print("Hello" + " World")  # 输出：Hello World

# 列表合并
print([1, 2] + [3, 4])  # 输出：[1, 2, 3, 4]

二、面向对象的其他高级特性

1、类属性

类属性是属于类本身的属性，而不是类的实例。类属性被该类的所有实例对象所共享。

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}个实例对象')

运行结果：

2、类方法

为什么需要类⽅法，在⾯向对象中，特别强调数据封装性。所以不建议直接在类的外部对 类属性 进⾏直接获取。所以我们如果想操作类属性，建议使⽤类⽅法。

class Tool(object):
    # 定义⼀个类属性count
    count = 0

    # 定义⼀个__init__初始化⽅法
    def __init__(self, name):
        self.name = name
        Tool.count += 1

    # 封装⼀个类⽅法：专⻔实现对Tool.count类属性进⾏操作
    @classmethod  # 声明为类⽅法，⽤于对类属性进⾏操作
    def get_count(cls):  # cls代表类对象
        print(f'我们使⽤Tool类共实例化了{cls.count}个⼯具')

t1 = Tool('斧头')
t2 = Tool('榔头')
t3 = Tool('铁锹')

Tool.get_count()

运行结果：

3、静态方法

静态方法既不操作实例属性，也不操作类属性。它通常用于实现与类相关的工具函数。

class Game:
    @staticmethod
    def menu():
        print("1. 开始游戏")
        print("2. 游戏暂停")
        print("3. 退出游戏")

# 调用静态方法
Game.menu()

三、总结

面向对象编程的三大特征——封装、继承和多态，是Python编程中非常重要的概念。通过封装，我们可以隐藏对象的内部实现细节；通过继承，我们可以复用和扩展代码；通过多态，我们可以编写更加通用和灵活的代码。此外，Python还提供了类属性、类方法和静态方法等高级特性，进一步增强了面向对象编程的功能性。

希望本文能帮助你更好地理解Python面向对象编程的核心概念，并在实际开发中灵活运用这些特性！