什么是 super() 关键字？
在python的面向对象编程中，super() 是一个内置函数，它提供了一种方式来访问父类或兄弟类的方法。它在处理继承关系，特别是多重继承时显得尤为重要。super() 的主要作用是允许子类在自身的方法中调用父类中被重写的方法，从而实现代码的复用和更灵活的类结构设计。
在Python 3中，super() 的调用方式变得更加简洁，通常无需传入参数，例如 super().__init__() 或 super().method_name()。它会自动识别当前类和实例，并根据方法解析顺序（Method Resolution Order, MRO）查找并调用下一个合适的方法。
super() 的基本用法
super() 最常见的应用场景之一是在子类的 __init__ 方法中调用父类的 __init__ 方法，以确保父类的属性得到正确初始化。
考虑以下简单的继承结构：
class Parent:
def __init__(self, name):
self.name = name
print(f"Parent's __init__ called for {self.name}.")
def greet(self):
print(f"Hello from Parent, I am {self.name}.")
class Child(Parent):
def __init__(self, name, age):
# 调用父类的__init__方法
super().__init__(name)
self.age = age
print(f"Child's __init__ called for {self.name}, age {self.age}.")
def greet(self):
print(f"Hello from Child, I am {self.name} and {self.age} years old.")
# 实例化子类
child_instance = Child("Alice", 10)
child_instance.greet()输出示例：
立即学习“Python免费学习笔记（深入）”；
Parent's __init__ called for Alice. Child's __init__ called for Alice, age 10. Hello from Child, I am Alice and 10 years old.
从上述输出可以看出，当创建 Child 类的实例时，super().__init__(name) 确保了 Parent 类的初始化逻辑先被执行，self.name 属性得以正确设置，然后才执行 Child 类的特有初始化逻辑。
方法重写与 super()：执行顺序解析
super() 在处理方法重写时，其执行顺序是开发者经常感到困惑的地方。当子类重写了父类的方法，并且子类的方法中又调用了 super().method_name() 时，实际的执行顺序取决于 super() 调用在子类方法中的位置。
让我们通过一个具体的例子来演示：
class Animal:
def __init__(self, species="unknown"):
self.species = species
print(f"--- Animal instance of {self.species} created. ---")
def make_sound(self):
print(f"{self.species} makes a generic sound.")
class Dog(Animal):
def __init__(self, name, breed):
print(f"Dog's __init__ started for {name}.")
super().__init__("dog") # 调用父类的__init__
self.name = name
self.breed = breed
print(f"Dog '{self.name}' of breed '{self.breed}' initialized.")
def make_sound(self):
print(f"Dog '{self.name}' says: Bark!") # 子类特有行为
super().make_sound() # 调用父类的make_sound方法
print(f"Dog '{self.name}' finishes barking.") # 子类后续行为
class Cat(Animal):
def __init__(self, name, color):
print(f"Cat's __init__ started for {name}.")
super().__init__("cat") # 调用父类的__init__
self.name = name
self.color = color
print(f"Cat '{self.name}' of color '{self.color}' initialized.")
def make_sound(self):
super().make_sound() # 先调用父类的make_sound方法
print(f"Cat '{self.name}' says: Meow!") # 子类特有行为
print(f"Cat '{self.name}' purrs softly.") # 子类后续行为
# 场景一：Dog 类的行为
print("\n--- Testing Dog ---")
my_dog = Dog("Buddy", "Golden Retriever")
my_dog.make_sound()
# 场景二：Cat 类的行为
print("\n--- Testing Cat ---")
my_cat = Cat("Whiskers", "Tabby")
my_cat.make_sound()输出分析：
对于 Dog 实例 (my_dog)：
--- Testing Dog --- Dog's __init__ started for Buddy. --- Animal instance of dog created. --- Dog 'Buddy' of breed 'Golden Retriever' initialized. Dog 'Buddy' says: Bark! dog makes a generic sound. Dog 'Buddy' finishes barking.
- __init__ 方法的执行顺序： 当 Dog("Buddy", "Golden Retriever") 被调用时，Dog 类的 __init__ 首先开始执行。其中的 super().__init__("dog") 会暂停 Dog 类的 __init__，转而执行 Animal 类的 __init__。Animal 的 __init__ 完成后，控制权返回到 Dog 类的 __init__，继续执行剩余的初始化代码。
- make_sound 方法的执行顺序： 当 my_dog.make_sound() 被调用时，首先执行 Dog 类 make_sound 方法中的第一行 print 语句（"Dog says: Bark!"）。接着，super().make_sound() 被调用，执行 Animal 类的 make_sound 方法（"dog makes a generic sound."）。最后，控制权返回 Dog 类的 make_sound 方法，执行剩余的 print 语句（"Dog finishes barking."）。
对于 Cat 实例 (my_cat)：
--- Testing Cat --- Cat's __init__ started for Whiskers. --- Animal instance of cat created. --- Cat 'Whiskers' of color 'Tabby' initialized. cat makes a generic sound. Cat 'Whiskers' says: Meow! Cat 'Whiskers' purrs softly.
- make_sound 方法的执行顺序： 与 Dog 不同，Cat 类的 make_sound 方法中 super().make_sound() 被放在了开头。这意味着当 my_cat.make_sound() 被调用时，它会立即执行 Animal 类的 make_sound 方法（"cat makes a generic sound."）。之后，才执行 Cat 类 make_sound 方法中特有的 print 语句（"Cat says: Meow!" 和 "Cat purrs softly."）。
总结执行顺序：
- 子类方法中 super() 调用之前的部分 -> 父类方法 -> 子类方法中 super() 调用之后的部分。
- super() 实际上是根据当前类的方法解析顺序（MRO）查找下一个要调用的方法。
方法解析顺序 (MRO)
super() 的行为是基于 Python 的方法解析顺序（MRO）的。MRO 是一个列表，定义了在查找方法或属性时，解释器应该遍历的类继承链的顺序。对于单继承，MRO 相对简单：子类 -> 父类 -> 祖父类，依此类推。对于多重继承，MRO 遵循 C3 线性化算法，确保了一致性和确定性。
你可以通过 ClassName.__mro__ 属性或 help(ClassName) 来查看任何类的 MRO。
print(Dog.__mro__) # 输出: (, , )
这表明当在 Dog 类中调用 super() 时，它会按照这个顺序查找下一个方法，即先看 Animal，然后是 object。
注意事项
- Python 2 vs. Python 3: 在 Python 2 中，super() 需要显式传入当前类和实例，如 super(Child, self).__init__()。但在 Python 3 中，可以直接使用 super().__init__()，语法更加简洁。
- super() 并非总是指父类： 在多重继承的复杂场景中，super() 调用的可能不是直接的父类，而是 MRO 中定义的下一个类。这是 super() 强大之处，也是需要理解 MRO 的原因。
- 统一调用风格： 建议在所有需要扩展父类行为的子类方法中，都使用 super() 来调用父类方法，以保持代码的一致性和可维护性。
总结
super() 关键字是 Python 中实现继承和方法重写机制的关键工具。它允许子类在自身逻辑中灵活地集成父类的行为，避免了重复代码，并使得复杂的继承结构能够以清晰、可预测的方式运作。理解 super() 的工作原理，特别是其与方法解析顺序（MRO）的关系，对于编写健壮和可扩展的 Python 面向对象代码至关重要。通过合理地使用 super()，开发者可以更好地管理类之间的关系，实现高效的代码复用。
