首页 > 文章 > python教程

new和init区别详解

时间：2025-09-20 19:10:10 390浏览收藏

在Python中，`__new__` 和 `__init__` 方法是对象生命周期中至关重要的两个环节。`__new__` 负责创建对象实例，如同工厂的“造物主”，而 `__init__` 则负责初始化对象，好比“装修师”，为“毛坯”对象填充属性和配置。理解它们的核心在于明确两者在对象构建过程中的职责分工。本文将深入解析 `__new__` 和 `__init__` 的区别、参数差异以及 `__new__` 不返回实例时的行为，并通过实际案例，阐述何时应该重写 `__new__` 方法，例如实现单例模式、创建不可变对象和子类化不可变类型等，助你掌握Python对象创建的底层机制，写出更高效、更灵活的代码。

__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` 的参数有什么不同？

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

*`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 的实例。