一、核心意义与机制
1.1 构造过程原理
1.2 与 __init__ 对比
| 特性 | __new__ | __init__ |
|---|---|---|
| 方法类型 | 静态方法 | 实例方法 |
| 返回值 | 必须返回实例对象 | 无返回值 |
| 调用时机 | 创建实例时首先调用 | 在 __new__ 之后调用 |
| 主要职责 | 控制实例创建过程 | 初始化实例属性 |
二、核心功能解析
2.1 核心能力
- 控制实例创建过程
- 决定是否生成新实例
- 修改实例创建逻辑
- 实现设计模式底层支持
2.2 方法签名
元类中的 __new__ 参数（示例 4.1）
- 样例
|
1 2 3 4 |
class Meta(type): def __new__(mcs, name, bases, attrs): # 参数列表固定 return super().__new__(mcs, name, bases, attrs) |
- 参数解析表
| 参数名 | 类型 | 说明 |
|---|---|---|
| mcs | type | 元类自身（约定命名，类似 cls 代表类） |
| name | str | 要创建的类名（如 "MyClass"） |
| bases | tuple | 基类列表（继承的父类） |
| attrs | dict | 类属性字典（包含方法、类变量等） |
调用逻辑
- 元类用于??创建类对象??（不是实例对象）
- 参数由解释器在定义类时自动传入
- super().__new__ 最终调用 type.__new__ 生成类对象
不可变类型子类的 __new__（示例 3.2）
样例
|
1 2 3 |
class ImmutableStr(str): def __new__(cls, value): return super().__new__(cls, processed_value) |
- 参数解析表
| 参数名 | 类型 | 说明 |
|---|---|---|
| cls | type | 当前类对象（ImmutableStr） |
| value | Any | 用户自定义参数（初始化输入值） |
调用逻辑
- 继承自不可变类型（str/int/tuple 等）
- 必须通过 __new__ 完成实例创建
- super().__new__ 调用父类（str）的构造方法
- 参数需匹配父类 __new__ 的要求（如 str 需要传入初始化字符串）
可变类型普通类的 __new__（示例 3.1）
样例
|
1 2 3 |
class Singleton: def __new__(cls, *args, ?**?kwargs): return super().__new__(cls) |
- 参数解析表
| 参数名 | 类型 | 说明 |
|---|---|---|
| cls | ` | 当前类对象（Singleton） |
| *args | tuple | 位置参数（与 __init__ 共享参数） |
| ?**?kwargs | dict | 关键字参数（与 __init__ 共享参数） |
调用逻辑
- 普通类的实例创建流程
- super().__new__ 调用 object.__new__ 生成实例
- 参数需与 __init__ 方法兼容
2.3 参数传递关系图示
2.4 核心记忆要点
??元类 __new__ 的四个参数是固定结构??
- 用于构建类对象（类的模板）
- 参数由解释器自动填充
??普通类 __new__ 第一个参数必为 cls??
- 后续参数需与 __init__ 匹配
- 不可变类型需要完全重写参数列表
??super().__new__ 的参数必须与父类一致??
- 元类中：super().__new__(mcs, name, bases, attrs)
- 普通类中：super().__new__(cls[, ...])
三、典型应用场景
3.1 单例模式实现
|
1 2 3 4 5 6 7 8 9 10 11 |
class Singleton: _instance = None
def __new__(cls, *args, ?**?kwargs): if not cls._instance: cls._instance = super().__new__(cls) return cls._instance
a = Singleton() b = Singleton() print(a is b) # True |
3.2 不可变类型扩展
|
1 2 3 4 5 6 7 8 |
class ImmutableStr(str): def __new__(cls, value): # 预处理字符串 processed = value.strip().upper() return super().__new__(cls, processed)
s = ImmutableStr(" hello ") print(s) # "HELLO" |
3.3 对象池技术
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
class ConnectionPool: _pool = [] _max_size = 5
def __new__(cls): if len(cls._pool) < cls._max_size: obj = super().__new__(cls) cls._pool.append(obj) return obj return cls._pool.pop(0)
conn1 = ConnectionPool() conn2 = ConnectionPool() |
四、高级应用技巧
4.1 元类协作
|
1 2 3 4 5 6 7 8 9 10 |
class Meta(type): def __new__(mcs, name, bases, attrs): # 添加类属性 attrs['version'] = 1.0 return super().__new__(mcs, name, bases, attrs)
class MyClass(metaclass=Meta): pass
print(MyClass.version) # 1.0 |
4.2 参数预处理
|
1 2 3 4 5 6 7 8 |
class SmartTuple(tuple): def __new__(cls, iterable): # 过滤非数字元素 filtered = (x for x in iterable if isinstance(x, (int, float))) return super().__new__(cls, filtered)
t = SmartTuple([1, 'a', 3.14, None]) print(t) # (1, 3.14) |
五、继承体系中的使用
5.1 继承链处理
|
1 2 3 4 5 6 7 8 9 |
class Base: def __new__(cls, *args, ?**?kwargs): print(f"Creating {cls.__name__}") return super().__new__(cls)
class Child(Base): pass
c = Child() # 输出 "Creating Child" |
5.2 多继承处理
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
class A: def __new__(cls, *args, ?**?kwargs): print("A's __new__") return super().__new__(cls)
class B: def __new__(cls, *args, ?**?kwargs): print("B's __new__") return super().__new__(cls)
class C(A, B): def __new__(cls, *args, ?**?kwargs): return A.__new__(cls)
obj = C() # 输出 "A's __new__" |
六、注意事项与调试
6.1 常见错误
|
1 2 3 4 5 6 7 8 9 |
class ErrorCase: def __new__(cls): # 错误：忘记返回实例 print("Creating instance") # ? 无返回值
def __init__(self): print("Initializing")
e = ErrorCase() # TypeError |
6.2 调试技巧
|
1 2 3 4 5 6 7 8 9 10 11 |
class DebugClass: def __new__(cls, *args, ?**?kwargs): print(f"__new__ args: {args}") instance = super().__new__(cls) print(f"Instance ID: {id(instance)}") return instance
def __init__(self, value): print(f"__init__ value: {value}")
d = DebugClass(42) |
七、性能优化建议
7.1 对象缓存策略
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class ExpensiveObject: _cache = {}
def __new__(cls, config): key = hash(frozenset(config.items())) if key not in cls._cache: instance = super().__new__(cls) instance._init(config) cls._cache[key] = instance return cls._cache[key]
def __init__(self, config): # 避免重复初始化 self.config = config |
最佳实践总结??
- 优先使用 super().__new__ 保证继承链正常
- 修改不可变类型必须使用 __new__
- 单例模式要处理好线程安全问题
- 避免在 __new__ 中做耗时操作
