Python的构造方法把我坑惨了,原来__new__和__init__的区别这么大

0 阅读10分钟

小许那天想实现一个单例模式。

他的需求很明确:一个数据库连接类,整个程序里只允许存在一个实例,所有地方共用同一个连接。他的思路是,在初始化的时候检查一下“是不是已经创建过了”,如果创建过,就复用原来的。

代码大概长这样:

class Database:
    _instance = None

    def __init__(self):
        if Database._instance is not None:
            self = Database._instance
            return
        Database._instance = self
        self.connection = create_connection()

跑起来之后,他写了两个地方去拿数据库对象:

db1 = Database()
db2 = Database()

print(db1 is db2)  # False

db1和db2不是同一个对象。单例没实现,__init__里的判断看起来执行了,但没有任何效果。更糟糕的是,create_connection()被调用了两次,第二次连接把第一次的连接覆盖了,第一次连接泄漏了。

小许很困惑:“我在__init__里明明判断了_instance,为什么还是创建了两个对象?”

同事看了一眼说:“__init__不是用来创建对象的,它是用来初始化对象的。对象在__init__执行之前就已经被创建好了。你要控制‘创建’这件事,得用__new__。”

小许把代码改成了:

class Database:
    _instance = None

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

这次db1 is db2返回True,单例生效了。

“原来__init__拿到的是一个已经存在的对象,我改它的属性可以,但没办法阻止它被创建。创建对象的动作发生在__init__之前,在__new__里。”

这个认知,就是很多人对Python构造过程感到困惑的起点:__new__负责“造出一个对象”,__init__负责“把这个对象配置好”。它们一前一后,职责完全不同。

先看一个最直观的对比

class Demo:
    def __new__(cls, *args, **kwargs):
        print("__new__ 被调用")
        instance = super().__new__(cls)
        return instance

    def __init__(self, value):
        print("__init__ 被调用")
        self.value = value

d = Demo(42)

输出:

__new__ 被调用
__init__ 被调用

顺序很清楚:先__new__,后__init__。

__new__接收的是cls(类),返回一个实例。__init__接收的是self(__new__返回的那个实例),不返回任何东西(必须返回None)。

用一个生活场景来理解。

你要开一家餐厅。

__new__是盖房子:从无到有,把餐厅的物理空间建出来。没有房子,后面的一切都无从谈起。

__init__是装修和布置:房子已经建好了,你往里面放桌椅、装厨房设备、挂招牌。你是在已有的房子上做配置,不是在造房子。

区别一目了然:__new__负责“从无到有”,__init__负责“从有到好用”。

new:真正创建实例的方法

__new__是一个静态方法(虽然Python会自动传cls),它的签名通常是:

def __new__(cls, *args, **kwargs):
    instance = super().__new__(cls)
    return instance

它的核心职责是:分配内存,创建实例,返回这个实例。

super().__new__(cls)调用父类的__new__,由object.__new__(cls)完成实际的内存分配。对于绝大多数类,你不需要重写__new__,因为默认的object.__new__已经够用了。

需要重写__new__的场景,通常是“创建过程本身需要特殊控制”:

单例模式:控制“只创建一次”。

class Singleton:
    _instance = None

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

不可变类型的子类:int、str、tuple、frozenset这些类型,一旦创建就不能修改。它们的值必须在__new__里确定,因为__init__执行时对象已经不可变了。

class PositiveInt(int):
    def __new__(cls, value):
        if value < 0:
            raise ValueError("必须是正数")
        return super().__new__(cls, value)

对象池/缓存:创建前先查缓存,有就返回缓存里的,没有才新建。

控制实例的创建条件:比如只允许创建特定数量的实例,或者根据参数返回不同子类的实例。

__new__的关键特性是:它返回什么,__init__就接收什么。 如果__new__返回的不是当前类的实例,__init__根本不会被调用。

class Demo:
    def __new__(cls):
        return "我不是 Demo 实例"

    def __init__(self):
        print("这行不会执行")

d = Demo()
print(d)  # "我不是 Demo 实例"

__new__返回了字符串,不是Demo实例,Python就跳过了__init__。这个行为在工厂模式里有用,但也容易造成“__init__莫名其妙没执行”的困惑。

init:初始化已创建的对象

__init__是实例方法,第一个参数是self,指向__new__返回的实例。它的职责是:给这个已经存在的实例设置初始状态。

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

__init__不能返回任何东西(除了None)。如果它返回了非None的值,Python会报错:

class User:
    def __init__(self):
        return "something"  # TypeError: __init__() should return None

这个限制是刻意的:__init__的职责是“配置”,不是“创建”。创建是__new__的事,__init__不应该抢这个活。

__init__在绝大多数类里都会被重写,因为它是设置实例属性的标准位置。但它不负责创建对象,它拿到的self已经是创建好的实例了。

坑一:在 init 里实现单例

这就是小许踩的坑。

def __init__(self):
    if Database._instance is not None:
        self = Database._instance  # 这行没用
        return
    Database._instance = self

self = Database._instance只是把局部变量self重新绑定到了另一个对象,不会改变调用者拿到的对象。调用者拿到的仍然是__new__创建的那个新实例,只是它的__init__提前返回了,属性没设置全。

单例必须用__new__控制,因为只有__new__能决定“返回哪个对象”。__init__改不了这个决定。

坑二:在 new 里忘记返回实例

class User:
    def __new__(cls, name):
        cls.name = name  # 忘了 return

__new__没有返回值,默认返回None。User("Alice")得到的是None,不是User实例。

u = User("Alice")
print(u)  # None

__new__必须显式返回一个实例,通常是super().__new__(cls)的结果。忘了写return,整个类的构造就废了。

坑三:在 init 里给不可变类型赋值

