Python派生类方法按需调用：存在则用、否则回退的规范实现

1. 小改动优化try-except方案（消除pylint警告） #

你的最后一种方案核心思路可行，只需调整基类中do_stuff_fast的定义方式，就能消除pylint警告并符合Python规范：

方案A：基类不定义do_stuff_fast，用鸭子类型检查 #

直接移除基类中的do_stuff_fast定义，在do_stuff里通过hasattr和callable判断当前实例是否实现了该方法：

class Base:
    def do_stuff_slow(self, data):
        # 通用慢速处理逻辑
        return processed_data

    def do_stuff(self, data):
        # 检查实例是否有可调用的do_stuff_fast方法
        if hasattr(self, "do_stuff_fast") and callable(getattr(self, "do_stuff_fast")):
            try:
                partial_result = self.do_stuff_fast(data)
                # 根据业务逻辑拆分剩余数据，传给慢速方法
                remaining_data = self._get_remaining_data(data, partial_result)
                return partial_result + self.do_stuff_slow(remaining_data)
            except Exception:
                # 快速方法出错时降级到慢速逻辑
                return self.do_stuff_slow(data)
        else:
            return self.do_stuff_slow(data)

    def _get_remaining_data(self, original, partial):
        # 通用的剩余数据拆分逻辑，按需实现
        pass

pylint不会警告未实现do_stuff_fast，因为基类根本没定义这个方法，只有主动实现的派生类才会触发快速路径。

方案B：基类定义空实现的do_stuff_fast #

如果需要在基类中保留该方法的占位，可将其实现为返回None的空方法，而非抛出NotImplementedError：

class Base:
    def do_stuff_slow(self, data):
        # 通用慢速处理逻辑
        return processed_data

    def do_stuff_fast(self, data):
        # 基类空实现，无快速逻辑时返回None
        return None

    def do_stuff(self, data):
        partial_result = self.do_stuff_fast(data)
        if partial_result is not None:
            remaining_data = self._get_remaining_data(data, partial_result)
            return partial_result + self.do_stuff_slow(remaining_data)
        else:
            return self.do_stuff_slow(data)

派生类只需在有快速逻辑时重写do_stuff_fast并返回非None结果即可，pylint不会强制要求实现该方法。

2. 重构类结构的替代方案 #

如果上述方案不符合你的代码风格，可选择以下更结构化的重构方式：

方式1：Mixin模式（明确区分有/无快速逻辑的类） #

定义一个专门的Mixin类承载快速方法的契约，需要快速逻辑的派生类继承该Mixin，基类通过类型检查判断是否走快速路径：

class Base:
    def do_stuff_slow(self, data):
        # 通用慢速处理逻辑
        return processed_data

    def do_stuff(self, data):
        if isinstance(self, FastStuffMixin):
            partial_result = self.do_stuff_fast(data)
            remaining_data = self._get_remaining_data(data, partial_result)
            return partial_result + self.do_stuff_slow(remaining_data)
        else:
            return self.do_stuff_slow(data)

class FastStuffMixin:
    # 定义快速方法的契约，派生类必须实现
    def do_stuff_fast(self, data):
        raise NotImplementedError

# 有快速逻辑的派生类
class DerivedFast(Base, FastStuffMixin):
    def do_stuff_fast(self, data):
        # 具体快速处理逻辑
        return partial_data

# 无快速逻辑的派生类
class DerivedSlow(Base):
    pass

这种方式边界清晰，pylint会警告继承FastStuffMixin的类必须实现do_stuff_fast，属于合理的强制约束。

方式2：策略模式（解耦快速逻辑与类继承） #

将快速逻辑作为可注入的策略，基类通过实例属性判断是否启用快速路径，避免继承层级的耦合：

class Base:
    def __init__(self, fast_strategy=None):
        self.fast_strategy = fast_strategy

    def do_stuff_slow(self, data):
        # 通用慢速处理逻辑
        return processed_data

    def do_stuff(self, data):
        if self.fast_strategy is not None:
            try:
                partial_result = self.fast_strategy(data)
                remaining_data = self._get_remaining_data(data, partial_result)
                return partial_result + self.do_stuff_slow(remaining_data)
            except Exception:
                return self.do_stuff_slow(data)
        else:
            return self.do_stuff_slow(data)

# 有快速逻辑的派生类
class DerivedFast(Base):
    def __init__(self):
        super().__init__(fast_strategy=self._internal_fast_logic)

    def _internal_fast_logic(self, data):
        # 具体快速处理逻辑
        return partial_data

# 无快速逻辑的派生类
class DerivedSlow(Base):
    pass

这种方式灵活性更高，甚至可以在运行时动态切换快速策略，完全避免了继承带来的约束。

内容的提问来源于stack exchange，提问作者CutOnBumInBand