__new__和__init__方法有什么区别？-Python教程-PHP中文网

__new__和__init__方法有什么区别？

简而言之，

__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__

登录后复制

。但有些特定的场景，它就显得不可或缺了。我总结了一下，主要有以下几种情况：

实现单例模式 (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__

登录后复制

和

__init__

登录后复制

的参数有什么不同？

这是一个非常关键的区别，也是初学者容易混淆的地方。我来详细拆解一下：

法语写作助手

法语助手旗下的AI智能写作平台，支持语法、拼写自动纠错，一键改写、润色你的法语作文。

查看详情

*`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__

登录后复制

方法没有返回当前类

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
```
登录后复制
的实例。