Python Academy · 课时

方法重写与 super()

Q: 「方法重写与 super()」这节课中我会学到什么？

重写父类方法，并使用 super() 调用它们。 你通过在浏览器中直接运行的动手代码来练习 Python Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

重写父类方法，并使用 super() 调用它们。

方法重写与 super() 是 CoddyKit 上的免费 Python Academy 课时。这是第 2 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Python Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Python Academy 课程共包含 4 节课。

简介

方法覆盖让子类能够自定义继承的行为。super() 让您能够调用原始实现。

覆盖基础

在子类中定义同名方法，可以为子类的所有实例替换父类版本。

class Greeter:
    def greet(self): return 'Hello'
class FormalGreeter(Greeter):
    def greet(self): return 'Good day'
print(FormalGreeter().greet())

覆盖中的 super()

子类中的 super().greet() 会调用父类版本。它适合扩展行为，而不是完全替换行为。

class Logger:
    def log(self, msg): print(f'[LOG] {msg}')
class TimedLogger(Logger):
    def log(self, msg):
        import time
        super().log(f'{time.time():.0f}: {msg}')
TimedLogger().log('test')

init 中的 super()

请始终在子类的 __init__ 中调用 super().__init__()，以确保执行父类的初始化。

class Animal:
    def __init__(self, name): self.name = name
class Cat(Animal):
    def __init__(self, name, indoor):
        super().__init__(name)
        self.indoor = indoor
cat = Cat('Whiskers', True)
print(cat.name, cat.indoor)

带参数使用 super()

super(ChildClass, self) 是显式形式（Python 2 风格）。在大多数情况下，Python 3 允许不带参数使用 super()。

class A:
    def greet(self): return 'A'
class B(A):
    def greet(self): return super().greet() + 'B'
class C(B):
    def greet(self): return super().greet() + 'C'
print(C().greet())

协作式继承

在多重继承中，super() 会遵循 MRO。每个类都调用 super()，可以确保继承链中的所有类都完成初始化。

class A:
    def __init__(self): print('A init')
class B(A):
    def __init__(self): super().__init__(); print('B init')
class C(A):
    def __init__(self): super().__init__(); print('C init')
class D(B, C):
    def __init__(self): super().__init__(); print('D init')
D()

覆盖 str

在子类中覆盖 __str__，可以自定义实例的打印方式。

class Animal:
    def __init__(self, name): self.name = name
    def __str__(self): return f'Animal: {self.name}'
class Dog(Animal):
    def __str__(self): return f'Dog: {self.name}'
print(Dog('Rex'))

模板方法模式

父类定义算法骨架；子类通过覆盖特定方法来补充各个步骤。

class DataProcessor:
    def process(self):
        data = self.load()
        return self.transform(data)
    def load(self): return [1,2,3]
    def transform(self, d): return d
class Doubler(DataProcessor):
    def transform(self, d): return [x*2 for x in d]
print(Doubler().process())

调用兄弟类方法

借助 super() 和正确的 MRO，您可以在多重继承中调用兄弟类的方法，这就是协作式 super()。

class A:
    def hello(self): print('A')
class B(A):
    def hello(self): super().hello(); print('B')
class C(A):
    def hello(self): super().hello(); print('C')
class D(B,C):
    def hello(self): super().hello(); print('D')
D().hello()

__init_subclass__

每当某个类被继承为子类时，都会调用 __init_subclass__。它适用于插件注册模式。

class Plugin:
    registry = []
    def __init_subclass__(cls, **kw):
        super().__init_subclass__(**kw)
        Plugin.registry.append(cls)
class A(Plugin): pass
class B(Plugin): pass
print([c.__name__ for c in Plugin.registry])

何时不应覆盖

如果不需要改变行为，就不要覆盖。多余的覆盖会增加维护负担。对于无关行为，请优先使用组合。

# Good: only override what's needed
class Dog(Animal):
    def speak(self): return 'Woof'
    # No need to override __init__ if parent's is fine
print('override guidance')

快速检查

在 Python 3 中，方法内部不带参数的 super() 指向什么？

回顾

在子类中重新定义方法即可实现覆盖。super().method() 会调用父类版本。super().__init__() 会初始化父类。协作式 super() 会遵循 MRO 顺序。

继续学习

进步很棒！请继续学习，掌握下一个概念。

常见问题解答