在 Python 中，继承是一种面向对象编程（OOP）的机制，它允许创建一个新的类（称为子类或派生类），这个子类可以继承一个或多个现有类（称为父类或基类）的属性和方法。通过继承，子类可以复用父类的代码，并且可以在父类的基础上进行扩展或修改。

—— 父类 ——

例如，我们有一个Animal类作为父类，它具有一些通用的属性（如name）和方法（如eat）。然后我们可以创建Dog类作为Animal类的子类，Dog类会自动继承Animal类的name属性和eat方法，同时还可以添加自己特有的属性（如breed）和方法（如bark）。

—— 继承语法 ——

在 Python 中，继承通过在子类定义时括号内指定父类来实现。例如 class 子类名 (父类名): ，子类就可继承父类属性与方法。可在子类中用 super (). 父类方法名 () 调用父类方法，也能直接重写父类方法以实现个性化功能拓展，这就是 Python 继承的基本语法操作。

class ParentClass:
    def __init__(self, name):
        self.name = name
    def method(self):
        print("This is a method of ParentClass")

class ChildClass(ParentClass):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age
    def child_method(self):
        print("This is a method of ChildClass")

# 创建ParentClass的实例
parent = ParentClass("Parent Instance")
parent.method()

# 创建ChildClass的实例
child = ChildClass("Child Instance", 10)
child.method()  # 可以调用从父类继承来的方法
child.child_method()  # 调用子类自己特有的方法
print(child.name)  # 访问从父类继承来的属性
print(child.age)  # 访问子类自己新增的属性

This is a method of ParentClass
This is a method of ParentClass
This is a method of ChildClass
Child Instance
10

定义了两个类，一个是父类ParentClass，另一个是继承自ParentClass的子类ChildClass。ParentClass有一个构造方法__init__用于初始化实例属性name，还有一个普通实例方法method，该方法用于打印表明它属于ParentClass的相关信息。ChildClass在继承ParentClass的基础上，扩展了自己的构造方法__init__，通过调用super().__init__(name)来复用父类的构造方法初始化从父类继承来的name属性，同时新增了自己的实例属性age，并且定义了一个属于自己的实例方法child_method，用于打印表明它属于ChildClass的相关信息。

首先创建了ParentClass的实例parent，并调用了它的method方法，会输出 "This is a method of ParentClass"。接着创建了ChildClass的实例child，可以调用从父类继承的method方法，也能调用自己特有的child_method方法。同时还展示了访问从父类继承的name属性以及子类自己新增的age属性的操作。

—— 单继承 ——

一个子类继承一个父类，子类自动拥有父类的非私有属性和方法。

class Animal:
    def __init__(self, name):
        self.name = name
    def eat(self):
        print(f"{self.name} is eating.")

class Dog(Animal):
    def bark(self):
        print(f"{self.name} is barking.")

my_dog = Dog("Buddy")
my_dog.eat()  # 调用从Animal类继承的eat方法
my_dog.bark() # 调用Dog类自身的bark方法

Buddy is eating.
Buddy is barking.

Dog类继承了Animal类。Dog类的对象my_dog可以调用Animal类中的eat方法，也可以调用自己类中的bark方法。

—— 多层继承 ——

一个子类继承自一个父类，而这个父类又继承自另一个更上层的父类，形成继承链。

class Organism:
    def __init__(self, life_status):
        self.life_status = life_status
    def is_alive(self):
        return self.life_status

class Animal(Organism):
    def __init__(self, life_status, name):
        super().__init__(life_status)
        self.name = name
    def eat(self):
        print(f"{self.name} is eating.")

class Dog(Animal):
    def bark(self):
        print(f"{self.name} is barking.")

my_dog = Dog(True, "Max")
print(my_dog.is_alive())  # 调用从Organism类继承的is_alive方法
my_dog.eat()              # 调用从Animal类继承的eat方法
my_dog.bark()             # 调用Dog类自身的bark方法

True
Max is eating.
Max is barking.

—— super()函数 ——

__init__方法

在子类的构造函数__init__中，使用super()函数来调用父类的__init__方法，以便正确地初始化从父类继承的属性。

class Parent:
    def __init__(self, parent_attr):
        self.parent_attr = parent_attr

class Child(Parent):
    def __init__(self, parent_attr, child_attr):
        super().__init__(parent_attr)
        self.child_attr = child_attr
    def display(self):
        print(f"Parent attribute: {self.parent_attr}, Child attribute: {self.child_attr}")

obj = Child("parent_value", "child_value")
obj.display()

Parent attribute: parent_value, Child attribute: child_value