class PositiveInt(int):
    def __init__(self, value):
        if value < 0:
            raise ValueError("必须是正数")
        self.value = value  # AttributeError

int是不可变类型,__init__执行时对象的值已经固定了,不能再给它设置新属性(除非类定义了__dict__,但int没有)。

更重要的是,__init__里的校验发生在对象已经创建之后。如果校验失败,对象已经被创建了,只是初始化没完成。对于不可变类型,值必须在__new__里确定,校验也必须在__new__里做。

class PositiveInt(int):
    def __new__(cls, value):
        if value < 0:
            raise ValueError("必须是正数")
        return super().__new__(cls, value)

__new__里校验,校验不过就不创建对象。这是不可变类型子类化的标准写法。

坑四:new 的参数和 init 不一致

class Demo:
    def __new__(cls, a, b):
        return super().__new__(cls)

    def __init__(self, a):
        self.a = a

Demo(1, 2)调用时,__new__接收(cls, 1, 2),__init__接收(self, 1, 2)。__init__只声明了一个参数a,但实际收到了两个,直接报TypeError。

__new__和__init__接收的参数必须一致(除了第一个cls/self)。如果__new__需要额外参数,__init__也要能接收这些参数,哪怕它不用。

更隐蔽的情况是__new__吃掉了某些参数,__init__收到的不一样:

class Demo:
    def __new__(cls, a, b):
        instance = super().__new__(cls)
        instance.b = b
        return instance

    def __init__(self, a, b):
        self.a = a

这里两者都接收(a, b),没问题。但如果__new__改了签名,__init__没跟着改,就会出错。

坑五:new 返回了其他类的实例,init 不执行

class Factory:
    def __new__(cls, kind):
        if kind == "a":
            return A()
        return B()

class A:
    def __init__(self):
        print("A 初始化")

class B:
    def __init__(self):
        print("B 初始化")

Factory("a")返回的是A实例,Factory.__init__不会被调用。因为__new__返回的不是Factory的实例,Python认为“创建的不是这个类”,跳过__init__。

这个行为在工厂模式里是特性,在普通类里是坑。如果你重写了__new__并返回了其他类型的对象,要清楚__init__不会执行。

坑六:继承不可变类型时只重写 init

class MyTuple(tuple):
    def __init__(self, iterable):
        super().__init__(iterable)  # 没用

tuple的__init__是object.__init__,它什么都不做。tuple的值在__new__里就已经确定了。重写__init__不会改变元组的内容。

正确写法:

class MyTuple(tuple):
    def __new__(cls, iterable):
        return super().__new__(cls, iterable)

str、int、float、frozenset这些不可变类型,子类化时都必须重写__new__,因为它们的值在创建时确定,__init__阶段已经无法修改。

那 new 和 init 的调用顺序能改变吗?

不能。Python的构造流程是固定的:

  1. 调用__new__(cls, *args, **kwargs),得到实例。
  2. 如果实例是cls的实例,调用__init__(instance, *args, **kwargs)。
  3. 返回实例。

__new__永远在__init__之前。__init__是否执行,取决于__new__返回了什么。这个顺序是解释器层面的,不能改。

什么时候用 new,什么时候用 init?

判断标准:

需要控制“对象是否被创建”“创建哪个对象”“创建多少个对象” :用__new__。单例、对象池、工厂、缓存,都属于这一类。

需要子类化不可变类型(int、str、tuple、frozenset):用__new__。值必须在创建时确定。

需要在对象创建之前做校验,校验失败就不创建:用__new__。在__init__里校验,对象已经创建了,校验失败只是初始化中断,对象本身已经存在。

只是设置实例属性、做常规初始化:用__init__。这是绝大多数类的标准做法。

需要访问实例属性、调用实例方法:用__init__。__new__执行时实例还没初始化,访问属性可能拿到不存在的东西。

不确定:用__init__。它是默认的、最常用的构造入口。只有当你需要控制“创建”本身时,才考虑__new__。

一个容易忽略的细节:new 是静态方法,但自动传 cls

__new__在定义时不需要@staticmethod装饰器,但它的行为类似静态方法:Python会自动把cls作为第一个参数传进去。

class Demo:
    def __new__(cls):
        print(f"cls 是: {cls}")
        return super().__new__(cls)

Demo()调用时,cls自动是Demo。你不需要手动传,也不能通过实例调用__new__(__new__是类级别的,实例调用它没有意义)。

回到小许的故事

小许最终的代码是这样的:

class Database:
    _instance = None

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

    def __init__(self):
        # 单例下 __init__ 每次都会执行,所以这里不放创建逻辑
        # 需要重复执行的初始化可以放这里,但连接创建已经移到 __new__
        pass

单例由__new__保证,连接只创建一次。__init__每次调用都会执行,但它不再负责“创建”,只负责“每次拿到实例时需要做的配置”。

他后来在团队文档里写了一条:“__new__负责创建对象,返回实例;__init__负责初始化对象,返回None。单例、对象池、不可变类型子类化,用__new__。常规属性设置,用__init__。__new__返回的不是当前类实例时,__init__不会执行。__new__忘了return,构造结果是None。__init__返回非None会报TypeError。”

__new__和__init__的区别,本质上是“创建”和“初始化”的区别。__new__决定“有没有这个对象、是哪个对象”,__init__决定“这个对象长什么样”。用错了不会总是报错,但会在单例、继承、不可变类型这些场景下悄悄失效。

记住那个盖房子的比喻:__new__是盖房子,__init__是装修。你要控制“盖不盖、盖几栋、盖成什么户型”,得在__new__里做;你要控制“里面放什么家具”,在__init__里做。房子已经盖好了,你再怎么改装修,也改变不了“已经有两栋房子”这个事实。