如何禁止抽象类的子类新增方法？能否强制子类仅实现抽象类方法？

在Python中没有原生语法直接强制子类只能拥有抽象类中定义的方法，但可以通过元类或装饰器在类创建阶段进行检查，实现类似的限制。以下是具体实现方案，以及对最佳实践的讨论：

方案1：使用自定义元类控制类创建 #

通过继承ABCMeta（抽象类的元类），重写类创建逻辑，在子类定义时自动检查是否存在未授权的新增方法：

from abc import ABC, ABCMeta, abstractmethod

class StrictSubclassMeta(ABCMeta):
    def __new__(cls, name, bases, namespace):
        # 收集所有抽象基类中定义的非特殊方法
        allowed_methods = set()
        for base in bases:
            if isinstance(base, ABCMeta):
                # 过滤掉__开头的特殊方法
                allowed_methods.update(m for m in dir(base) if not m.startswith('__'))
        
        # 收集子类中自定义的非特殊方法
        subclass_methods = set()
        for attr_name, attr in namespace.items():
            if callable(attr) and not attr_name.startswith('__'):
                subclass_methods.add(attr_name)
        
        # 检查是否存在新增方法
        extra_methods = subclass_methods - allowed_methods
        if extra_methods:
            raise TypeError(f"子类 {name} 不允许新增未在抽象类中定义的方法: {', '.join(extra_methods)}")
        
        return super().__new__(cls, name, bases, namespace)

# 抽象类使用自定义元类
class MovementsService(ABC, metaclass=StrictSubclassMeta):
    @abstractmethod
    def run(self):
        pass

# 合法子类：仅实现抽象方法
class People(MovementsService):
    def run(self):
        print("im running")

# 非法子类：新增move方法会触发异常
class InvalidPeople(MovementsService):
    def run(self):
        print("im running")
    def move(self):
        print("im moving")  # 此处会抛出TypeError

方案2：使用装饰器检查子类 #

如果不想修改元类，可以用装饰器在子类定义后进行方法校验：

from abc import ABC, abstractmethod

def enforce_strict_subclass(abstract_cls):
    def decorator(subclass):
        # 获取抽象类允许的非特殊方法
        allowed_methods = {
            m for m in dir(abstract_cls) 
            if not m.startswith('__') and callable(getattr(abstract_cls, m, None))
        }
        # 排除object类自带的方法
        allowed_methods.update(dir(object))
        
        # 获取子类的非特殊方法
        subclass_methods = {
            m for m in dir(subclass) 
            if not m.startswith('__') and callable(getattr(subclass, m, None))
        }
        
        extra_methods = subclass_methods - allowed_methods
        if extra_methods:
            raise TypeError(f"子类 {subclass.__name__} 包含未授权方法: {', '.join(extra_methods)}")
        return subclass
    return decorator

class MovementsService(ABC):
    @abstractmethod
    def run(self):
        pass

# 用装饰器约束子类
@enforce_strict_subclass(MovementsService)
class People(MovementsService):
    def run(self):
        print("im running")

# 非法子类会触发异常
@enforce_strict_subclass(MovementsService)
class InvalidPeople(MovementsService):
    def run(self):
        print("im running")
    def move(self):
        print("im moving")

关于最佳实践的讨论 #

1. Python设计哲学的冲突：
   Python作为动态语言，核心优势是灵活性，强制限制子类方法数量违背了这种设计理念。过度约束会导致代码僵化，后续扩展需求可能受阻。

2. 更推荐的接口约束方式：

   • 文档与代码审查：在接口文档中明确声明子类仅需实现抽象方法，通过团队代码审查保证规范执行。
   • 测试用例校验：编写自动化测试，遍历项目中所有子类，检查是否存在未授权的新增方法。
   • 静态类型检查：使用mypy等工具，通过Protocol定义接口契约，虽然无法完全阻止新增方法，但能在开发阶段及时发现不符合规范的代码。

3. 强制方案的局限性：
   元类和装饰器只能拦截类定义阶段的方法新增，无法阻止运行时动态添加的方法（如通过setattr），只能作为开发阶段的辅助校验手段。

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