Python中定义抽象类子类时，如何校验_READ_NAME的唯一性？

我采用如下类架构：

# abstracts.py
import abc
class AbstractReader(metaclass=abc.ABCMeta):
  
    @classmethod
    def get_reader_name(cl):
        return cls._READER_NAME

    @classmethod
    @property
    @abc.abstractmethod
    def _READER_NAME(cls):
        raise NotImplementedError

# concretes.py
from .abstracts import AbstractReader
class ReaderConcreteNumber1(AbstractReader):
    _READER_NAME = "NAME1"

class ReaderConcreteNumber2(AbstractReader):
    _READER_NAME = "NAME2"

我有一个通过_READER_NAME变量查找具体类的管理器类，因此要求每个AbstractReader的子类必须定义唯一的_READER_NAME值。请问在定义具体类时，如何校验NAME1、NAME2这类_READER_NAME值的唯一性？

方法一：自定义元类实现类定义阶段校验 #

修改AbstractReader的元类，在子类被创建时自动检查_READER_NAME的唯一性，同时维护一个全局注册表：

# abstracts.py
import abc

class ReaderMeta(abc.ABCMeta):
    # 存储所有已注册的_READ_NAME
    _registered_names = set()

    def __new__(cls, name, bases, namespace):
        # 先检查当前类是否定义了_READ_NAME
        if '_READER_NAME' in namespace:
            reader_name = namespace['_READER_NAME']
            if reader_name in cls._registered_names:
                raise ValueError(f"_READER_NAME '{reader_name}' 已被其他Reader类占用")
            cls._registered_names.add(reader_name)
        # 调用父类方法创建类
        return super().__new__(cls, name, bases, namespace)

class AbstractReader(metaclass=ReaderMeta):
  
    @classmethod
    def get_reader_name(cls):
        return cls._READER_NAME

    @classmethod
    @property
    @abc.abstractmethod
    def _READER_NAME(cls):
        raise NotImplementedError

这样只要你定义了重复的_READER_NAME，类在定义时就会直接抛出ValueError，从源头避免冲突。

方法二：用装饰器做校验 #

如果不想修改元类，可以给具体子类加装饰器，在装饰时完成唯一性检查：

# abstracts.py
import abc

# 全局存储已注册的名称
_registered_names = set()

def unique_reader_name(cls):
    reader_name = cls._READER_NAME
    if reader_name in _registered_names:
        raise ValueError(f"_READER_NAME '{reader_name}' 已经存在")
    _registered_names.add(reader_name)
    return cls

class AbstractReader(metaclass=abc.ABCMeta):
  
    @classmethod
    def get_reader_name(cls):
        return cls._READER_NAME

    @classmethod
    @property
    @abc.abstractmethod
    def _READER_NAME(cls):
        raise NotImplementedError

然后在具体类上应用装饰器：

# concretes.py
from .abstracts import AbstractReader, unique_reader_name

@unique_reader_name
class ReaderConcreteNumber1(AbstractReader):
    _READER_NAME = "NAME1"

@unique_reader_name
class ReaderConcreteNumber2(AbstractReader):
    _READER_NAME = "NAME2"

# 下面这个类定义会直接报错
@unique_reader_name
class DuplicateReader(AbstractReader):
    _READER_NAME = "NAME1"

方法三：在管理器注册环节校验 #

如果你的管理器需要主动注册Reader子类，可以把校验逻辑和注册绑定：

class ReaderManager:
    def __init__(self):
        self._reader_map = {}

    def register_reader(self, reader_cls):
        reader_name = reader_cls._READER_NAME
        if reader_name in self._reader_map:
            raise ValueError(f"_READER_NAME '{reader_name}' 已被注册")
        self._reader_map[reader_name] = reader_cls

    def get_reader(self, name):
        return self._reader_map.get(name)

# 使用示例
manager = ReaderManager()
manager.register_reader(ReaderConcreteNumber1)
manager.register_reader(ReaderConcreteNumber2)
# 重复注册会触发报错
manager.register_reader(ReaderConcreteNumber1)

这种方式适合需要集中管理所有Reader类的场景，把校验和业务逻辑绑定在一起。

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