简而言之，
__new__
方法负责创建并返回一个新的对象实例，而
__init__
方法则是在对象实例创建后，负责对其进行初始化。这是python对象生命周期中两个截然不同但又紧密关联的阶段。
解决方案
在我看来，理解
__new__
和
__init__
的核心在于它们在对象构建过程中的职责分工。
__new__
就像是工厂里的“造物主”，它负责从无到有地把一个“毛坯”对象生产出来，而
__init__
则是“装修师”，它拿到这个“毛坯”后，负责往里面填充各种属性、配置，让它变得可用、有意义。
当我们写
MyClass(arg1, arg2)
这样的代码时，Python解释器内部的调用顺序是这样的：
-
MyClass.__new__(MyClass, arg1, arg2)
被调用。
这是一个类方法（虽然你不需要显式地用@classmethod
装饰），它接收的第一个参数是
cls
，也就是当前类本身。它的主要任务是分配内存，然后返回一个该类的实例。通常，我们会调用
super().__new__(cls)
__new__
方法完成实际的实例创建。如果
__new__
方法返回的不是当前类的实例（或者根本没返回实例），那么
__init__
就不会被调用。
- 如果
__new__
返回了一个
MyClass
的实例，那么这个实例就会作为第一个参数
self
传递给
MyClass.__init__(self, arg1, arg2)
。
此时，__init__
的任务就是对这个已经存在的实例进行初始化，比如设置实例变量、调用其他方法等。它不应该返回任何值，返回
None
是隐式的默认行为。
我个人觉得，对于大多数日常编程任务，我们几乎只会和
__init__
打交道。因为它更直观，更符合我们“给对象属性赋值”的思维习惯。
__new__
只有在需要对实例的创建过程本身进行干预时才会被用到，比如实现一些高级的设计模式。
class MyClass: def __new__(cls, *args, **kwargs): print(f"__new__ called for class {cls.__name__} with args: {args}, kwargs: {kwargs}") # 实际创建实例，通常通过调用父类的__new__ instance = super().__new__(cls) print(f"Instance created by __new__: {instance}") return instance def __init__(self, name, value): print(f"__init__ called for instance {self} with name: {name}, value: {value}") self.name = name self.value = value print(f"Instance initialized: {self.name}, {self.value}") # 看看实际运行效果 print("--- Creating an instance ---") obj = MyClass("TestObject", 123) print(f"Final object: {obj.name}, {obj.value}") print("n--- What if __new__ returns something else? ---") class AnotherClass: def __new__(cls, *args, **kwargs): print(f"AnotherClass.__new__ called, but returning a string.") return "I am not an instance of AnotherClass!" def __init__(self, *args, **kwargs): print(f"AnotherClass.__init__ called. This should not happen if __new__ returns non-instance.") self.data = "initialized data" # 尝试创建AnotherClass的实例 not_an_instance = AnotherClass("hello") print(f"Returned by constructor: {not_an_instance}") # 你会发现__init__并没有被调用
什么时候应该重写
__new__
__new__
方法？
这是一个很好的问题，因为在日常开发中，我们很少会去动
__new__
。但有些特定的场景，它就显得不可或缺了。我总结了一下，主要有以下几种情况：
-
实现单例模式 (Singleton Pattern)： 当你希望一个类在整个应用程序生命周期中只创建一个实例时，
__new__
是最佳选择。你可以在
__new__
中检查是否已经存在该类的实例，如果存在就直接返回那个旧实例，而不是创建一个新的。这比在
__init__
中做判断更优雅，因为
__init__
总是会收到一个新的（尽管可能未被完全初始化的）实例。
class Singleton: _instance = None # 用于存储单例实例 def __new__(cls, *args, **kwargs): if cls._instance is None: print("Creating the one and only instance...") cls._instance = super().__new__(cls) else: print("Returning existing instance...") return cls._instance def __init__(self, name): # 注意：如果每次都创建新实例，__init__会被反复调用。 # 对于单例，如果想只初始化一次，需要在__init__中也做判断。 if not hasattr(self, '_initialized'): # 确保只初始化一次 print(f"Initializing instance with name: {name}") self.name = name self._initialized = True else: print(f"Instance already initialized. New name '{name}' ignored.") s1 = Singleton("First Instance") print(f"s1.name: {s1.name}") s2 = Singleton("Second Instance") # 这里的"Second Instance"不会改变s1的name print(f"s2.name: {s2.name}") print(f"s1 is s2: {s1 is s2}") # True，证明是同一个实例你会看到，
__new__
确保了实例的唯一性，而
__init__
还需要额外的逻辑来确保初始化行为只发生一次。
-
创建不可变对象 (Immutable Objects)： 如果你希望创建一个像
tuple
或
str
那样，一旦创建就不能修改内部状态的对象，
__new__
可以在对象创建时就锁定其结构。虽然这通常也可以通过在
__init__
中设置私有属性并避免提供setter方法来实现，但
__new__
在某些更底层的场景下提供更强的控制。
-
子类化不可变类型： 当你尝试子类化像
int
,
str
,
tuple
这样的内置不可变类型时，你通常需要重写
__new__
来创建正确类型的实例，因为它们的
__init__
方法可能不允许你在创建后修改内部状态。
class MyString(str): def __new__(cls, content): # 必须调用str的__new__来创建str实例 instance = super().__new__(cls, content.upper()) print(f"MyString instance created with: {instance}") return instance def __init__(self, content): # __init__在这里可以做一些额外的事情，但不能改变str的内部值 print(f"MyString __init__ called for {self}, original content was: {content}") self.extra_data = "some_extra_info" my_str = MyString("hello world") print(f"Result: {my_str}, type: {type(my_str)}") print(f"Extra data: {my_str.extra_data}") -
元类 (Metaclasses) 的实现： 虽然这有点超出了普通对象创建的范畴，但元类本身就是通过重写
type
的
__new__
方法来控制类的创建过程的。这算是
__new__
更高级的应用了。
__new__
__new__
和
__init__
的参数有什么不同？
这是一个非常关键的区别，也是初学者容易混淆的地方。我来详细拆解一下：
-
*`new(cls, args, kwargs)`
-
cls
：
它是__new__
的第一个参数，表示当前正在创建实例的类。是的，你没看错，它是一个类，而不是一个实例。这是因为
__new__
的任务是在实例被创建 之前 被调用，所以它不可能收到一个实例。
-
*args
和
**kwargs
：* 这些是传递给类构造函数（比如
MyClass(arg1, arg2, key=value)
）的所有位置参数和关键字参数。
__new__
接收它们，并通常会将它们原封不动地传递给 `super().new(cls, args,
kwargs)`，这样父类才能正确地创建实例。
-
-
*`init(self, args, kwargs)`
-
self
：
它是__init__
的第一个参数，表示已经由
__new__
方法创建并返回的那个实例。
__init__
的职责就是对这个
self
实例进行初始化。
- *`args
和
kwargs`： 同样，这些是传递给类构造函数的所有位置参数和关键字参数。它们会从
__new__
调用传递过来，供
__init__
用于设置实例的属性。
-
我们可以用一个简单的流程图来想象这个参数传递：
MyClass(param1, param2)
↓
MyClass.__new__(MyClass, param1, param2)
↓ (如果
__new__
返回
MyClass
的实例
obj
)
obj.__init__(param1, param2)
注意，
__new__
接收的
cls
和
__init__
接收的
self
是完全不同的东西。
cls
是一个类型对象，而
self
是一个已经存在的实例对象。当你重写
__new__
时，务必记得调用
super().__new__(cls, ...)
，并且将
cls
传进去，而不是
self
。
如果
__new__
__new__
不返回当前类的实例会发生什么？
这是一个非常有意思的“分支点”，也是理解
__new__
强大之处的关键。如果
__new__
方法没有返回当前类
cls
的一个实例（或者子类的实例），那么 Python 的解释器就会“认为”你已经完全接管了对象的创建过程，并且不再需要后续的初始化步骤了。
具体来说，会发生以下情况：
-
__init__
方法将不会被调用。 这是最重要的后果。因为
__init__
期望接收一个已经创建好的实例作为
self
，如果你在
__new__
中返回了一个完全不同的东西（比如一个字符串、一个数字、或者另一个类的实例），那么
__init__
就没有“目标”可以初始化了。Python 解释器会直接将
__new__
的返回值作为构造函数（
MyClass(...)
）的结果。
class MySpecialClass: def __new__(cls, value): print(f"MySpecialClass.__new__ called with value: {value}") if value < 0: print("Value is negative, returning a string instead of an instance.") return "Error: Negative value not allowed!" else: print("Value is non-negative, proceeding with instance creation.") return super().__new__(cls) def __init__(self, value): # 这个方法只有在__new__返回MySpecialClass的实例时才会被调用 print(f"MySpecialClass.__init__ called with value: {value}") self.value = value self.is_valid = True obj1 = MySpecialClass(10) print(f"obj1 type: {type(obj1)}, value: {obj1.value if hasattr(obj1, 'value') else 'N/A'}") print("n--- Testing with negative value ---") obj2 = MySpecialClass(-5) print(f"obj2 type: {type(obj2)}, value: {obj2}") # obj2现在是一个字符串！ # 尝试访问obj2.value会导致AttributeError # print(obj2.value) # 这会报错 -
你可以返回任意类型的对象。
__new__
可以返回一个完全不相关的对象，甚至是 Python 内置类型（如
str
,
int
,
list
）。这在某些高级场景下非常有用，比如你希望根据传入的参数动态地决定返回哪种类型的对象，或者实现一种“伪工厂”模式。
-
潜在的混淆和调试难度。 虽然这种行为提供了极大的灵活性，但如果滥用，也可能导致代码难以理解和调试。当一个类的构造函数返回的不是该类的一个实例时，可能会让使用者感到困惑，因为这打破了常规的对象创建预期。因此，我个人建议，除非有非常明确和充分的理由（比如前面提到的单例模式或子类化不可变类型），否则最好让
__new__
始终返回
cls
的实例。
这个特性是 Python 允许我们深度定制对象创建过程的体现，它赋予了我们对对象生命周期更底层的控制能力。但就像所有强大的工具一样，使用时也需要谨慎和深思熟虑。
评论（已关闭）
评论已关闭