好的，各位观众，欢迎来到今天的“Python冷知识热炒”讲座！今天我们要聊的是一个听起来高深莫测，但实际上非常有用的小技巧：Python 中的 __new__ 方法。
__new__：对象的“出生证明”签发员
我们都知道，在 Python 中创建一个对象，一般都是用 类名() 这样的方式。比如：
class Dog:
def __init__(self, name):
self.name = name
my_dog = Dog("旺财")
print(my_dog.name) # 输出：旺财这里，Dog("旺财") 这行代码实际上做了两件事：
- 创建对象： 在内存中开辟一块空间，用来存放
Dog对象的各种属性。 - 初始化对象： 调用
__init__方法，给对象设置初始值，比如这里的name属性。
但问题来了，谁负责创建对象呢？__init__ 只是负责给对象“装修”而已，真正负责“盖房子”的是谁？答案就是：__new__。
可以把 __new__ 想象成一个“出生证明”签发员。只有它签发了“出生证明”，对象才能被创建出来。而 __init__ 只是在对象“出生”之后，给它穿衣服、喂奶粉之类的。
__new__ 的基本用法：
__new__ 是一个静态方法（staticmethod），它的第一个参数是类本身（通常命名为 cls），剩下的参数会原封不动地传递给 __init__ 方法。它的职责是：
- 创建对象： 调用父类的
__new__方法来创建一个对象。 - 返回对象： 必须返回创建好的对象。
一个最简单的 __new__ 方法看起来是这样的：
class MyClass:
def __new__(cls, *args, **kwargs):
# 调用父类的 __new__ 方法来创建对象
instance = super().__new__(cls)
return instance
def __init__(self, value):
self.value = value
obj = MyClass(10)
print(obj.value) # 输出：10在这个例子中，MyClass 的 __new__ 方法只是简单地调用了父类（通常是 object）的 __new__ 方法来创建对象，然后原封不动地返回。
为什么要用 __new__？
你可能会觉得，__new__ 看起来有点多余，直接用 __init__ 不行吗？答案是：有些情况下，__init__ 搞不定，必须靠 __new__ 出马。
以下是一些常见的应用场景：
- 控制对象的创建： 比如实现单例模式、对象池等。
- 创建不可变对象： 对于一些不可变对象（比如元组），需要在创建时就确定其值，
__init__无法胜任。 - 子类化不可变类型： 如果想继承
str、int、tuple这样的不可变类型，__new__是必不可少的。
实战演练：__new__ 的各种骚操作
接下来，我们通过几个例子来展示 __new__ 的强大之处。
1. 单例模式：保证只有一个实例
单例模式是一种常用的设计模式，它保证一个类只有一个实例，并提供一个全局访问点。我们可以用 __new__ 来实现单例模式：
class Singleton:
_instance = None # 类变量，用于保存唯一的实例
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
def __init__(self, value):
if not hasattr(self, 'value'): # 避免多次初始化
self.value = value
# 创建两个实例
instance1 = Singleton(10)
instance2 = Singleton(20)
print(instance1 is instance2) # 输出：True，说明是同一个对象
print(instance1.value) # 输出：10，说明初始化只执行了一次
print(instance2.value) # 输出: 10在这个例子中，Singleton 类使用 _instance 类变量来保存唯一的实例。在 __new__ 方法中，首先判断 _instance 是否为 None，如果是，则创建一个新的实例并保存到 _instance 中；否则，直接返回 _instance。这样，无论创建多少个 Singleton 对象，实际上都指向同一个实例。
注意点： __init__ 方法需要判断 value 是否已经存在，防止重复初始化。
2. 对象池：减少对象创建的开销
对象池是一种优化技术，它预先创建一些对象并保存在一个池子中，当需要使用对象时，直接从池子中获取，而不是每次都创建新的对象。这样可以减少对象创建的开销，提高性能。
class ReusableObject:
def __init__(self, id):
self.id = id
print(f"Object {id} created.")
class ObjectPool:
_pool = []
_max_size = 5
def __new__(cls, *args, **kwargs):
if cls._pool:
print("Reusing existing object.")
return cls._pool.pop(0) # 从池中取出一个对象
else:
if len(cls._pool) < cls._max_size:
instance = super().__new__(cls)
cls._pool.append(instance) # 将新对象添加到池中
return instance
else:
print("Maximum pool size reached.")
return None
def __init__(self, id):
if not hasattr(self, 'id'):
self.id = id
print(f"Object {id} initialized.")
def release(self):
ObjectPool._pool.append(self)
print(f"Object {self.id} released to pool.")
# 使用对象池
obj1 = ObjectPool(1) # 创建一个新对象
obj2 = ObjectPool(2) # 创建一个新对象
obj3 = ObjectPool(3)
obj4 = ObjectPool(4)
obj5 = ObjectPool(5)
obj6 = ObjectPool(6) # max size reached
obj1.release()
obj7 = ObjectPool(7) # reusing
print(obj1 is obj7) # true
print(ObjectPool._pool)在这个例子中，ObjectPool 类维护一个对象池 _pool，并在 __new__ 方法中判断池中是否有可用的对象。如果有，则直接从池中返回；否则，创建一个新的对象并添加到池中。
3. 创建不可变对象
Python 中的元组（tuple）是不可变对象，这意味着一旦创建，就不能修改其元素。我们可以用 __new__ 来创建一个类似的不可变对象：
class ImmutablePoint:
def __new__(cls, x, y):
# 创建一个元组来保存坐标
instance = tuple.__new__(cls, (x, y))
return instance
def __init__(self, x, y):
# 初始化对象，但实际上什么也不做，因为对象已经不可变了
pass # 必须要有 init
@property
def x(self):
return self[0]
@property
def y(self):
return self[1]
point = ImmutablePoint(10, 20)
print(point.x) # 输出：10
print(point.y) # 输出：20
# point[0] = 30 # 报错：'ImmutablePoint' object does not support item assignment在这个例子中，ImmutablePoint 类继承自 tuple，并在 __new__ 方法中调用 tuple.__new__ 来创建一个元组。由于元组是不可变的，所以 __init__ 方法实际上什么也不做。我们通过 property 装饰器来定义 x 和 y 属性，方便访问坐标值。
4. 子类化不可变类型
如果想继承 str、int、tuple 这样的不可变类型，__new__ 是必不可少的。比如，我们想创建一个自定义的字符串类型，可以实现一些额外的功能：
class MyString(str):
def __new__(cls, value):
# 在创建字符串之前，可以对值进行一些处理
value = value.upper() # 转换为大写
instance = super().__new__(cls, value)
return instance
def __init__(self, value):
# 初始化方法，但实际上什么也不做
pass
def reverse(self):
return self[::-1]
my_string = MyString("hello")
print(my_string) # 输出：HELLO
print(my_string.reverse()) # 输出：OLLEH在这个例子中，MyString 类继承自 str，并在 __new__ 方法中将字符串转换为大写。reverse 方法是自定义的，用于反转字符串。
__new__ 和 __init__ 的区别：
| 特性 | __new__ |
__init__ |
|---|---|---|
| 作用 | 创建对象 | 初始化对象 |
| 调用时机 | 在对象创建之前调用 | 在对象创建之后调用 |
| 返回值 | 必须返回创建好的对象 | 无返回值（或者返回 None） |
| 第一个参数 | 类本身 (cls) |
对象实例 (self) |
| 静态方法 | 是 | 不是 |
| 常用场景 | 控制对象创建、创建不可变对象、子类化不可变类型 | 设置对象属性的初始值 |
注意事项：
__new__必须返回一个对象实例，否则__init__方法不会被调用。- 如果
__new__方法没有调用父类的__new__方法来创建对象，那么实际上相当于阻止了对象的创建。 __new__是一个静态方法，所以不能访问实例属性。
总结：
__new__ 方法是 Python 中一个强大的工具，可以用来控制对象的创建过程。虽然它不如 __init__ 常用，但在某些特定的场景下，却是必不可少的。掌握 __new__ 方法，可以让你更加灵活地控制对象的行为，编写出更加优雅和高效的代码。
希望今天的讲座对大家有所帮助！下次再见！