Python中__new__和__init__的区别是什么？资深架构师一文讲透

第一章：Python中__new__与__init__方法的核心概念

在Python的面向对象编程中，__new__ 和 __init__ 是两个特殊的方法，它们共同参与对象的创建与初始化过程，但职责截然不同。

方法职责区分

__new__ 是一个类方法，负责创建类的实例。它在实例被创建之前调用，并返回该实例。开发者可以通过重写 __new__ 来控制对象的创建过程，例如实现单例模式。而 __init__ 是一个实例方法，负责在实例创建后对其进行初始化设置，如赋值属性，它不返回任何值（即返回 None）。

执行顺序与调用机制

当通过类创建实例时，Python 首先调用 __new__ 方法生成对象，然后将该对象作为第一个参数传递给 __init__ 方法。因此，__new__ 先于 __init__ 执行。

• __new__ 接收至少一个参数 cls，代表当前类
• __init__ 接收 self 参数，指向已创建的实例
• 若 __new__ 未返回实例，则 __init__ 不会被调用

# 示例：自定义 __new__ 与 __init__
class MyClass:
    def __new__(cls, *args, **kwargs):
        print("Creating instance via __new__")
        instance = super().__new__(cls)  # 调用父类 __new__
        return instance

    def __init__(self, value):
        print("Initializing instance via __init__")
        self.value = value

obj = MyClass(42)
# 输出：
# Creating instance via __new__
# Initializing instance via __init__

方法	调用时机	返回值要求
__new__	创建实例前	必须返回实例或子类实例
__init__	实例创建后	不应返回值（隐式返回 None）

第二章：深入理解__new__方法的底层机制

2.1 __new__方法的定义与调用时机

构造对象的第一步：`__new__` 的角色

在Python中，`__new__` 是一个静态方法，负责创建类的实例。它在 `__init__` 之前被调用，是对象创建过程中最先执行的方法。

class MyClass:
    def __new__(cls, *args, **kwargs):
        print("Creating instance via __new__")
        instance = super().__new__(cls)
        return instance

    def __init__(self, value):
        self.value = value
        print("Initializing instance in __init__")

上述代码中，`__new__` 接收的第一个参数是类本身（`cls`），通过 `super().__new__(cls)` 调用父类的 `__new__` 方法来实际创建实例。只有当 `__new__` 返回了当前类的实例时，系统才会继续调用 `__init__` 进行初始化。

调用时机与控制逻辑

• 每当实例化类时（如 obj = MyClass(10)），Python首先调用 __new__ 创建对象；
• 若 __new__ 返回的是当前类的实例，则自动调用 __init__；
• 若 __new__ 返回 None，则不会调用 __init__；
• 可用于实现单例模式或不可变类型对象的定制化创建。

2.2 如何通过__new__控制对象创建过程

在Python中，__new__ 是一个静态方法，负责实际的对象创建，位于 __init__ 之前执行。它接收类作为第一个参数，并返回类的实例。

控制实例创建时机

通过重写 __new__，可以在对象创建前加入逻辑判断，例如实现单例模式：

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

上述代码中，__new__ 拦截实例创建请求，仅允许生成一个实例。首次调用时创建对象，后续直接返回已存在的 _instance。

应用场景与优势

• 用于实现设计模式如单例、对象池
• 可拦截并定制不可变类型（如 tuple、str）的创建过程
• 在实例化前进行资源检查或条件过滤

相比 __init__，__new__ 更底层，适用于需要精细控制对象生成的场景。

2.3 使用__new__实现类的动态修改与元编程

Python 中的 `__new__` 是一个特殊方法，负责实例的创建过程。通过重写 `__new__`，可以在对象生成前干预类的构造逻辑，实现动态属性注入或单例模式等高级控制。

动态修改类结构

在 `__new__` 中可动态添加方法或属性，适用于插件式架构：

class MetaClass(type):
    def __new__(cls, name, bases, attrs):
        # 动态添加日志功能
        attrs['logged'] = True
        return super().__new__(cls, name, bases, attrs)

class Service(metaclass=MetaClass):
    pass

print(Service.logged)  # 输出: True

上述代码中，`__new__` 在类创建时自动注入 `logged` 属性，实现了无需继承的横向功能扩展。

应用场景对比

场景	使用__new__	传统方式
单例模式	直接控制实例创建	依赖全局变量
类注册	自动注册子类	手动注册

2.4 单例模式中的__new__实践应用

在Python中，`__new__` 是类创建实例的静态方法，通过重写 `__new__` 可实现单例模式，确保类仅生成一个实例。

