小许那天想实现一个单例模式。
他的需求很明确:一个数据库连接类,整个程序里只允许存在一个实例,所有地方共用同一个连接。他的思路是,在初始化的时候检查一下“是不是已经创建过了”,如果创建过,就复用原来的。
代码大概长这样:
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的构造流程是固定的:
- 调用
__new__(cls, *args, **kwargs),得到实例。 - 如果实例是
cls的实例,调用__init__(instance, *args, **kwargs)。 - 返回实例。
__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__里做。房子已经盖好了,你再怎么改装修,也改变不了“已经有两栋房子”这个事实。