如何处理抽象类中无需实现的抽象方法？

看起来你遇到的是**抽象类设计中“部分子类不需要实现某些抽象方法”**的典型问题，结合你的测量类场景，我给你几个实用的思路：

方案1：拆分抽象职责，用组合替代多重继承 #

你提到过拆分出Exclusions抽象类的想法，其实可以更灵活地用组合来解决，而不是硬套多重继承：

• 先把Denominator拆成两个独立的抽象类：BaseDenominator（只包含_set_populace）和ExclusionHandling（包含_remove_exclusions）
• 让需要处理排除逻辑的Submeasure（比如你的_Sub_1）同时继承BaseDenominator + ExclusionHandling + Numerator + Stratification
• 而不需要排除逻辑的Submeasure（_Sub_2）只继承BaseDenominator + Numerator + Stratification

这样做的好处是：

• 职责划分更清晰，每个抽象类只管一件事
• 子类可以按需组合需要的抽象能力，不会被迫实现不需要的方法
• 你不用纠结“怎么让代码区分Sub1和Sub2”，因为它们的继承结构本身就体现了差异

示例代码大概是这样：

from abc import ABC, abstractmethod

class BaseDenominator(ABC):
    @abstractmethod
    def _set_populace(self) -> None:
        pass

class ExclusionHandling(ABC):
    @abstractmethod
    def _remove_exclusions(self) -> None:
        pass

class Numerator(ABC):
    # 你的Numerator抽象方法
    pass

class Stratification(ABC):
    # 你的Stratification抽象方法
    pass

# 需要处理排除的Submeasure
class StandardSubmeasure(BaseDenominator, ExclusionHandling, Numerator, Stratification):
    pass

# 不需要处理排除的Submeasure
class SubsetSubmeasure(BaseDenominator, Numerator, Stratification):
    pass

# 然后你的具体子类
class _Sub_1(StandardSubmeasure):
    def _set_populace(self):
        # 实现逻辑
        pass
    def _remove_exclusions(self):
        # 实现逻辑
        pass

class _Sub_2(SubsetSubmeasure):
    def _set_populace(self):
        # 复用Sub1的结果，不需要实现_remove_exclusions
        pass

方案2：给抽象方法提供默认实现（谨慎使用） #

如果拆分抽象类太麻烦，你可以修改Denominator中的_remove_exclusions，给它一个默认的空实现，而不是强制子类重写：

class Denominator(ABC):
    @abstractmethod
    def _set_populace(self) -> None:
        pass

    # 改成普通方法，提供默认空实现
    def _remove_exclusions(self) -> None:
        """默认不做任何排除操作"""
        pass

这样做的好处是简单快捷，但要注意：

• 这个方法不再是强制实现的，所以如果某个子类应该实现排除逻辑但忘了，编译器不会提醒你
• 适合那些“可选实现”的方法，而不是核心职责方法

方案3：用标记类明确标识子类类型，跳过不必要的方法调用 #

如果你不想改动现有的抽象类结构，可以给不需要排除逻辑的子类加一个标记，然后在父类的流程中跳过这个方法的调用：
比如在Submeasure类中：

class Submeasure(Denominator, Numerator, Stratification):
    def run_calculation(self):
        self._set_populace()
        # 检查子类是否需要执行排除逻辑
        if not hasattr(self, '_skip_exclusions') or not self._skip_exclusions:
            self._remove_exclusions()
        # 后续的numerator和stratification逻辑
        self._calculate_numerator()
        self._apply_stratification()

# 然后在_Sub_2中：
class _Sub_2(Submeasure):
    _skip_exclusions = True

    def _set_populace(self):
        # 复用Sub1的结果
        pass

    # 不需要实现_remove_exclusions，因为父类会跳过

这种方式适合不想大规模重构现有代码的场景，用标记来控制流程。

最后回到你的问题核心：其实这种场景的本质是职责的拆分不够细，多重继承很容易导致这种“子类被迫实现不需要的方法”的问题，所以优先推荐方案1的组合式抽象，让每个子类只承担自己需要的职责。

备注：内容来源于stack exchange，提问作者Alex