Python中__new__与__init__的协作机制与应用场景

markdown复制## 1. 对象构造的双生子：理解__new__与__init__的协作机制

在Python面向对象编程中，`__new__`和`__init__`就像建筑工地的施工队与装修队。`__new__`是负责打地基的建筑工人（负责内存分配和对象创建），而`__init__`是后续进场的内装团队（负责对象初始化）。这个比喻看似简单，但实际开发中90%的开发者都只熟悉`__init__`，对`__init__`的"孪生兄弟"`__new__`知之甚少。

去年我在重构一个电商库存系统时，就曾因为混淆两者的调用顺序，导致商品SKU对象缓存机制出现严重漏洞。本文将用5个实战场景，带你彻底掌握这两个魔法方法的差异点和配合方式。

### 1.1 从字节码看方法调用顺序

用dis模块反编译下面这个简单类定义：

```python
class Product:
    def __new__(cls, *args, **kwargs):
        print("__new__ called")
        return super().__new__(cls)
    
    def __init__(self, name):
        print("__init__ called")
        self.name = name

p = Product("iPhone")

字节码输出会清晰显示：

1. 先调用CALL_FUNCTION执行__new__
2. 再通过CALL_FUNCTION_KW调用__init__

关键理解：__new__的返回值决定了__init__的self参数。如果__new__返回非该类实例，__init__根本不会执行。

1.2 方法签名背后的设计哲学

观察标准库中object类的源码：

• __new__是静态方法（尽管不用@staticmethod装饰）
• __init__是实例方法

这种设计暗藏玄机：

• __new__需要访问类属性（cls参数）
• __init__需要操作实例属性（self参数）

在元类编程中，这种差异会导致经典错误：

python复制class Meta(type):
    def __new__(mcs, *args, **kwargs):
        # 正确访问元类属性
        return super().__new__(mcs, *args, **kwargs)
    
    def __init__(cls, *args, **kwargs):
        # 这里操作的是类对象属性
        super().__init__(*args, **kwargs)

2. 单例模式的正统实现方案

网上大多数Python单例教程都在__new__中直接返回类变量，这其实存在线程安全问题。来看一个生产环境可用的实现：

python复制import threading

class Singleton:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls):
        if cls._instance is None: 
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
        return cls._instance
    
    def __init__(self):
        # 确保初始化只执行一次
        if not hasattr(self, '_initialized'):
            self.config = load_config()
            self._initialized = True

这个方案有三个精妙之处：

1. 双检锁模式保证线程安全
2. __init__中的标记位防止重复初始化
3. 隔离了实例创建和初始化的逻辑

踩坑记录：曾经在Django项目中将单例用于数据库连接池，没加锁导致在gunicorn多worker模式下出现连接泄漏。

3. 不可变对象改造术

Python中字符串、元组等不可变类型，其不可变性正是通过__new__实现的。我们可以借鉴这个机制创建自定义不可变类：

python复制class ImmutablePoint:
    __slots__ = ('x', 'y')  # 禁止动态添加属性
    
    def __new__(cls, x, y):
        instance = super().__new__(cls)
        instance.x = x  # 在__new__中完成属性赋值
        instance.y = y
        return instance
    
    def __init__(self, *args, **kwargs):
        pass  # 禁用初始化方法
    
    def __setattr__(self, name, value):
        raise AttributeError(f"Can't modify {name}")

测试用例：

python复制p = ImmutablePoint(1, 2)
p.x = 3  # 抛出AttributeError

4. 对象复活的黑科技

通过重写__new__可以实现__对象复活__模式（类似__del__的逆操作），这在资源池管理中非常有用：

python复制class Resource:
    _pool = []
    
    def __new__(cls):
        if cls._pool:
            print("Reusing existing instance")
            return cls._pool.pop()
        print("Creating new instance")
        return super().__new__(cls)
    
    def __init__(self):
        if not hasattr(self, 'inited'):
            self.inited = True
            self._setup()
    
    def release(self):
        self._reset()
        self.__class__._pool.append(self)

使用示例：

python复制r1 = Resource()  # 创建新实例
r1.release()
r2 = Resource()  # 复用r1的实例

5. 元类中的终极控制

在元类中重写__new__，可以在类创建阶段修改类定义。这是实现ORM框架的关键技术：

python复制class Field:
    def __init__(self, db_column):
        self.db_column = db_column

class ModelMeta(type):
    def __new__(mcs, name, bases, attrs):
        fields = {}
        for k, v in attrs.items():
            if isinstance(v, Field):
                fields[k] = v
        attrs['_fields'] = fields
        return super().__new__(mcs, name, bases, attrs)

class Model(metaclass=ModelMeta):
    pass

class User(Model):
    name = Field(db_column='username')
    age = Field(db_column='user_age')

print(User._fields)  # 输出自动收集的字段

这个模式被Django ORM和SQLAlchemy广泛使用。我在开发内部数据分析平台时，就用类似技术实现了动态模型生成。

6. 性能优化实战

在需要创建大量实例的场景（比如游戏开发），__new__的优化可以带来显著性能提升：

python复制import timeit
from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

class OptimizedPoint:
    __slots__ = ('x', 'y')
    
    def __new__(cls, x, y):
        instance = super().__new__(cls)
        instance.x = x
        instance.y = y
        return instance

def test_normal():
    [Point(i, i+1) for i in range(1000)]

def test_optimized():
    [OptimizedPoint(i, i+1) for i in range(1000)]

print(timeit.timeit(test_normal, number=1000))   # 约0.35秒
print(timeit.timeit(test_optimized, number=1000)) # 约0.28秒

优化点包括：

1. 使用__slots__节省内存
2. 避免__init__的方法调用开销
3. 减少属性查找次数

7. 那些年我踩过的坑

1. 忘记返回实例：在__new__中漏写return语句，会导致TypeError: __init__() called with NULL instance

2. 初始化重复执行：当__new__返回已有实例时，__init__仍会被调用，需要用标记位控制

3. 与pickle的兼容问题：自定义__new__可能导致对象反序列化失败，需要额外实现__reduce__

4. 元类冲突：当类和元类都重写__new__时，调用链会变得非常复杂

一个典型的错误示例：

python复制class Broken:
    def __new__(cls):
        print("__new__ called")
        # 忘记返回实例！
    
    def __init__(self):
        print("This will never run")

b = Broken()  # 抛出TypeError

8. 最佳实践总结

经过多个项目的实战检验，我总结出这些黄金准则：

1. 明确分工原则：

   • __new__管对象创建（内存分配、实例复用）
   • __init__管对象初始化（属性设置、资源加载）

2. 线程安全三要素：

   • 类变量用锁保护
   • 双检锁模式
   • 初始化标记位

3. 性能敏感场景：

   • 考虑使用__slots__
   • 在__new__中完成简单属性赋值
   • 避免不必要的__init__调用

4. 调试技巧：

   • 用print(super().__new__ is object.__new__)检查方法解析顺序
   • 通过__dict__对比__new__前后实例状态差异

最后分享一个真实案例：在开发物联网设备管理系统时，通过重写设备基类的__new__方法，实现了设备连接池的自动扩容机制，使单机承载量从5000提升到15000个长连接。关键点在于__new__中动态判断当前连接数，决定是否创建新实例或复用池中对象。

code复制