Python中如何确保子类重写的方法调用了super()？

在Python里，有几种实用的方式可以强制或验证子类重写父类方法时是否调用了super()，下面是最常用的几种方案：

1. 实例状态标记+断言检查 #

这是最简单的实现方式，通过在父类方法中设置状态标记，后续验证标记是否被触发——只有子类调用super()时，父类方法才会执行，标记才会被设置。

示例代码：

class Parent:
    def __init__(self):
        self._init_super_called = True
        # 父类初始化逻辑
        self.parent_attr = "default_parent_value"

    def validate_init_super(self):
        assert getattr(self, "_init_super_called", False), "子类必须调用 super().__init__()"

# 正确的子类实现
class GoodChild(Parent):
    def __init__(self):
        super().__init__()
        self.child_attr = "custom_child_value"

# 错误的子类实现（未调用super）
class BadChild(Parent):
    def __init__(self):
        self.child_attr = "custom_child_value"

# 测试
good_kid = GoodChild()
good_kid.validate_init_super()  # 正常通过

bad_kid = BadChild()
bad_kid.validate_init_super()  # 抛出AssertionError

可以把检查逻辑嵌入父类的核心业务方法中，避免手动调用验证函数。

2. 装饰器跟踪父类方法调用 #

通过装饰器给父类方法打标记，灵活验证指定方法是否被子类通过super()调用。

示例代码：

def track_super_call(func):
    def wrapper(self, *args, **kwargs):
        setattr(self, f"_super_{func.__name__}_called", True)
        return func(self, *args, **kwargs)
    return wrapper

class Parent:
    @track_super_call
    def process_data(self):
        print("父类数据预处理")

    def check_super_for(self, method_name):
        flag = getattr(self, f"_super_{method_name}_called", False)
        assert flag, f"子类必须调用 super().{method_name}()"

class GoodChild(Parent):
    def process_data(self):
        super().process_data()
        print("子类数据加工")

class BadChild(Parent):
    def process_data(self):
        print("子类数据加工（未调用父类逻辑）")

# 测试
good = GoodChild()
good.process_data()
good.check_super_for("process_data")  # 通过

bad = BadChild()
bad.process_data()
bad.check_super_for("process_data")  # 抛出AssertionError

3. 元类拦截：子类定义阶段强制检查 #

如果想要从根源上避免子类遗漏super()调用，可以用元类在子类定义时，静态分析方法代码中是否包含super()调用。注意：这种方式无法检测动态调用父类的场景（比如通过getattr调用）。

示例代码：

import ast
import inspect

class RequireSuperMeta(type):
    def __new__(cls, name, bases, attrs):
        for method_name, method in attrs.items():
            # 只检查重写了父类的方法
            for base in bases:
                if method_name in dir(base) and callable(method):
                    try:
                        # 解析方法源代码，检查是否有super()调用
                        source = ast.parse(inspect.getsource(method))
                        has_super = any(
                            isinstance(node, ast.Call) and 
                            isinstance(node.func, ast.Name) and 
                            node.func.id == 'super'
                            for node in ast.walk(source)
                        )
                        if not has_super:
                            raise TypeError(f"子类 {name} 的方法 {method_name} 必须调用 super()")
                    except OSError:
                        # 动态生成的方法无法获取源码，跳过检查
                        pass
        return super().__new__(cls, name, bases, attrs)

# 使用元类的父类
class Parent(metaclass=RequireSuperMeta):
    def process_data(self):
        pass

# 正确的子类
class GoodChild(Parent):
    def process_data(self):
        super().process_data()

# 错误的子类（定义时直接抛出TypeError）
class BadChild(Parent):
    def process_data(self):
        pass

4. 模板方法模式：从设计层面规避问题 #

如果可以调整父类设计，使用模板方法模式，让父类控制完整执行流程，子类只需要实现特定钩子方法，完全不需要手动调用super()。这是最可靠的方案。

示例代码：

class Parent:
    def process_data(self):
        # 父类固定前置逻辑
        print("父类数据校验")
        # 子类实现的自定义逻辑
        self._custom_process()
        # 父类固定后置逻辑
        print("父类数据归档")

    def _custom_process(self):
        raise NotImplementedError("子类必须实现 _custom_process 方法")

class Child(Parent):
    def _custom_process(self):
        print("子类数据转换")

# 调用时自动执行完整流程，无需子类调用super
child = Child()
child.process_data()
# 输出：
# 父类数据校验
# 子类数据转换
# 父类数据归档

内容的提问来源于stack exchange，提问作者Fernando Jesus Garcia Hipola