python中如何继承不同的父类

在Python中继承不同的父类时，可以通过单继承、多继承、使用super()函数、抽象基类等方式来实现。单继承是指一个类继承一个父类，多继承是指一个类可以继承多个父类。具体使用哪种方式取决于实际需求。下面我们详细介绍如何在Python中实现不同的继承方式。

一、单继承

在Python中，单继承是指一个类继承自另一个父类。单继承的方式非常简单，我们只需要在定义子类时，在括号中指定父类的名称即可。

class Parent:
    def __init__(self, name):
        self.name = name
    def greet(self):
        print(f"Hello, my name is {self.name}")
class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age
    def display(self):
        print(f"I am {self.age} years old")
使用示例
child = Child("Alice", 10)
child.greet()  # 输出: Hello, my name is Alice
child.display()  # 输出: I am 10 years old

在上面的例子中，Child 类继承自 Parent 类，Child 类可以调用 Parent 类的方法和属性。

二、多继承

多继承是指一个类可以同时继承多个父类。在Python中，可以通过在类定义时，在括号中列出多个父类的名称来实现多继承。

class Father:
    def __init__(self, father_name):
        self.father_name = father_name
    def father_greet(self):
        print(f"Hello, I am {self.father_name}")
class Mother:
    def __init__(self, mother_name):
        self.mother_name = mother_name
    def mother_greet(self):
        print(f"Hello, I am {self.mother_name}")
class Child(Father, Mother):
    def __init__(self, father_name, mother_name, child_name):
        Father.__init__(self, father_name)
        Mother.__init__(self, mother_name)
        self.child_name = child_name
    def child_greet(self):
        print(f"Hello, I am {self.child_name}")
使用示例
child = Child("John", "Jane", "Alice")
child.father_greet()  # 输出: Hello, I am John
child.mother_greet()  # 输出: Hello, I am Jane
child.child_greet()  # 输出: Hello, I am Alice

在上面的例子中，Child 类同时继承了 Father 和 Mother 类，Child 类可以调用这两个父类的方法和属性。

三、使用super()函数

super() 函数在继承中非常重要，它用于调用父类的方法。super() 函数通常在子类的方法中调用，以保证父类的方法能够被正确调用。

class Parent:
    def __init__(self, name):
        self.name = name
    def greet(self):
        print(f"Hello, my name is {self.name}")
class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age
    def display(self):
        print(f"I am {self.age} years old")
使用示例
child = Child("Alice", 10)
child.greet()  # 输出: Hello, my name is Alice
child.display()  # 输出: I am 10 years old

在上面的例子中，super().__init__(name) 调用了 Parent 类的 __init__ 方法，确保 Parent 类的初始化逻辑被正确执行。

四、抽象基类

抽象基类（Abstract Base Class, ABC）是Python中用于定义抽象类的模块。抽象基类不能直接实例化，它通常用于定义接口和子类必须实现的方法。

from abc import ABC, abstractmethod
class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass
class Dog(Animal):
    def sound(self):
        return "Bark"
class Cat(Animal):
    def sound(self):
        return "Meow"
使用示例
dog = Dog()
cat = Cat()
print(dog.sound())  # 输出: Bark
print(cat.sound())  # 输出: Meow

在上面的例子中，Animal 是一个抽象基类，它定义了一个抽象方法 sound。Dog 和 Cat 类继承自 Animal 并实现了 sound 方法。

五、组合与委托

除了继承，组合与委托也是一种常见的代码复用方式。组合是指一个类包含另一个类的实例，而不是继承它。委托是指一个类将某些功能委托给另一个类来实现。

class Engine:
    def start(self):
        print("Engine started")
class Car:
    def __init__(self):
        self.engine = Engine()
    def start(self):
        self.engine.start()
使用示例
car = Car()
car.start()  # 输出: Engine started

在上面的例子中，Car 类包含一个 Engine 类的实例，并将 start 方法委托给 Engine 类来实现。

六、接口继承

接口继承是指一个类实现一个接口或多个接口。在Python中，接口通常通过抽象基类来定义。

from abc import ABC, abstractmethod
class Shape(ABC):
    @abstractmethod
    def draw(self):
        pass
class Circle(Shape):
    def draw(self):
        print("Drawing a circle")
class Square(Shape):
    def draw(self):
        print("Drawing a square")
使用示例
circle = Circle()
square = Square()
circle.draw()  # 输出: Drawing a circle
square.draw()  # 输出: Drawing a square

在上面的例子中，Shape 是一个抽象基类，定义了一个抽象方法 draw。Circle 和 Square 类继承自 Shape 并实现了 draw 方法。

七、继承中的MRO（方法解析顺序）

在多继承中，Python使用C3线性化算法来确定方法的调用顺序，这个顺序称为MRO（Method Resolution Order）。我们可以使用 __mro__ 属性来查看类的MRO。

class A:
    def method(self):
        print("A.method")
class B(A):
    def method(self):
        print("B.method")
class C(A):
    def method(self):
        print("C.method")
class D(B, C):
    pass
使用示例
d = D()
d.method()  # 输出: B.method
print(D.__mro__)  # 输出: (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)