__new__与__init__的基本概念
在python中，对象的生命周期通常涉及两个特殊方法：
-
*`new(cls, args, kwargs)`:
- 这是一个类方法（即使没有使用@classmethod装饰器，它也隐式地接收类作为第一个参数cls）。
- 它在实例被创建之前调用，负责创建并返回一个类的实例。
- 它是真正创建实例的方法，通常通过调用父类的__new__方法（如super().__new__(cls)或object.__new__(cls)）来完成实例的创建。
- 如果__new__没有返回当前类的实例（或者返回None），那么该类的__init__方法将不会被调用。
-
*`init(self, args, kwargs)`:
- 这是一个实例方法，它在__new__方法返回实例后立即调用。
- 它负责初始化新创建实例的状态，例如设置实例的属性。
- 它不返回任何值（隐式返回None）。
调用顺序总结： 当你创建一个类的实例时（例如obj = MyClass()），Python解释器会首先调用MyClass.__new__()来创建实例。如果__new__成功创建并返回了一个MyClass的实例，那么解释器会接着调用该实例的MyClass.__init__()方法来对其进行初始化。
__new__的正确使用姿势
__new__通常只在需要控制实例创建过程的特殊场景下重写，例如：
- 单例模式（Singleton）：确保一个类只有一个实例。
- 不可变对象（Immutable Objects）：在实例创建时进行特殊处理。
- 元类（Metaclasses）：高级用法，用于自定义类的创建。
在重写__new__时，务必遵循以下原则：
立即学习“Python免费学习笔记（深入）”；
- 第一个参数必须是cls：即使它是一个实例方法，__new__在被调用时，第一个参数永远是当前类。
- 必须返回一个实例：通常是通过调用父类的__new__方法来获取实例，例如 instance = super().__new__(cls, *args, **kwargs)。
- 不要在__new__中手动调用__init__：这是Python解释器的工作。如果在__new__中手动调用__init__，可能会导致重复初始化、初始化未完全创建的对象，或在__new__返回非实例对象时引发错误。
继承链中的行为
当存在继承关系时，__new__和__init__的调用行为会更加复杂：
- __new__的调用：当你实例化一个子类时，子类的__new__方法会首先被调用。如果子类没有重写__new__，则会向上查找父类的__new__方法。
- __init__的调用：只有当__new__方法返回的是当前类或其子类的实例时，该实例的__init__方法才会被调用。如果__new__返回了其他类型的对象，或者返回了None，那么当前类的__init__将不会被执行。
案例分析与常见陷阱
我们通过一个示例来深入理解__new__和__init__的复杂交互，特别是当__new__被错误实现时。
考虑以下有问题的代码：
class Demo:
def __new__(self): # 错误：__new__应接收cls作为第一个参数
self.__init__(self) # 陷阱：在__new__中手动调用__init__
print("Demo's __new__() invoked")
# 隐式返回None，因为没有显式return
def __init__(self):
print("Demo's __init__() invoked")
class Derived_Demo(Demo):
def __new__(self): # 错误：__new__应接收cls作为第一个参数
print("Derived_Demo's __new__() invoked")
# 隐式返回None，因为没有显式return
def __init__(self):
print("Derived_Demo's __init__() invoked")
def main():
obj1 = Derived_Demo()
print(f"obj1 is: {obj1}") # 观察obj1的值
obj2 = Demo()
print(f"obj2 is: {obj2}") # 观察obj2的值
main()运行上述代码的输出：
Derived_Demo's __new__() invoked Demo's __init__() invoked Demo's __new__() invoked obj1 is: None obj2 is: None
输出分析：
-
obj1 = Derived_Demo() 调用 Derived_Demo.__new__()：
- 打印 "Derived_Demo's __new__() invoked"。
- 陷阱一：Derived_Demo.__new__方法没有显式返回任何对象。在Python中，如果一个函数没有显式return语句，它会隐式返回None。因此，obj1最终被赋值为None。
- 陷阱二：由于__new__返回了None而不是Derived_Demo的实例，Python解释器不会继续调用Derived_Demo.__init__。这就是为什么你没有看到 "Derived_Demo's __init__() invoked"。
-
obj2 = Demo() 调用 Demo.__new__()：
- 陷阱三：在Demo.__new__内部，它手动调用了self.__init__(self)。此时，self实际上是Demo类（因为__new__的第一个参数是类）。这个调用导致了Demo.__init__被执行，打印出 "Demo's __init__() invoked"。这是一个反模式，因为__init__应该由Python解释器在__new__返回实例后自动调用。
- 接着，打印 "Demo's __new__() invoked"。
- 陷阱四：与Derived_Demo.__new__类似，Demo.__new__也没有显式返回任何对象，因此它也隐式返回None。obj2最终也被赋值为None。
正确的__new__和__init__实现
为了避免上述问题，并确保__new__和__init__按预期工作，我们应该这样实现它们：
class Demo:
def __new__(cls, *args, **kwargs): # 正确：第一个参数是cls
print("Demo's __new__() invoked")
# 正确：通过super()调用父类（object）的__new__来创建实例
instance = super().__new__(cls)
return instance # 正确：返回创建的实例
def __init__(self, value=None): # 可以有参数，用于初始化实例
print(f"Demo's __init__() invoked with value: {value}")
self.value = value
class Derived_Demo(Demo):
def __new__(cls, *args, **kwargs): # 正确：第一个参数是cls
print("Derived_Demo's __new__() invoked")
# 正确：通过super()调用父类（Demo）的__new__来创建实例
instance = super().__new__(cls)
return instance # 正确：返回创建的实例
def __init__(self, name=None): # 可以有参数，用于初始化实例
super().__init__(name) # 调用父类的__init__
print(f"Derived_Demo's __init__() invoked with name: {name}")
self.name = name
def main():
print("--- Creating obj1 ---")
obj1 = Derived_Demo(name="Alice")
print(f"obj1 is: {obj1}")
print(f"obj1.name: {obj1.name}")
print(f"obj1.value: {obj1.value}") # 继承自Demo的属性
print("\n--- Creating obj2 ---")
obj2 = Demo(value=123)
print(f"obj2 is: {obj2}")
print(f"obj2.value: {obj2.value}")
main()运行正确代码的输出：
--- Creating obj1 --- Derived_Demo's __new__() invoked Demo's __new__() invoked Demo's __init__() invoked with value: Alice Derived_Demo's __init__() invoked with name: Alice obj1 is: <__main__.Derived_Demo object at 0x...> obj1.name: Alice obj1.value: Alice --- Creating obj2 --- Demo's __new__() invoked Demo's __init__() invoked with value: 123 obj2 is: <__main__.Demo object at 0x...> obj2.value: 123
正确代码分析：
-
obj1 = Derived_Demo(name="Alice")：
- 首先调用Derived_Demo.__new__(cls, name="Alice")。
- Derived_Demo.__new__内部调用super().__new__(cls)，这会继续向上调用Demo.__new__，最终由object.__new__(cls)创建Derived_Demo的实例。
- Derived_Demo.__new__返回这个实例。
- Python解释器接收到这个实例后，接着调用Derived_Demo.__init__(obj1, name="Alice")。
- Derived_Demo.__init__内部调用super().__init__(name)，这会调用Demo.__init__来初始化父类部分。
- 最终，obj1是一个完全初始化好的Derived_Demo实例。
-
obj2 = Demo(value=123)：
- 首先调用Demo.__new__(cls, value=123)。
- Demo.__new__内部调用super().__new__(cls)，由object.__new__(cls)创建Demo的实例。
- Demo.__new__返回这个实例。
- Python解释器接收到这个实例后，接着调用Demo.__init__(obj2, value=123)。
- 最终，obj2是一个完全初始化好的Demo实例。
总结与最佳实践
- __new__是工厂，__init__是装修工：__new__负责生产出毛坯房（实例），__init__负责装修和配置这个毛坯房。
- 谨慎重写__new__：除非你有特定的需求（如实现单例模式、自定义不可变对象等），否则通常不需要重写__new__方法。
- 确保__new__返回实例：如果你重写了__new__，它必须返回一个有效的实例（通常是super().__new__(cls, ...)的结果）。如果返回None或非当前类的实例，后续的__init__将不会被调用。
- 避免在__new__中手动调用__init__：这是Python解释器的工作。手动调用会导致不确定行为，并且可能绕过正常的初始化流程。
- __new__的参数传递：__new__方法接收的参数（除了cls之外）会原封不动地传递给__init__。因此，__new__和__init__的签名（除了第一个参数）通常是匹配的。
理解__new__和__init__的正确用法对于编写健壮和高效的Python代码至关重要，尤其是在处理复杂的类结构和对象创建逻辑时。
