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

简介: 本文通过小许实现单例模式的踩坑经历,深入剖析Python中`__new__`与`__init__`的本质区别:`__new__`负责“创建对象”(分配内存、返回实例),`__init__`仅负责“初始化已存在对象”。单例、不可变类型子类化等必须用`__new__`控制。

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

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

代码大概长这样:

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,为什么还是创建了两个对象?”

代理 IP 使用小技巧 让你的数据抓取效率翻倍 (29).png

同事看了一眼说:“__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__里做。房子已经盖好了,你再怎么改装修,也改变不了“已经有两栋房子”这个事实。

目录
相关文章
|
6天前
|
Linux Go 开发工具
手机上跑 DeepSeek 智能体:开源安卓客户端 DSH Go 安装与使用指南
DSH Go 是一款开源安卓客户端,将 DeepSeek Harness 智能体引擎装进手机:免 Root、免 Termux,一键安装即用;支持本机运行(内置 Ubuntu+Node.js)或远程接管电脑会话;具备插话打断、过程折叠、屏幕操控、端到端加密分享等特色功能,真正实现智能体“口袋化”。
7201 17
|
6天前
|
弹性计算 人工智能 API
Codex超详细入门指南(下载·安装·登录·上手,全版本覆盖,2026最新版)
建议收藏本教程,2026 全年各版本更新随时回来查阅。如果你在搭建过程中遇到任何问题,欢迎结合 阿里云工单系统 提交技术支持请求,或在 阿里云开发者社区 搜索 Codex 相关话题交流。 祝你编码愉快,效率翻倍!
2385 10
|
8天前
|
人工智能 前端开发 API
阿里云Qwen4-Max 大模型详解:定位、特征、能力、适用场景与相对Qwen3-Max差异解析
2026年11月11日,阿里发布第四代旗舰模型Qwen4-Max预览版,首发千问AI平台Token Plan并接入千问办公、Qoder等入口。该版本聚焦知识理解、世界感知、编程与Agentic四项升级,主打复杂编程、专业办公、前端设计与专业软件操作等真实任务。预览期为11月11日10:00至11月25日24:00,仅支持Token Plan调用,到期后模型标识下线;限时2折、新用户再享5折,最低1折可体验。
|
8天前
|
JSON 前端开发 API
阿里云最新Qwen4-Max大模型介绍:模型定位、特征、能力、适用场景解析
2026 年 11 月 11 日,阿里发布第四代旗舰模型Qwen4-Max预览版,首发千问 AI 平台 Token Plan,并同步接入千问办公、Qoder 等入口。该版本聚焦知识理解、世界感知、编程与 Agentic 四项升级,主打复杂编程、专业办公、前端设计与专业软件操作。预览期至 11 月 25 日 24:00,到期后模型标识下线;限时 2 折、新用户再享 5 折,最低 1 折可体验。
|
4天前
|
传感器 安全 区块链
Windows 电脑运行安卓应用教程:开源工具 ApkStart 双击 APK 即装、独立窗口运行
ApkStart 是一款开源Windows工具,让安卓APP像原生软件一样运行:双击APK即安装、生成真实图标、独立窗口启动、开始菜单可搜索。无需传统模拟器,内置QEMU运行时,支持数据互通、ARM兼容与命令行操作。(239字)
|
21天前
|
Linux 开发工具 iOS开发
Codex保姆级教程(下载+安装+登录+使用,含所有版本,2026最新)
Codex是OpenAI推出的开源AI编程智能体,本地运行,可理解整个代码库,支持自然语言指令改代码、执行命令、跑测试、修Bug,兼容Win/macOS/Linux。(239字)
10323 59
|
4天前
|
人工智能 弹性计算 开发工具
零成本玩各大模型!DeepSeek Harness dsh-our-free-model 插件,13 个厂商模型直接用
总结一下:装这个插件,你不用注册、不用绑卡、不用填一个 Key,就能在 DeepSeek Harness 里用上 DeepSeek V4.1 Flash、Kimi K3 这一批前沿模型,而且是白嫖的、还不限量。三步搞定:下载插件,复制包含 `package.json` 的插件目录路径,在「添加插件」里粘贴路径安装并重启。无论是在阿里云 ECS 上通过命令行部署的 Web 版,还是本地的 Electron 桌面端,都能顺利跑通,快速搭建一套零成本的免费模型使用环境。
1075 1
|
7天前
|
Linux API iOS开发
【DSH】DeepSeek Harness新手保姆教程(下载+安装+配置+使用,2026最新实测)
DeepSeek Harness(dsh)是DeepSeek AI开源的智能体框架,秉持“一切皆插件”理念,支持读文件、改代码、跑命令、处理表格、联网搜索等操作。免费开源,兼容Windows/macOS/Linux,提供桌面端与网页端,可灵活安装插件扩展能力。
|
16天前
|
Linux 开发工具 iOS开发
2026最新codex下载安装保姆级使用教程(下载+安装+登录+使用,含所有历史版本)
本文详解OpenAI Codex国内快速上手指南:提供Win/macOS/Linux全平台免安装包、npm/Homebrew等多方式安装、账号/API Key双登录、简体中文切换,覆盖下载、安装、汉化、使用及高频避坑(如微软商店失败、npm超时等),10分钟即可跑通。
3530 9