跳到主要内容

Python super() 函数

super() 内置函数返回一个代理对象（超类的临时对象），允许我们访问基类的方法。

示例​

class Animal(object):
    def __init__(self, animal_type):
        print('Animal Type:', animal_type)

class Mammal(Animal):
    def __init__(self):

        # 调用超类
        super().__init__('Mammal')
        print('Mammals give birth directly')

dog = Mammal()

# 输出：Animal Type: Mammal
# Mammals give birth directly

super() 的使用​

在 Python 中，super() 有两个主要用途：

  • 允许我们避免显式使用基类名称
  • 用于多重继承

示例 1：单继承中的 super()​

在单继承的情况下，我们使用 super() 来指代基类。

class Mammal(object):
    def __init__(self, mammalName):
        print(mammalName, 'is a warm-blooded animal.')

class Dog(Mammal):
    def __init__(self):
        print('Dog has four legs.')
        super().__init__('Dog')

d1 = Dog()

输出

Dog has four legs.
Dog is a warm-blooded animal.

这里，我们使用代码

super().__init__('Dog')

而不是

Mammal.__init__(self, 'Dog')

调用了 Mammal 类（在 Dog 类中）的 __init__() 方法。

由于我们在调用其成员时不需要指定基类的名称，我们可以轻松更改基类名称（如果需要的话）。

# 将基类更改为 CanidaeFamily
class Dog(CanidaeFamily):
    def __init__(self):
        print('Dog has four legs.')

        # 无需更改此处
        super().__init__('Dog')
````super()` 内置函数返回一个代理对象，一个可以通过委托调用基类方法的替代对象。这被称为间接引用（通过 `super()` 引用基对象的能力）。

由于间接引用是在运行时计算的，我们可以在不同的时间使用不同的基类（如果需要的话）。

## 示例 2：多重继承中的 super()

```python
class Animal:
    def __init__(self, Animal):
        print(Animal, '是一种动物。')

class Mammal(Animal):
    def __init__(self, mammalName):
        print(mammalName, '是温血动物。')
        super().__init__(mammalName)

class NonWingedMammal(Mammal):
    def __init__(self, NonWingedMammal):
        print(NonWingedMammal, "不能飞。")
        super().__init__(NonWingedMammal)

class NonMarineMammal(Mammal):
    def __init__(self, NonMarineMammal):
        print(NonMarineMammal, "不能游泳。")
        super().__init__(NonMarineMammal)

class Dog(NonMarineMammal, NonWingedMammal):
    def __init__(self):
        print('狗有 4 条腿。')
        super().__init__('狗')

d = Dog()
print('')
bat = NonMarineMammal('蝙蝠')

输出

狗有 4 条腿。
狗不能游泳。
狗不能飞。
狗是温血动物。
狗是一种动物。

蝙蝠不能游泳。
蝙蝠是温血动物。
蝙蝠是一种动物。

方法解析顺序（MRO）​

方法解析顺序（MRO）是在存在多重继承时方法应该被继承的顺序。你可以通过使用 __mro__ 属性来查看 MRO。

>>> Dog.__mro__
(<class 'Dog'>,
<class 'NonMarineMammal'>,
<class 'NonWingedMammal'>,
<class 'Mammal'>,
<class 'Animal'>,
<class 'object'>)

MRO 的工作原理如下：

  • 派生类中的方法总是在基类的方法之前被调用。 在我们的例子中，Dog 类在 NonMarineMammal 或 NoneWingedMammal 之前被调用。这两个类在 Mammal 之前被调用，Mammal 在 Animal 之前被调用，而 Animal 类在 object 之前被调用。
  • 如果有多个父类，如 Dog(NonMarineMammal, NonWingedMammal)，则首先调用 NonMarineMammal 的方法，因为它首先出现。

要了解更多关于 super() 的信息，请访问 Python 的 super() 被认为非常棒！。

最后于 更新