核心实现机制

利用类属性记录实例状态，控制 `__new__` 的返回值：

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance

上述代码中，`_instance` 为类变量，首次调用时创建实例并缓存；后续调用直接返回已有实例。`super().__new__(cls)` 调用父类 `object.__new__` 分配内存。

应用场景与优势

• 适用于日志管理器、配置中心等需全局唯一对象的场景
• 相比模块级变量，更具封装性和可继承性

2.5 __new__在不可变类型中的特殊作用

在Python中，不可变类型如 `int`、`str` 和 `tuple` 一旦创建便无法更改。此时，`__new__` 方法承担了对象构造的核心职责。

不可变对象的定制化创建

通过重写 `__new__`，可以在实例化前干预对象的生成过程。例如，实现单例模式或缓存特定值的实例。

class ImmutableWithCache:
    _cache = {}
    
    def __new__(cls, value):
        if value in cls._cache:
            return cls._cache[value]
        instance = super().__new__(cls)
        cls._cache[value] = instance
        return instance
        
    def __init__(self, value):
        if not hasattr(self, 'value'):
            self.value = value

上述代码中，`__new__` 拦截对象创建，对相同值返回缓存实例。由于不可变类型无法在 `__init__` 中重新赋值，因此必须在首次构造时完成初始化。

与__init__的协作限制

对于不可变类型，`__init__` 仅在新实例创建后调用一次。若 `__new__` 返回缓存对象，则跳过 `__init__`，防止状态被篡改。

第三章：剖析__init__方法的初始化逻辑

3.1 __init__方法的职责与执行流程

构造函数的基本职责

`__init__` 方法是 Python 类中的初始化方法，负责在实例创建后设置对象的初始状态。它不创建对象（由 `__new__` 完成），而是配置已创建的实例。

执行流程解析

当调用类创建实例时，Python 自动调用 `__init__`，传入实例本身（`self`）及其它参数。以下示例展示其典型用法：

class Person:
    def __init__(self, name, age):
        self.name = name  # 初始化实例属性
        self.age = age

上述代码中，`name` 和 `age` 被绑定到实例 `self` 上，成为实例属性。参数说明： - `self`：指向新创建的实例； - `name`, `age`：外部传入的初始化数据。

• 执行时机：实例化后立即调用
• 可选性：若未定义，Python 使用继承链中的 `__init__` 或不执行任何操作
• 返回值：不应有显式返回（或仅返回 None）

3.2 __init__中的参数传递与实例初始化

在Python类的构建过程中，`__init__`方法负责实例的初始化工作。它接收创建对象时传入的参数，并将这些值绑定到实例属性上。

基本参数传递

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

上述代码中，`name`和`age`是`__init__`方法的形式参数，用于接收外部传入的实际值。当执行`p = Person("Alice", 30)`时，参数被赋值给实例变量。

默认参数与可变参数

• 使用默认值参数可提高灵活性：def __init__(self, name, age=18)
• 支持*args和**kwargs处理不定长参数

通过合理设计`__init__`的参数结构，可以实现灵活且健壮的对象初始化逻辑。

3.3 常见__init__使用误区与最佳实践

避免在 __init__ 中执行耗时操作

初始化方法应聚焦于对象状态的设置，而非执行网络请求或文件读取等副作用操作。这有助于提升实例化效率并降低耦合。

正确使用默认参数

• 切勿使用可变对象（如列表、字典）作为参数默认值
• 推荐使用 None 代替可变默认值，并在函数体内初始化

class UserManager:
    def __init__(self, users=None):
        self.users = users if users is not None else []

上述代码避免了多个实例共享同一列表的陷阱。若将默认值设为 []，所有实例将引用同一个列表对象，导致数据污染。

优先使用类型注解提升可维护性

结合 __init__ 使用类型提示，能显著增强代码可读性与IDE支持能力。

第四章：__new__与__init__的协作与差异对比

4.1 执行顺序分析：谁先谁后？

在并发编程中，执行顺序直接影响程序的正确性。多个 goroutine 同时访问共享资源时，若缺乏同步机制，将导致不可预测的行为。

竞态条件示例

var counter int
func worker() {
    for i := 0; i < 1000; i++ {
        counter++ // 存在竞态条件
    }
}
// 启动两个协程并发执行worker

上述代码中，counter++ 实际包含读取、修改、写入三步操作，多个协程同时执行会导致结果不一致。

同步控制手段

• 使用 sync.Mutex 保护临界区
• 通过 channel 实现协程间通信与协作
• 利用 WaitGroup 控制启动与等待时机

