在 Python 类的魔法方法中，**`__new__` 方法**是唯一能够**修改返回的类实例化对象**的方法。该方法在对象创建阶段被调用，负责分配内存并返回新的实例，而 `__init__` 方法仅用于初始化已创建的对象 [ref_1]。 ### `__new__` 方法的核心作用 `__new__` 方法是 Python 中真正的构造器，它在类实例化时最先被调用。与 `__init__` 方法不同，`__new__` 的返回值决定了最终生成的实例对象 [ref_2]。 | 特性 | `__new__` 方法 | `__init__` 方法 | |------|----------------|-----------------| | **调用时机** | 对象创建阶段 | 对象初始化阶段 | | **返回值** | 必须返回一个对象实例 | 无返回值（返回 None） | | **主要作用** | 控制对象的创建过程 | 初始化对象属性 | | **修改实例能力** | **可以修改返回的实例** | 只能修改已有实例的属性 | ### `__new__` 方法修改实例的具体方式 #### 1. 返回不同类型的实例 `__new__` 方法可以返回与当前类不同的实例类型，这是修改返回实例最直接的方式： ```python class BaseClass: def __new__(cls, *args, **kwargs): # 返回一个字符串实例而不是 BaseClass 实例 return "Modified Instance" def __init__(self): print("This won't be executed") # 测试 obj = BaseClass() print(type(obj)) # 输出: <class 'str'> print(obj) # 输出: Modified Instance ``` 在这个例子中，`__new__` 方法返回了一个字符串对象，完全改变了实例的类型 [ref_3]。 #### 2. 实现单例模式 通过 `__new__` 方法控制实例的创建，可以实现单例模式： ```python class Singleton: _instance = None def __new__(cls, *args, **kwargs): if cls._instance is None: # 调用父类的 __new__ 方法创建实例 cls._instance = super().__new__(cls) # 始终返回同一个实例 return cls._instance def __init__(self, value): self.value = value # 测试单例模式 singleton1 = Singleton("First") singleton2 = Singleton("Second") print(singleton1 is singleton2) # 输出: True print(singleton1.value) # 输出: Second print(singleton2.value) # 输出: Second ``` 这里 `__new__` 方法确保了无论创建多少次，都返回同一个实例对象 [ref_5]。 #### 3. 修改实例的创建逻辑 `__new__` 方法可以在实例创建过程中添加自定义逻辑： ```python class CustomObject: def __new__(cls, value): # 在创建实例前进行验证 if value < 0: # 返回一个特殊的错误对象 return ValueError("Value cannot be negative") # 正常创建实例 instance = super().__new__(cls) instance.original_value = value return instance def __init__(self, value): # 只有当 __new__ 返回当前类实例时，__init__ 才会执行 if isinstance(self, CustomObject): self.processed_value = value * 2 # 测试 obj1 = CustomObject(10) print(f"Type: {type(obj1)}, Value: {obj1.processed_value}") # 输出: Type: <class '__main__.CustomObject'>, Value: 20 obj2 = CustomObject(-5) print(f"Type: {type(obj2)}, Value: {obj2}") # 输出: Type: <class 'ValueError'>, Value: Value cannot be negative ``` ### `__new__` 与 `__init__` 的协同工作 理解这两个方法的调用顺序对于正确修改实例至关重要： ```python class DemoClass: def __new__(cls, *args, **kwargs): print("1. __new__ 方法被调用") # 必须调用父类的 __new__ 来创建实例 instance = super().__new__(cls) print(f"2. 创建的实例: {instance}") return instance def __init__(self, name): print("3. __init__ 方法被调用") self.name = name print(f"4. 初始化完成: {self}") # 实例化过程 obj = DemoClass("Test") """ 输出顺序: 1. __new__ 方法被调用 2. 创建的实例: <__main__.DemoClass object at 0x...> 3. __init__ 方法被调用 4. 初始化完成: <__main__.DemoClass object at 0x...> """ ``` **关键点**：只有当 `__new__` 方法返回当前类的实例（或子类实例）时，`__init__` 方法才会被调用 [ref_1]。 ### 实际应用场景 #### 1. 不可变类型的子类化 当子类化不可变类型（如 tuple、str）时，必须重写 `__new__` 方法： ```python class CustomTuple(tuple): def __new__(cls, iterable): # 过滤掉 None 值 filtered = (x for x in iterable if x is not None) # 调用 tuple 的 __new__ 方法 return super().__new__(cls, filtered) def __init__(self, iterable): # __init__ 在不可变类型中通常不需要 pass # 测试 custom_tuple = CustomTuple([1, None, 2, None, 3]) print(custom_tuple) # 输出: (1, 2, 3) ``` #### 2. 工厂模式实现 使用 `__new__` 方法实现简单的工厂模式： ```python class Shape: def __new__(cls, shape_type, *args): if shape_type == "circle": return Circle(*args) elif shape_type == "rectangle": return Rectangle(*args) else: raise ValueError(f"Unknown shape type: {shape_type}") class Circle: def __init__(self, radius): self.radius = radius def area(self): return 3.14 * self.radius ** 2 class Rectangle: def __init__(self, width, height): self.width = width self.height = height def area(self): return self.width * self.height # 使用工厂 circle = Shape("circle", 5) rectangle = Shape("rectangle", 4, 6) print(f"Circle area: {circle.area()}") # 输出: Circle area: 78.5 print(f"Rectangle area: {rectangle.area()}") # 输出: Rectangle area: 24 ``` ### 注意事项 1. **必须返回对象**：`__new__` 方法必须返回一个对象实例，否则会引发 TypeError [ref_2]。 2. **参数传递**：`__new__` 方法的参数应该与 `__init__` 方法保持一致。 3. **元类影响**：在涉及元类的情况下，实例创建过程会更加复杂，元类的 `__new__` 方法会在类级别影响实例创建 [ref_6]。 ### 总结 在 Python 的魔法方法体系中，**只有 `__new__` 方法具备修改返回类实例化对象的能力**。它作为对象创建的第一道关卡，通过控制返回的实例对象，实现了单例模式、工厂模式、不可变类型定制等多种高级编程模式。相比之下，`__init__` 方法仅负责初始化已存在的实例，无法改变实例本身的性质 [ref_1][ref_3]。正确理解和使用 `__new__` 方法是掌握 Python 面向对象编程高级技巧的关键。