Python子类实例化时如何调用父类工厂方法替代构造方法

这个问题核心是拆分父类的初始化逻辑，让我们既能复用工厂方法里的无预处理逻辑，又能正常初始化子类属性。咱们一步步来解决：

首先看你的父类SuperObject，它有两条实例化路径：

• __init__：会先对property做预处理，再完成属性赋值
• create工厂方法：直接赋值原始property，完全跳过预处理

现在子类Object默认调用super().__init__会触发预处理，但你想复用create的逻辑。直接在子类__init__里调用create会返回一个新的父类实例，不是我们需要的子类实例，所以得换个思路——把父类里的核心初始化逻辑抽出来，让__init__和create都能复用它。

方案1：拆分父类的初始化逻辑（最优雅） #

先重构父类，把直接赋值属性的核心逻辑抽到一个单独的方法（比如_setup）里，这样__init__和create都可以调用这个方法：

def preprocess(prop):
    # 假设这是你的预处理逻辑
    return f"processed_{prop}"

class SuperObject:
    def __init__(self, property):
        # __init__先执行预处理，再调用核心初始化逻辑
        processed_prop = preprocess(property)
        self._setup(processed_prop)
    
    def _setup(self, property):
        # 核心初始化逻辑：只做属性赋值，无额外操作
        self.property = property
    
    @classmethod
    def create(cls, property):
        # 工厂方法直接调用核心逻辑，跳过预处理
        super_object = cls.__new__(cls)
        super_object._setup(property)
        return super_object

然后子类Object的__init__就可以直接调用_setup，而不是super().__init__，这样就完美避开了预处理：

class Object(SuperObject):
    def __init__(self, super_property, special_property):
        # 直接调用父类的核心初始化方法，传入原始的super_property
        self._setup(super_property)
        # 初始化子类自身的属性
        self.special_property = special_property

这个方案的优势很明显：

• 父类的核心初始化逻辑只写一次，__init__和create都复用，后续修改逻辑只需改动_setup
• 子类实例化完全符合正常的Object(...)调用方式，不需要强制用户改用工厂方法

方案2：子类重写工厂方法（适合不能修改父类的场景） #

如果没办法修改父类的代码，那可以在子类里重写create工厂方法，先调用父类的create创建子类实例，再补充子类专属属性：

class Object(SuperObject):
    def __init__(self, super_property, special_property):
        # 注意：直接调用这个构造方法还是会触发预处理，所以推荐让用户用create方法实例化
        super().__init__(super_property)
        self.special_property = special_property
    
    @classmethod
    def create(cls, super_property, special_property):
        # 调用父类的create创建当前子类的实例（cls是Object，父类create会生成Object实例）
        instance = super().create(super_property)
        # 补充子类的专属属性
        instance.special_property = special_property
        return instance

之后用户就可以通过Object.create("raw_prop", "special")得到一个super_property未被预处理的子类实例。但这个方案的缺点是，如果用户直接调用Object("raw_prop", "special")还是会触发预处理，需要额外约束调用方式。

方案3：跳过父类__init__直接赋值（简单但耦合高） #

如果父类逻辑非常简单，仅仅是赋值property，那也可以直接在子类__init__里跳过父类的__init__，自己给self.property赋值：

class Object(SuperObject):
    def __init__(self, super_property, special_property):
        # 完全不调用父类构造方法，直接赋值父类属性
        self.property = super_property
        self.special_property = special_property

但这个方案耦合性很高，如果父类后续在create里添加了其他初始化逻辑（比如绑定额外属性、注册回调等），子类就会漏掉这些逻辑，只适合极端简单的场景。

测试验证（方案1） #

# 父类用__init__实例化，会预处理
obj1 = SuperObject("test")
print(obj1.property)  # 输出 processed_test

# 父类用create实例化，不预处理
obj2 = SuperObject.create("test")
print(obj2.property)  # 输出 test

# 子类实例化，super_property不被预处理
obj3 = Object("raw_super", "my_special")
print(obj3.property)  # 输出 raw_super
print(obj3.special_property)  # 输出 my_special

完全符合你的需求！

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