执行顺序保障策略对比

机制	适用场景	开销
Mutex	共享变量保护	中等
Channel	数据传递与同步	较高

4.2 返回值差异对对象构造的影响

在面向对象编程中，构造函数的返回值处理方式直接影响对象的初始化行为。某些语言允许显式返回对象实例，而另一些则隐式返回当前构造的实例。

构造函数中的显式与隐式返回

以 Go 语言为例，构造函数通常为普通函数，需显式返回指针：

func NewUser(name string) *User {
    return &User{Name: name}
}

该模式明确控制返回值，便于实现对象池或单例逻辑。而在 JavaScript 中，new 调用构造函数时，若无显式返回对象，则默认返回 this：

function Person(name) {
    this.name = name;
}
const p = new Person("Alice"); // 返回新创建的实例

返回值覆盖对构造语义的影响

若构造函数显式返回一个非空对象，JavaScript 将放弃原本的 this 实例：

• 返回原始类型：忽略，仍使用 this
• 返回对象类型：替代 this 成为 new 表达式的结果

这一机制可能导致意外的对象共享，需谨慎处理。

4.3 在继承体系中两者的交互行为

在面向对象设计中，父类与子类之间的状态和行为交互尤为关键。当子类继承并扩展父类时，字段与方法的初始化顺序直接影响运行时表现。

初始化顺序规则

Java等语言遵循严格的初始化流程：

1. 父类静态字段与块
2. 子类静态字段与块
3. 父类实例字段与构造函数
4. 子类实例字段与构造函数

代码示例与分析

class Parent {
    protected int value = 10;
    public Parent() {
        display(); // 可能引发问题
    }
    public void display() { System.out.println(value); }
}

class Child extends Parent {
    private int value = 20;
    @Override
    public void display() { System.out.println(value); }
}

上述代码中，Child 构造时先调用 Parent 构造函数，而其中的 display() 被重写，此时子类字段尚未初始化，输出为0，体现虚方法调用的风险。

安全实践建议

避免在构造函数中调用可被重写的方法，以防止访问未初始化的子类状态。

4.4 实战案例：自定义类创建与初始化流程

在面向对象编程中，类的创建与初始化是构建可复用组件的核心环节。通过定义构造函数和初始化逻辑，开发者能够精确控制对象的生成过程。

构造函数中的参数注入

以 Python 为例，使用 `__init__` 方法实现初始化：

class DatabaseConnection:
    def __init__(self, host: str, port: int = 5432, ssl: bool = False):
        self.host = host
        self.port = port
        self.ssl = ssl
        self.is_connected = False

上述代码中，`__init__` 接收主机地址、端口和 SSL 配置，并赋予默认值。实例化时自动绑定属性，确保对象状态一致。

初始化流程的执行顺序

• 解释器调用 __new__ 创建空实例
• 传递参数至 __init__ 进行属性赋值
• 完成对象构建，返回可用实例

该机制保障了资源预加载与依赖注入的有序执行，适用于数据库连接池、配置管理等场景。

第五章：总结与高级应用场景展望

微服务架构中的实时配置同步

在复杂的微服务系统中，Consul 的 KV 存储常被用于集中管理配置。通过 Watch 机制，各服务可监听关键路径变化并动态重载配置，避免重启。例如，在 Go 应用中使用 consul API 监听变更：

watch, err := api.NewWatchHandle(&consulapi.QueryOptions{
    WaitTime: 10 * time.Second,
}, func(idx uint64, raw interface{}) {
    if data, ok := raw.(map[string]interface{}); ok {
        reloadConfig(data)
    }
})

多数据中心故障转移策略

利用 Consul 的多数据中心复制能力，可在主数据中心宕机时快速切换至备用集群。以下为跨 DC 连接状态监控的常用指标：

指标	正常阈值	告警条件
RTT 延迟	< 50ms	> 100ms 持续 3 次
连接成功率	> 99.9%	< 95% 超过 1 分钟

服务网格集成实践

Consul 可与 Envoy 或 Linkerd 集成，实现细粒度流量控制。通过定义 Service Intentions，可编程地管理 mTLS 通信策略。典型操作流程包括：

• 注册服务至 Consul Agent
• 启用 Connect 功能并签发证书
• 通过 API 创建 intention 规则，如 "frontend" 允许调用 "payment-service"
• 部署 sidecar 代理拦截进出流量

架构示意：
[Client] → [Sidecar Proxy] ⇄ (Consul Server) ⇄ [Service Registry]