如何通过子类化设计可修改功能的Python模块？

我想设计一个Python模块，让功能可以通过子类化来修改，类似unittest模块的模式——用户创建unittest.TestCase的子类，把测试用例定义成类的方法，执行unittest.main()时这些方法就会被运行。

我自己写了一个模块，通过子类化MyRangeA来修改行为，用了魔术方法__new__和__subclasses__，目前测试能用，但想知道有没有更优方案，或者这个实现有没有潜在问题。

模块代码 #

class MyRangeA:

    def __new__(cls, upper_limit):

        if cls.__subclasses__():

            assert len(cls.__subclasses__()) == 1,\
                f"Expected not more than one subclass of {cls} but the following exist:\n{cls.__subclasses__()}"

            subclass = cls.__subclasses__().pop()

            return super().__new__(subclass)

        else:

            return super().__new__(cls)


    def __init__(self, upper_limit):

        self._upper_limit = upper_limit

    def __iter__(self):

        return iter(range(self._upper_limit))

def print_my_range():
    print(str.join(", ", [str(num) for num in MyRangeA(3)]))

客户端代码示例 #

from dunder_new import MyRangeA, print_my_range

class MyRangeB(MyRangeA):

    def __iter__(self):

        return iter(range(1, self._upper_limit + 1))

print_my_range()

客户端代码修改了print_my_range的输出，使其打印"1, 2, 3"而非"0, 1, 2"。

现有实现的潜在问题 #

• 依赖全局子类状态：__subclasses__()会返回所有已加载的子类，若其他模块也定义了MyRangeA的子类，断言会直接失败，完全不具备多环境兼容性。
• 单子类限制过于僵化：断言只允许存在一个子类，无法支持多子类共存场景，违背Python动态特性。
• 实例创建逻辑不直观：用户调用MyRangeA(3)却得到MyRangeB的实例，隐式行为增加代码理解与调试成本。
• 多层继承支持受限：若用户子类化MyRangeB，__new__逻辑只会取最顶层的直接子类，无法处理多层继承场景。

更优设计方案 #

方案1：显式指定子类（推荐） #

将控制权交给用户，让其主动传入子类，符合Python"显式优于隐式"的设计哲学：

模块代码：

class MyRangeBase:
    def __init__(self, upper_limit):
        self._upper_limit = upper_limit

    def __iter__(self):
        return iter(range(self._upper_limit))

def print_my_range(range_cls=MyRangeBase):
    print(", ".join(str(num) for num in range_cls(3)))

客户端代码：

from my_module import MyRangeBase, print_my_range

class MyRangeB(MyRangeBase):
    def __iter__(self):
        return iter(range(1, self._upper_limit + 1))

# 显式传入子类
print_my_range(MyRangeB)

方案2：自动发现子类（类似unittest逻辑） #

把子类收集逻辑放在模块入口函数中，而非干扰实例创建过程：

模块代码：

class MyRangeBase:
    def __init__(self, upper_limit):
        self._upper_limit = upper_limit

    def __iter__(self):
        return iter(range(self._upper_limit))

def print_my_range():
    # 收集所有直接子类
    subclasses = MyRangeBase.__subclasses__()
    # 可自定义选择逻辑，比如取最后定义的子类
    range_cls = subclasses[-1] if subclasses else MyRangeBase
    print(", ".join(str(num) for num in range_cls(3)))

客户端代码无需修改，保持原有子类定义即可。

方案3：工厂模式封装实例创建 #

用工厂函数统一处理子类选择逻辑，隔离实例创建与业务逻辑：

模块代码：

class MyRangeBase:
    def __init__(self, upper_limit):
        self._upper_limit = upper_limit

    def __iter__(self):
        return iter(range(self._upper_limit))

def create_range(upper_limit):
    subclasses = MyRangeBase.__subclasses__()
    # 可添加优先级、配置等自定义选择逻辑
    return subclasses[0](upper_limit) if subclasses else MyRangeBase(upper_limit)

def print_my_range():
    print(", ".join(str(num) for num in create_range(3)))

总结 #

原始实现虽能运行，但依赖全局状态且行为不直观。优先推荐显式指定子类的方案，清晰可控；若需自动发现子类，建议将逻辑放在入口函数或工厂中，避免在__new__中做隐式替换。

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