如何强制Python抽象类的子类持有指定名称与类型的成员？

我明白你的需求——你想让human这个抽象类的所有子类，都必须乖乖拥有一个叫hand、类型是Hands（或者它的子类）的成员，要是哪个子类没做到，直接报错不让它生效对吧？比如你举的German类，只调用父类初始化却没正确设置hand，这种情况就得被拦下来。

下面给你几个实用的实现方案，你可以根据需求选：

方案1：初始化时直接检查（简单粗暴有效） #

我们可以在父类human的__init__方法里加检查逻辑，确保子类实例化后一定有符合要求的hand成员：

from abc import ABC, abstractmethod

class Hands(object):
    pass

class human(ABC):
    def __init__(self):
        # 先让子类完成自己的初始化，再做检查
        super().__init__()
        # 第一步：检查有没有hand这个成员
        if not hasattr(self, 'hand'):
            raise TypeError(f"子类{self.__class__.__name__}必须定义名为hand的成员！")
        # 第二步：检查hand的类型是不是Hands或者它的子类
        if not isinstance(self.hand, Hands):
            raise TypeError(f"子类{self.__class__.__name__}的hand必须是Hands类型或其子类！")

class american_hands(Hands):
    pass

class american(human):
    def __init__(self):
        # 注意顺序：先给自己的hand赋值，再调用父类的初始化做检查
        self.hand = american_hands()
        super().__init__()

# 测试错误案例：这个German类没定义hand，实例化会报错
class German(human):
    def __init__(self):
        super().__init__()

# 跑下面这行代码就会触发TypeError
# German()

这里要注意子类__init__的顺序：必须先把self.hand赋值好，再调用父类的super().__init__()，不然父类检查的时候还没这个成员，就直接报错了。

方案2：用抽象属性+静态检查（提前发现问题） #

如果你希望在写代码的时候就能发现错误（不用等到运行时），可以结合抽象属性和类型注解，再配合静态检查工具比如mypy：

from abc import ABC, abstractmethod
from typing import TypeVar

# 定义类型变量，限定必须是Hands的子类
HandsType = TypeVar('HandsType', bound='Hands')

class Hands(object):
    pass

class human(ABC):
    @property
    @abstractmethod
    def hand(self) -> HandsType:
        """子类必须实现这个属性，返回Hands类型或其子类"""
        raise NotImplementedError

class american_hands(Hands):
    pass

class american(human):
    def __init__(self):
        self._hand = american_hands()
    
    # 子类必须实现hand属性
    @property
    def hand(self) -> american_hands:
        return self._hand

# 错误案例：German没实现hand抽象属性，mypy会直接标红，运行时也报错
class German(human):
    pass

# 实例化German会抛出NotImplementedError
# German()

这种方法的好处是，用mypy之类的工具检查代码时，就能提前发现子类没实现hand的问题，不用等到运行时才踩坑。

方案3：元类检查（更底层的控制） #

如果你想要更严格的控制，甚至在类定义阶段或者实例化的最底层做检查，可以用元类：

from abc import ABC, ABCMeta, abstractmethod

class Hands(object):
    pass

# 自定义元类，继承ABCMeta因为我们的父类是抽象类
class HumanMeta(ABCMeta):
    def __call__(cls, *args, **kwargs):
        # 先创建实例
        instance = super().__call__(*args, **kwargs)
        # 检查hand成员和类型
        if not hasattr(instance, 'hand'):
            raise TypeError(f"{cls.__name__}的实例必须包含hand成员！")
        if not isinstance(instance.hand, Hands):
            raise TypeError(f"{cls.__name__}的hand必须是Hands类型或其子类！")
        return instance

class human(ABC, metaclass=HumanMeta):
    pass

class american_hands(Hands):
    pass

class american(human):
    def __init__(self):
        self.hand = american_hands()

# 错误案例：German没设置hand，实例化直接报错
class German(human):
    def __init__(self):
        pass

# 运行下面这行就会报错
# German()

元类的__call__方法会在你实例化类的时候自动触发，不管子类的__init__怎么写，都能确保最终的实例一定有符合要求的hand成员，控制力度更强。

选哪个方案？ #

• 要是你想要简单直接，运行时检查就行，选方案1；
• 要是想提前在编码阶段发现问题，配合静态检查工具选方案2；
• 要是需要更底层、更严格的控制，选方案3。

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