如何从各含N个子类的众多子类中便捷实例化孙类？

现有父类Letters，其下有26个子类A、B、C……Z，每个子类又各有2个孙类（如UpperA、LowerA、UpperB、LowerB等）。希望在Letters中定义LetterFactory函数，避免重复编写52次大小写判断逻辑。

原计划的工厂函数代码如下：

def LetterFactory(font: str, letter: str, lettercase: str):
  match letter:
    case 'A':
      if lettercase == 'upper':
        return UpperA(font)
      elif lettercase == 'lower':
        return LowerA(font)
    case 'B':
       ...

你已尝试两种方案但均不满意：

1. 字典映射方案：需手动维护26个字母的大小写类映射，仍有重复工作

alphabet = {
"A" : {
  "upper" : UpperA,
  "lower" : LowerA
},
"B" : {
...
}

2. 基于类名动态查找：依赖全局命名空间，实现不够优雅

def LetterFactory(font: str, letter: str, lettercase: str):
    class_name = lettercase + letter
    letter_class = globals()[class_name]
    return letter_class(font)

方案1：装饰器显式注册（推荐） #

通过装饰器在定义孙类时自动注册到统一注册表，无需手动维护映射，同时避免依赖全局命名空间：

# 全局注册表，存储(字母, 大小写)到类的映射
letter_registry = {}

def register_letter(letter: str, lettercase: str):
    """装饰器：将字母类注册到注册表"""
    def decorator(cls):
        letter_registry[(letter, lettercase)] = cls
        return cls
    return decorator

# 定义孙类时直接注册
@register_letter('A', 'upper')
class UpperA(Letters):
    def __init__(self, font):
        self.font = font

@register_letter('A', 'lower')
class LowerA(Letters):
    def __init__(self, font):
        self.font = font

# 最终的工厂函数
def LetterFactory(font: str, letter: str, lettercase: str):
    target_cls = letter_registry.get((letter, lettercase))
    if not target_cls:
        raise ValueError(f"不支持的字母{letter}或大小写{lettercase}")
    return target_cls(font)

优势：注册逻辑与类定义绑定，不易出错；显式注册比动态查找更安全、可读性更强。

方案2：调整类结构，将大小写作为参数 #

如果允许调整现有类的设计，可以将大小写作为字母类的初始化参数，而非拆分独立子类，大幅减少类的数量和映射维护成本：

# 重构字母子类，接受大小写参数
class A(Letters):
    def __init__(self, font, lettercase: str):
        self.font = font
        self.case = lettercase
        # 可根据case实现不同逻辑，或用策略模式拆分具体行为

class B(Letters):
    def __init__(self, font, lettercase: str):
        self.font = font
        self.case = lettercase

# 工厂函数只需维护26个字母类的映射
letter_classes = {'A': A, 'B': B, ..., 'Z': Z}

def LetterFactory(font: str, letter: str, lettercase: str):
    target_cls = letter_classes.get(letter)
    if not target_cls:
        raise ValueError(f"不支持的字母{letter}")
    if lettercase not in ('upper', 'lower'):
        raise ValueError(f"不支持的大小写{lettercase}")
    return target_cls(font, lettercase)

优势：类结构更简洁，工厂函数逻辑更简单，后续扩展新大小写类型也更方便。

方案3：元类自动注册 #

如果已有大量符合命名规则的孙类（如UpperX/LowerX），可以用元类自动完成注册，无需手动添加装饰器：

class LetterMeta(type):
    """元类：自动注册符合命名规则的字母类"""
    letter_registry = {}

    def __new__(cls, name, bases, attrs):
        new_cls = super().__new__(cls, name, bases, attrs)
        # 从类名提取大小写和字母（如UpperA -> ('upper', 'A')）
        if name.startswith('Upper'):
            lettercase = 'upper'
            letter = name[5:]
        elif name.startswith('Lower'):
            lettercase = 'lower'
            letter = name[5:]
        else:
            # 非目标类，直接返回
            return new_cls
        LetterMeta.letter_registry[(letter, lettercase)] = new_cls
        return new_cls

# 让父类Letters继承该元类
class Letters(metaclass=LetterMeta):
    pass

# 定义孙类时会自动注册，无需额外操作
class UpperA(Letters):
    def __init__(self, font):
        self.font = font

class LowerA(Letters):
    def __init__(self, font):
        self.font = font

# 工厂函数
def LetterFactory(font: str, letter: str, lettercase: str):
    target_cls = LetterMeta.letter_registry.get((letter, lettercase))
    if not target_cls:
        raise ValueError(f"不支持的字母{letter}或大小写{lettercase}")
    return target_cls(font)

优势：完全自动注册，无需修改现有类的定义（只要类名符合规则），适合已有大量类的场景。

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