python中super多继承顺序

在 Python 中，当一个类继承自多个父类时，会按照特定的顺序进行方法的查找和调用，这个顺序被称为方法解析顺序（Method Resolution Order，简称 MRO）。MRO 的计算方式是通过 C3 算法来实现的，其基本原则是：

1. 子类永远先于父类被检查
2. 多个父类按照它们在括号内从左到右的顺序被检查
3. 如果对下一个类存在两个合法的选择，选择第一个父类

在 Python 2.x 版本中，MRO 的计算方式是采用经典类的深度优先搜索（DFS）算法；在 Python 3.x 版本中，MRO 的计算方式是采用新式类的 C3 算法。因此，如果想要正确地实现多继承，需要遵守 MRO 的规则，否则可能会出现一些难以预料的问题。

相关问题

python多继承super

在Python中，多继承可以通过使用`super()`函数来调用父类的方法。`super()`函数用于调用父类的方法，以便在子类中重写父类的方法时，可以保留父类的功能。

当一个子类继承自多个父类时，可以使用`super()`函数按照特定的顺序调用父类的方法。这种顺序是由子类声明时指定的。

下面是一个简单的示例，演示了如何在多继承中使用`super()`函数：

class Parent1:
    def my_method(self):
        print("Parent1's method")

class Parent2:
    def my_method(self):
        print("Parent2's method")

class Child(Parent1, Parent2):
    def my_method(self):
        super().my_method()  # 调用第一个父类的方法
        # 或者使用以下语法：
        # Parent1.my_method(self)
        super(Parent2, self).my_method()  # 调用第二个父类的方法
        # 或者使用以下语法：
        # Parent2.my_method(self)

child = Child()
child.my_method()

在上述示例中，`Child`类继承了`Parent1`和`Parent2`两个父类。在`Child`类中的`my_method()`方法中，通过使用`super().my_method()`调用了`Parent1`的方法，然后通过`super(Parent2, self).my_method()`调用了`Parent2`的方法。这样，我们就可以在子类中按照需要选择调用父类的方法。

python中super的用法

### 回答1：
`super()`是Python中的一个内置函数，用于调用父类（超类）的方法。其通常用于子类中重写父类方法时，需要在子类中调用父类方法的情况下。`super()`函数的语法如下：

super([type[, object-or-type]])

其中，`type`是类，`object-or-type`是对象或类，如果省略第二个参数，则`super()`返回一个未绑定方法对象，该对象可以在任何实例上调用。如果指定了第二个参数，则返回一个绑定方法对象，该对象只能在指定的实例上调用。

举个例子，假设我们有一个父类`Person`和一个子类`Student`，并且子类中重写了父类的`__init__`方法，但是我们还需要在子类的`__init__`方法中调用父类的`__init__`方法，可以这样使用`super()`函数：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def say_hello(self):
        print("Hello, I'm {} and I'm {} years old.".format(self.name, self.age))

class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)  # 调用父类的__init__方法
        self.grade = grade
    
    def say_hello(self):
        super().say_hello()  # 调用父类的say_hello方法
        print("I'm a student in grade {}.".format(self.grade))

s = Student("Tom", 18, 12)
s.say_hello()

在上述代码中，`super().__init__(name, age)`调用了父类`Person`的`__init__`方法，并且将`name`和`age`参数传递给父类的`__init__`方法进行初始化。`super().say_hello()`调用了父类`Person`的`say_hello`方法，同时在子类中添加了额外的输出。

### 回答2：
在Python中，`super()`是一个内置函数，用于调用父类的方法。它通常用于子类的构造函数中，以便在子类中扩展父类的功能而不覆盖它。

在使用`super()`时，我们需要传入两个参数：子类的类名和子类的对象。例如，如果我们有一个子类`Child`和一个父类`Parent`，我们可以使用`super()`来调用父类的方法。

`super().__init__()`的作用是调用父类`Parent`的构造函数，并将子类对象的引用传递给它，以便初始化父类中的实例变量和方法。这样，我们就可以在子类中添加新的属性和行为，同时保留父类的功能。

例如，假设父类`Parent`有一个实例变量`name`和一个方法`say_hello()`，我们可以在子类`Child`的构造函数中使用`super().__init__()`来调用父类的构造函数，并在子类中添加新的属性和行为，如下所示：

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

    def say_hello(self):
        print("Hello, " + self.name + "!")

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age

    def say_age(self):
        print("I am " + str(self.age) + " years old.")

child = Child("Alice", 10)
child.say_hello()  # 输出: "Hello, Alice!"
child.say_age()  # 输出: "I am 10 years old."

在上面的示例中，`Child`子类调用`super().__init__(name)`以调用父类`Parent`的构造函数，并将`name`参数传递给它。然后，子类`Child`可以添加自己的实例变量`age`和方法`say_age()`。

总而言之，`super()`函数在Python中用于调用父类的方法，使子类能够扩展父类的功能而不覆盖它。

### 回答3：
在Python中，super是一个内置函数，用于调用父类的方法。它可以用于两种不同的情况。

首先，当我们在子类中重写一个方法时，如果我们希望在子类中使用父类的方法的实现，我们可以使用super()来调用父类的方法。我们可以通过super()函数来获取父类对象，并在其上调用方法。例如，如果我们有一个父类A和一个子类B，子类B重写了父类A的方法foo，我们可以使用super().foo()来调用父类A的foo方法。这样，我们可以继承并使用父类的实现，同时还可以在子类中添加新的功能。

另外，我们还可以使用super()来在多重继承的情况下调用父类的方法。在多重继承中，一个子类可以有多个父类，我们可以使用super()函数来按照特定的顺序调用各个父类的方法。这种方式确保了方法调用的顺序是按照方法解析顺序（MRO）来进行的，这个顺序是根据C3线性化算法来计算得到的。

总结来说，super()函数在Python中的用法就是用来调用父类的方法。它可以在重写方法时使用，以及在多重继承中按照特定顺序调用各个父类的方法。这样我们能够在子类中继承和扩展父类的功能，使代码更加灵活和可维护。