在Child类的__init__方法中，super().__init__(parent_attr)这一行先初始化了从Parent类继承的parent_attr属性，然后再初始化自己的child_attr属性。

普通方法

在子类的普通方法中使用super()函数来调用父类的同名方法，并且可以在调用父类方法的基础上添加额外的功能。

class Shape:
    def area(self):
        print("Calculating area of a generic shape.")

class Rectangle(Shape):
    def area(self):
        super().area()
        print("For a rectangle, area = length * width.")

rect = Rectangle()
rect.area()

Calculating area of a generic shape.
For a rectangle, area = length * width.

这里Rectangle类重写了Shape类中的area方法。在Rectangle类的area方法中，首先通过super().area()调用了父类Shape类的area方法，然后添加了关于矩形面积计算方式的额外说明。

—— 方法重写（覆盖） ——

子类重新定义一个与父类中同名的方法，当调用该方法时，会执行子类中定义的版本，从而改变了从父类继承的行为。

class Vehicle:
    def move(self):
        print("Vehicle is moving.")

class Car(Vehicle):
    def move(self):
        print("Car is driving.")

my_car = Car()
my_car.move()  # 调用Car类中重写后的move方法，输出 "Car is driving."

Car is driving.

当Car类重写了Vehicle类的move方法后，Car类的对象在调用move方法时，执行的是Car类中定义的move方法，而不是Vehicle类中的move方法。

—— 多继承 ——

一个子类可以继承多个父类，它会继承所有父类的非私有属性和方法。但可能会出现方法名冲突和复杂的方法解析顺序（MRO）问题。

class Flyer:
    def fly(self):
        print("It can fly.")

class Swimmer:
    def swim(self):
        print("It can swim.")

class Duck(Flyer, Swimmer):
    def quack(self):
        print("Duck is quacking.")

my_duck = Duck()
my_duck.fly()
my_duck.swim()
my_duck.quack()

It can fly.
It can swim.
Duck is quacking.

Duck类继承了Flyer类和Swimmer类，它可以调用Flyer类中的fly方法、Swimmer类中的swim方法以及自己类中的quack方法。

—— 方法解析顺序（MRO）——

上面代码加入print(Duck.__mro__)，就可打印出继承的顺序。

It can fly.
It can swim.
Duck is quacking.
(<class '__main__.Duck'>, <class '__main__.Flyer'>, <class '__main__.Swimmer'>, <class 'object'>)

—— 私有属性 ——

在 Python 中，通过在属性名前添加双下划线__来定义私有属性，私有属性在类的外部不能直接访问，一定程度上起到了隐藏内部数据的作用。

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

    def get_name(self):
        return self.__name

    def get_age(self):
        return self.__age

    def set_name(self, new_name):
        self.__name = new_name

    def set_age(self, new_age):
        if new_age > 0:
            self.__age = new_age
# 创建Person类的实例
person = Person("Alice", 25)

# 通过访问器方法获取私有属性的值
print(person.get_name())  
print(person.get_age())  

# 通过修改器方法修改私有属性的值
person.set_name("Bob")
person.set_age(30)

print(person.get_name())  
print(person.get_age())  

Alice
25
Bob
30

构造方法（__init__）：在创建类的实例时自动调用，用于初始化对象的属性，就像上面Person类中的__init__方法，用来初始化__name和__age这两个私有属性。

访问器方法（getter）：用于获取私有属性的值，比如get_name和get_age方法，外部可以通过调用这些方法来间接获取私有属性的内容。

修改器方法（setter）：用于修改私有属性的值，像set_name和set_age方法，不过在set_age方法中还可以添加一些逻辑判断（这里判断年龄要大于 0）来保证数据的合理性。

执行代码部分，首先创建了Person类的实例person，在创建时通过构造方法传入了初始的姓名和年龄。然后使用访问器方法get_name和get_age获取并打印了私有属性对应的姓名和年龄。接着使用修改器方法set_name和set_age修改了私有属性的值，之后再次通过访问器方法获取并打印修改后的值，可以看到私有属性的值按照预期被正确修改和获取了，而在整个过程中，外部始终不能直接访问到类中的私有属性，保证了数据的封装性和一定程度的安全性。

—— 作者小语 ——

Python 继承的世界丰富多彩，单继承、多层继承、super 函数的巧妙运用、方法重写的独特魅力以及多继承的多元拓展，都为编程之路点亮了明灯。掌握这些知识，如同手握魔法棒，能让代码更加灵动高效。朋友们，别犹豫，投身到 Python 继承的学习中，挖掘更多编程宝藏，开启精彩无限的代码创造之旅，一起在知识的海洋破浪前行！