Python中工厂方法内设置实例变量的实现方案探讨

你说得对，Python确实不支持像Java那样的构造方法重载，但我们有几种更优雅的方式来实现你的需求——既能避免调用__init__里开销高昂的计算，又能保持代码的整洁性，不用被迫写空构造+多个初始化方法或者冗余的通用构造。

方案1：直接调用__new__跳过__init__ #

这是最直接的方式：利用Python的实例创建机制，__new__负责创建实例对象，而__init__只是初始化实例。我们可以在类方法中手动调用__new__得到一个未初始化的实例，然后自己设置属性，完全跳过__init__里的开销逻辑：

def some_logic(val):
    # 模拟开销高昂的计算
    return val * 1000

def some_different_logic(val, additional):
    return val * additional

class Object:
    def __init__(self, x, y):
        self.a = some_logic(x)
        self.b = some_logic(y)
    
    @classmethod
    def produce_object(cls, x, y, additional_knowledge) -> 'Object':
        # 创建实例但不触发__init__
        o = cls.__new__(cls)
        # 用自定义逻辑初始化属性
        o.a = some_different_logic(x, additional_knowledge)
        o.b = some_different_logic(y, additional_knowledge)
        return o

# 测试
obj1 = Object(2, 3)
print(obj1.a, obj1.b)  # 输出：2000 3000

obj2 = Object.produce_object(2, 3, 5)
print(obj2.a, obj2.b)  # 输出：10 15

这个方案的优势是完全保留原来的__init__逻辑，同时类方法可以独立创建实例，不会触发任何不必要的计算。

方案2：拆分初始化逻辑到私有方法 #

如果需要支持多种初始化场景，可以把不同的初始化逻辑封装到私有方法中，然后通过__init__的参数或者类方法来选择调用哪个逻辑，避免写复杂的通用构造：

def some_logic(val):
    return val * 1000

def some_different_logic(val, additional):
    return val * additional

def another_logic(val1, val2):
    return val1 + val2, val1 - val2

class Object:
    def __init__(self, *args, init_type='default', **kwargs):
        # 根据初始化类型调用对应的私有方法
        if init_type == 'default':
            self._init_default(*args)
        elif init_type == 'additional':
            self._init_with_additional(*args, **kwargs)
        elif init_type == 'another':
            self._init_another(*args)
        else:
            raise ValueError(f"不支持的初始化类型：{init_type}")
    
    def _init_default(self, x, y):
        self.a = some_logic(x)
        self.b = some_logic(y)
    
    def _init_with_additional(self, x, y, additional_knowledge):
        self.a = some_different_logic(x, additional_knowledge)
        self.b = some_different_logic(y, additional_knowledge)
    
    def _init_another(self, e, f):
        self.a, self.b = another_logic(e, f)
    
    # 提供友好的类方法接口，用户无需直接处理init_type参数
    @classmethod
    def produce_with_additional(cls, x, y, additional_knowledge):
        return cls(x, y, init_type='additional', additional_knowledge=additional_knowledge)
    
    @classmethod
    def produce_with_another(cls, e, f):
        return cls(e, f, init_type='another')

# 测试
obj1 = Object(2, 3)
print(obj1.a, obj1.b)  # 2000 3000

obj2 = Object.produce_with_additional(2, 3, 5)
print(obj2.a, obj2.b)  # 10 15

obj3 = Object.produce_with_another(10, 3)
print(obj3.a, obj3.b)  # 13 7

这个方案的优势是扩展性强，新增初始化逻辑只需要添加对应的私有方法和类方法即可，而且用户调用时不用处理复杂的参数组合，每个类方法对应一种清晰的创建场景。

方案3：使用dataclass简化实例创建（Python 3.7+） #

如果你的Python版本在3.7及以上，使用dataclasses模块可以大幅简化代码，让不同的实例创建逻辑更加清晰：

from dataclasses import dataclass

def some_logic(val):
    return val * 1000

def some_different_logic(val, additional):
    return val * additional

def another_logic(val1, val2):
    return val1 + val2, val1 - val2

@dataclass
class Object:
    a: int
    b: int

    @classmethod
    def from_default(cls, x, y):
        return cls(some_logic(x), some_logic(y))
    
    @classmethod
    def from_additional(cls, x, y, additional_knowledge):
        return cls(some_different_logic(x, additional_knowledge), some_different_logic(y, additional_knowledge))
    
    @classmethod
    def from_another(cls, e, f):
        a, b = another_logic(e, f)
        return cls(a, b)

# 测试
obj1 = Object.from_default(2, 3)
print(obj1.a, obj1.b)  # 2000 3000

obj2 = Object.from_additional(2, 3, 5)
print(obj2.a, obj2.b)  # 10 15

obj3 = Object.from_another(10, 3)
print(obj3.a, obj3.b)  # 13 7

dataclass会自动帮我们生成__init__、__repr__等方法，我们只需要专注于不同的实例创建逻辑，每个类方法对应一种场景，参数明确，完全不会出现你担心的“大量参数为None”的问题。

为什么不推荐你之前的方案？ #

你提到的空__init__加多个初始化方法的方式，会导致实例创建后可能处于未初始化状态（a和b为None），如果后续忘记调用初始化方法，很容易引发错误。而上面的方案都能保证实例创建后立即处于有效状态，代码更健壮。

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