1. 项目概述：从“造房子”到“装修房子”的哲学

在Python的世界里，创建一个对象，就像是在现实世界中建造并装修一栋房子。很多开发者，尤其是从其他语言（比如Java或C++）转过来的朋友，会习惯性地认为__init__就是那个负责“建造”房子的构造函数。但如果你也这么想，那可能就错过了Python对象模型中最精妙、也最容易被误解的一部分。实际上，__init__更像是一位室内设计师，负责在房子建好之后，把家具搬进去、把墙刷上颜色；而真正负责“打地基、砌砖墙”的建造师，是另一个低调但至关重要的方法：__new__。

我最初接触这两个方法时也犯过迷糊，直到在一个需要实现单例模式的项目里踩了坑。当时我试图在__init__里控制实例的唯一性，结果发现每次MyClass()调用，__init__都会被重新执行，单例根本做不成。后来才明白，实例的“出生”控制权在__new__手里。这个认知上的转变，让我对Python的底层机制有了更深的理解。今天，我们就来彻底拆解这对“黄金搭档”，弄明白__new__和__init__各自的分工、协作时机，以及如何利用它们玩出一些高级花样。无论你是想深入理解Python面向对象编程的基石，还是为了解决某些特定的设计难题（比如不可变对象、元类编程、对象池），搞懂它们都至关重要。

2. 核心概念拆解：建造师与装修师的分工

要理解__new__和__init__，我们必须先抛开“构造函数”这个来自其他语言的固有印象。在Python中，对象的完整诞生过程分为两步：创建（Creation）和初始化（Initialization）。这是两个截然不同的阶段。

2.1__new__：沉默的建造师

__new__是一个静态方法（虽然你用不着@staticmethod装饰器），它的职责是创建并返回一个新的类实例。它是整个对象生命周期中第一个被调用的方法，甚至早于__init__。你可以把它想象成工厂里的模具，负责把原材料（内存空间）塑造成一个具有基本形态的产品（实例）。

它的方法签名通常是这样的：

def __new__(cls, *args, **kwargs):

• cls： 代表当前正在被实例化的类。注意，是类本身，不是实例。
• *args, **kwargs： 这些参数会原封不动地从实例化调用（如MyClass(arg1, arg2)）传递给__new__，然后再传递给__init__。

__new__必须返回一个对象。通常，它会调用其父类的__new__方法来分配内存和创建基础实例对象，最常用的就是object.__new__(cls)。如果__new__返回的不是cls的实例，那么后续的__init__方法将不会被调用。这是控制对象创建行为的一个关键钩子。

注意：__new__是类方法，但Python通过特殊方式处理，使其不需要显式装饰。你几乎总是需要调用父类的__new__，通常是object.__new__()，来执行实际的内存分配。

2.2__init__：活跃的装修师

__init__是一个实例方法，它的职责是初始化新创建好的实例。它接收__new__创建出来的那个“毛坯房”实例，并对其进行装修——设置初始属性、建立内部状态等。

它的方法签名是这样的：

def __init__(self, *args, **kwargs):

• self： 这就是__new__方法创建并返回的那个实例对象。__init__的工作就是操作这个self。
• *args, **kwargs： 和__new__接收到的参数序列一致（前提是__new__如实地传递了它们）。

__init__不应该返回任何值（或者说，应该返回None）。它的作用纯粹是副作用——修改self。如果它返回了非None的值，Python会抛出TypeError。

2.3 执行顺序与协作流程

当你写下obj = MyClass(x, y)这行代码时，幕后发生了以下事情：

1. 调用MyClass.__new__(MyClass, x, y)：Python解释器首先找到MyClass的__new__方法。如果MyClass没有定义，会沿着继承链向上找，最终找到object.__new__。这个方法分配内存，创建一个“原始”的MyClass类型实例，我们暂时叫它raw_obj。
2. 检查返回值：如果__new__返回的raw_obj确实是MyClass（或其子类）的一个实例，那么进入步骤3。否则，流程结束，obj就是__new__返回的那个东西（可能根本不是MyClass的实例）。
3. 调用MyClass.__init__(raw_obj, x, y)：此时，raw_obj被传递给__init__作为self参数。__init__方法对self进行各种属性赋值等初始化操作。
4. 赋值：最终，这个被初始化后的对象被赋值给变量obj。

用一个简单的代码片段可以验证这个顺序：

class Demo: def __new__(cls, *args, **kwargs): print(f“__new__ called with args: {args}”) # 必须调用父类的__new__来创建实例 instance = super().__new__(cls) print(f“Instance created: {instance}”) return instance def __init__(self, value): print(f“__init__ called with self: {self}, value: {value}”) self.value = value # 执行 obj = Demo(42) # 输出： # __new__ called with args: (42,) # Instance created: <__main__.Demo object at 0x...> # __init__ called with self: <__main__.Demo object at 0x...>, value: 42

可以看到，__new__先执行并创建了实例，然后这个实例才被传递给__init__。

3.__new__的进阶应用场景

理解了基本分工后，你会发现__new__绝不仅仅是个“幕后工作者”。在某些高级场景下，它才是主角。下面我们来看几个必须动用__new__才能优雅解决的经典问题。

3.1 实现不可变对象（如自定义元组、字符串）

Python内置的不可变类型（int,str,tuple,frozenset等）之所以不可变，部分原因就在于它们在__new__阶段就完成了所有状态的设置，而__init__对于这些类型常常是个空操作（或者根本不定义）。如果你想自定义一个不可变类，就需要在__new__中完成所有工作。

示例：实现一个简单的不可变点（Point）类

class ImmutablePoint: “”“一个不可变的二维点”“” __slots__ = (‘_x‘, ‘_y‘) # 使用__slots__禁止动态添加属性，增强不可变性 def __new__(cls, x, y): # 在创建实例前，可以进行参数验证等操作 if not isinstance(x, (int, float)) or not isinstance(y, (int, float)): raise TypeError(‘Coordinates must be numbers‘) # 创建实例 instance = super().__new__(cls) # ！！！关键步骤：在__new__中直接设置属性。 # 因为属性是存储在实例的__dict__中，而我们在__new__里已经拿到了实例引用。 # 对于使用__slots__的类，我们需要直接给对应的slot赋值。 # 这里我们通过直接操作对象内部来实现（注意：这需要一点技巧，通常不推荐直接操作，但不可变对象是特例）。 # 更安全通用的做法是使用基类object的__setattr__？不，在__new__里也不行。 # 实际上，对于真正严格的不可变，我们常常继承tuple。 # 让我们换一种更‘Pythonic‘的实现方式：继承namedtuple。 # 但为了演示__new__，我们采用一个替代方案： object.__setattr__(instance, ‘_x‘, x) object.__setattr__(instance, ‘_y‘, y) return instance @property def x(self): return self._x @property def y(self): return self._y def __repr__(self): return f“ImmutablePoint({self.x}, {self.y})” # 尝试修改属性会失败 p = ImmutablePoint(3, 4) print(p.x, p.y) # 3, 4 # p.x = 10 # AttributeError: can‘t set attribute

实操心得：实现真正的不可变类比想象中复杂。上面的例子使用了__slots__和直接调用object.__setattr__来绕过实例的常规属性设置机制。但在生产环境中，更常见的做法是继承collections.namedtuple或typing.NamedTuple，它们内部已经完美处理了不可变逻辑，代码更简洁安全。自己用__new__实现主要用于理解原理或处理非常特殊的定制需求。

3.2 实现单例模式

单例模式确保一个类只有一个实例。由于__new__控制着实例的创建，它是实现单例的天然位置。

示例：线程安全的单例基类

import threading class Singleton: “”“一个线程安全的单例基类。子类继承即可获得单例特性。”“” _instance = None _lock = threading.Lock() def __new__(cls, *args, **kwargs): # 双重检查锁模式，兼顾性能和线程安全 if cls._instance is None: with cls._lock: if cls._instance is None: # 注意：这里调用的是 object.__new__(cls)，因为Singleton可能就是基类。 # 如果Singleton作为基类，子类调用super().__new__会递归回到这里。 # 所以我们需要绕过自身的__new__，直接调用object.__new__。 cls._instance = object.__new__(cls) # 可选：初始化单例实例。注意，__init__可能被多次调用，需要防范。 return cls._instance def __init__(self, *args, **kwargs): # ！！！警告：对于单例，__init__可能会被多次调用（每次实例化语法都会触发）。 # 因此，我们需要一个标志来确保初始化只执行一次。 if not hasattr(self, ‘_initialized‘): # 执行真正的初始化逻辑 self._initialized = True # ... 其他初始化代码 ... class MyConfig(Singleton): def __init__(self, config_file=None): # 调用父类的__init__，它会处理“只初始化一次”的逻辑 super().__init__() # 只有当第一次初始化时，才执行下面的代码 if hasattr(self, ‘_config_loaded‘): return self.config = {} if config_file: self.load_config(config_file) self._config_loaded = True def load_config(self, file): # 模拟加载配置 self.config[‘file‘] = file # 测试 config1 = MyConfig(“app.json“) config2 = MyConfig(“other.json“) # 这次传入的参数会被忽略，因为实例已经存在 print(config1 is config2) # True print(config1.config) # {‘file‘: ‘app.json‘}

注意事项：单例模式的一个经典陷阱就是__init__的重复调用。因为每次使用MyClass()语法，__init__都会被触发。我们的解决方案是在实例上设置一个标志（如_initialized），确保核心初始化代码只跑一次。此外，继承单例基类时要小心，如果子类重写了__new__且逻辑不当，可能会破坏单例。

3.3 充当对象工厂或返回其他类的实例

__new__可以返回任意对象，不一定是cls的实例。这使它能够作为一个轻量级的工厂方法使用。

示例：根据参数返回不同的子类实例

class Shape: def __new__(cls, shape_type, *args, **kwargs): if shape_type == “circle“: return super().__new__(Circle) elif shape_type == “rectangle“: return super().__new__(Rectangle) else: raise ValueError(f“Unknown shape type: {shape_type}“) # Shape类本身可能只是一个接口或抽象基类，不打算被直接实例化。 def area(self): raise NotImplementedError class Circle(Shape): def __init__(self, radius): self.radius = radius def area(self): return 3.14159 * self.radius ** 2 class Rectangle(Shape): def __init__(self, width, height): self.width = width self.height = height def area(self): return self.width * self.height # 使用统一的接口创建不同对象 circle = Shape(“circle“, 5) # 实际返回一个Circle实例 rect = Shape(“rectangle“, 4, 6) # 实际返回一个Rectangle实例 print(isinstance(circle, Circle)) # True print(isinstance(circle, Shape)) # True print(circle.area()) # 78.53975 print(rect.area()) # 24

这个例子中，Shape的__new__方法根据参数动态决定创建哪个子类的对象。这提供了极大的灵活性，但也要注意，由于返回的不是Shape本身的实例，Shape.__init__将不会被调用，初始化逻辑完全由子类的__init__负责。

4.__init__的细节与最佳实践

相比__new__的“魔法”，__init__更贴近日常开发。但用好它，也能避免很多坑。

4.1 初始化父类：super().__init__()的正确姿势

在继承体系中，确保父类的初始化逻辑被执行至关重要。这需要通过super()来调用。

class Base: def __init__(self, base_value): self.base_value = base_value print(“Base initialized“) class Derived(Base): def __init__(self, base_value, derived_value): # 必须显式调用父类的__init__ super().__init__(base_value) # Python 3 简洁语法 # 在Python 2中，需要写 super(Derived, self).__init__(base_value) self.derived_value = derived_value print(“Derived initialized“) obj = Derived(1, 2) print(obj.base_value, obj.derived_value) # 1, 2

关键点：

• 调用时机：通常先调用super().__init__()，再初始化子类特有的属性。这样能保证父类的基础设施先建立好。
• 参数传递：需要将父类__init__所需的参数传递过去。
• 多重继承：在复杂的菱形继承结构中，super()机制（遵循方法解析顺序MRO）能确保每个父类只被初始化一次，避免了传统直接调用ParentClass.__init__(self)可能导致的重复初始化问题。

4.2 处理可选参数与默认值

__init__是定义对象初始状态的入口，设计好参数非常重要。

class Connection: def __init__(self, host, port=8080, timeout=10.0, verbose=False): self.host = host self.port = port self.timeout = timeout self.verbose = verbose self._connected = False # 可以进行一些简单的参数验证 if not isinstance(port, int): raise TypeError(“port must be an integer“) if timeout <= 0: raise ValueError(“timeout must be positive“) def connect(self): # 模拟连接逻辑 if self.verbose: print(f“Connecting to {self.host}:{self.port}...“) self._connected = True

最佳实践：

1. 必选参数在前：如host。
2. 可选参数在后：并赋予合理的默认值。
3. 类型与有效性检查：在__init__开头进行，尽早失败（Fail Fast），避免对象处于部分初始化的无效状态。
4. 设置私有状态：像_connected这样的内部状态，通常在__init__中设置为初始值。

4.3 避免在__init__中执行复杂逻辑或I/O操作

__init__的目标是让对象达到一个有效的初始状态，而不是完成所有工作。避免在其中进行网络连接、文件读取、复杂计算等耗时或可能失败的操作。

不好的例子：

class UserData: def __init__(self, user_id): self.user_id = user_id # 在初始化时从数据库加载数据 self.data = self._load_from_database() # 可能失败，导致对象创建不完整 self.processed = self._heavy_computation(self.data) # 耗时 def _load_from_database(self): # 模拟数据库操作，可能抛出异常 if self.user_id < 0: raise DatabaseError(“Invalid user ID“) return {“name“: “Alice“, “age“: 30}

更好的设计：

class UserData: def __init__(self, user_id): self.user_id = user_id self.data = None # 初始化为None，表示未加载 self.processed = None def load(self): “”“显式加载数据”“” self.data = self._load_from_database() self.processed = self._process(self.data) def _load_from_database(self): # ... 数据库操作 ... pass # 使用 user = UserData(123) try: user.load() # 加载操作与初始化分离，错误处理更清晰 except DatabaseError as e: print(f“Failed to load data: {e}“) else: # 使用user.data pass

这种“延迟初始化”或“显式初始化”的模式，使得对象的创建变得轻量和快速，同时也将可能失败的操作隔离到单独的方法中，错误处理路径更清晰。

5.__new__与__init__的协同与陷阱

理解了各自的作用后，我们来看看它们如何配合，以及配合不好时会掉进哪些坑。

5.1 参数传递的桥梁

__new__接收到的*args, **kwargs会原样传递给__init__（前提是__new__返回了正确类型的实例）。这为在__new__中预处理参数提供了可能。

class ValidatedObject: def __new__(cls, name, value): # 在创建实例前，对参数进行预处理或验证 if not name or not isinstance(name, str): raise ValueError(“Invalid name“) # 可以修改参数后再传递 processed_name = name.strip().upper() # 创建实例 instance = super().__new__(cls) # 注意：__init__接收到的将是原始参数，除非我们做点手脚。 # 但通常，我们更希望__init__看到处理后的参数。 # 一种方法是将处理后的参数存储在类变量或临时位置，但更干净的做法是修改args。 # 然而，__new__的args是元组，不可变。我们可以选择在__init__中再处理一次， # 或者用一个包装器。这里演示一个技巧：将处理后的值附加到类上（非实例）。 # 但这并不优雅。更常见的模式是：验证在__new__，初始化用原始参数或新参数。 # 让我们换一种思路，在__new__里创建实例，但通过修改传入__init__的参数来实现。 # 实际上，我们无法改变传给__init__的args。所以，更好的架构是： # 要么所有验证和预处理都在__init__里做， # 要么使用类方法（工厂方法）来创建实例。 # 因此，对于简单的参数预处理，放在__init__里更直接。 # 这个例子主要展示__new__可以访问参数，但介入参数流需要谨慎设计。 return instance def __init__(self, name, value): # 这里收到的name还是原始的 self.name = name.strip().upper() # 所以在这里处理 self.value = value

这个例子想说明的是，虽然__new__能拿到参数，但想要改变传入__init__的参数流比较别扭。通常，参数验证和清洗的逻辑放在__init__开头就足够了。__new__更适合用于控制是否创建以及创建什么类型的实例这类更根本的问题。

5.2 当__new__不返回实例时

这是__new__最强大的特性之一，也是容易困惑的地方。如果__new__返回的不是当前类（cls）的实例，那么__init__会被完全跳过。

class AlternativeCreator: def __new__(cls, magic_number): if magic_number == 42: # 返回一个完全不同的对象，比如一个字符串 return “The Answer to Life, the Universe, and Everything“ else: # 正常创建实例 return super().__new__(cls) def __init__(self, magic_number): print(f“This will NOT print if magic_number is 42.“) self.number = magic_number obj1 = AlternativeCreator(10) print(type(obj1), obj1.number) # <class ‘__main__.AlternativeCreator‘> 10 obj2 = AlternativeCreator(42) print(type(obj2), obj2) # <class ‘str‘> The Answer to Life, the Universe, and Everything # 注意：obj2是一个字符串，不是AlternativeCreator的实例。__init__从未被调用。

这种机制可以用于实现缓存、对象池（返回已存在的对象）或像上面例子中的工厂，根据条件返回不同类型的对象。

5.3 元类中的__new__与普通类中__new__的区别

这是一个高级主题，但非常重要。元类（metaclass）是“类的类”，它控制类的创建行为。元类中的__new__和__init__作用于类本身，而不是类的实例。

• 元类的__new__(metacls, name, bases, attrs)： 负责创建类对象。attrs是一个包含类属性（方法、类变量等）的字典。你可以在这里修改、添加或删除类的属性。
• 元类的__init__(cls, name, bases, attrs)： 负责初始化创建好的类对象。此时类已经创建，你可以进行一些额外的设置。

而普通类中的__new__和__init__，如前所述，作用于类的实例。

示例：一个简单的元类，自动给方法名添加前缀

class PrefixMeta(type): def __new__(metacls, name, bases, attrs): # 遍历类的属性 new_attrs = {} for attr_name, attr_value in attrs.items(): if callable(attr_value) and not attr_name.startswith(‘__‘): # 是可调用的方法且不是特殊方法 new_name = ‘prefixed_‘ + attr_name new_attrs[new_name] = attr_value # 也可以选择保留原名 # new_attrs[attr_name] = attr_value else: new_attrs[attr_name] = attr_value # 调用type.__new__来创建类 return super().__new__(metacls, name, bases, new_attrs) class MyClass(metaclass=PrefixMeta): def my_method(self): return “hello“ value = 10 obj = MyClass() print(dir(obj)) # 你会看到 ‘prefixed_my_method‘ 而不是 ‘my_method‘ # print(obj.my_method()) # AttributeError print(obj.prefixed_my_method()) # hello print(MyClass.value) # 10

理解这两个层面的__new__/__init__是掌握Python元编程的关键。简单记：元类造类，类造实例。

6. 常见问题与排查技巧实录

在实际使用中，会遇到一些典型的问题。下面是我总结的一些“坑”和解决方法。

6.1__init__被多次调用

问题现象： 单例对象的属性被重复重置，或者日志显示初始化逻辑被执行了多次。

根本原因：

1. 单例模式实现有缺陷，每次实例化语法都触发了新的__init__调用。
2. 在继承链中，没有正确使用super()，导致某个父类的__init__被多次调用。

排查与解决：

• 对于单例：参考3.2节的实现，在__init__中使用_initialized标志位。
• 对于继承：确保使用super().__init__()，并且理解MRO。可以使用ClassName.__init__(self, ...)，但要小心菱形继承导致的重复调用。

# 一个错误的菱形继承示例 class A: def __init__(self): print(“A init“) self.a = 1 class B(A): def __init__(self): print(“B init“) A.__init__(self) # 直接调用父类 self.b = 2 class C(A): def __init__(self): print(“C init“) A.__init__(self) # 直接调用父类 self.c = 3 class D(B, C): def __init__(self): print(“D init“) B.__init__(self) C.__init__(self) self.d = 4 obj = D() # 输出： # D init # B init # A init # C init # A init <-- A被初始化了两次！ print(obj.a) # 1 (但被C.__init__覆盖了？实际上，最后一次A.__init__调用设置了self.a=1)

使用super()可以解决这个问题：

class A: def __init__(self): print(“A init“) self.a = 1 class B(A): def __init__(self): print(“B init“) super().__init__() # 使用super self.b = 2 class C(A): def __init__(self): print(“C init“) super().__init__() # 使用super self.c = 3 class D(B, C): def __init__(self): print(“D init“) super().__init__() # 使用super self.d = 4 obj = D() # 输出 (遵循MRO: D -> B -> C -> A): # D init # B init # C init # A init <-- A只初始化了一次！ print(obj.a, obj.b, obj.c, obj.d) # 1 2 3 4

6.2 子类化内置不可变类型时的__new__重写

当你继承int,str,tuple这类内置不可变类型时，你几乎总是需要重写__new__，而不是__init__。

错误示例：

class MyInt(int): def __init__(self, value, extra_info): super().__init__(value) self.extra_info = extra_info # 这行可能无效或出错 # 尝试使用 try: num = MyInt(10, “hello“) except TypeError as e: print(e) # int() takes at most 2 arguments (3 given)

正确做法：

class MyInt(int): def __new__(cls, value, extra_info): # 在__new__中创建基础int实例 obj = super().__new__(cls, value) # 为我们的子类添加额外属性。由于是不可变类型的基础部分已定， # 我们可以直接给对象赋值属性（Python允许）。 obj.extra_info = extra_info return obj num = MyInt(10, “hello“) print(num) # 10 print(num + 5) # 15 (仍然表现为一个int) print(num.extra_info) # hello

实操心得：继承内置不可变类型时，记住“数据在__new__中就已经定型了”。额外的属性可以在__new__中附加到返回的对象上。__init__对于许多内置不可变类型要么不被调用，要么参数签名不匹配。

6.3__init__中super()调用引发的无限递归

在多重继承的复杂场景下，错误地使用super()可能导致无限递归，但更常见的是AttributeError。

问题示例：

class Base: def __init__(self): self.base_attr = “base“ class MixinA: def __init__(self): super().__init__() # 意图调用下一个类的__init__ self.a_attr = “a“ class MixinB: def __init__(self): super().__init__() # 意图调用下一个类的__init__ self.b_attr = “b“ class Derived(MixinA, MixinB, Base): def __init__(self): super().__init__() self.derived_attr = “derived“ # 这实际上可以工作，因为MRO是: Derived -> MixinA -> MixinB -> Base -> object # 每个super().__init__()都会调用MRO中的下一个__init__。 obj = Derived() print(obj.base_attr, obj.a_attr, obj.b_attr, obj.derived_attr) # base a b derived

问题通常出现在某个Mixin没有正确考虑协作，或者继承顺序导致super()链断裂。确保每个需要参与协作的__init__都调用了super().__init__()，并且理解你设计的类的MRO（可以用ClassName.__mro__查看）。

6.4 调试技巧：追踪__new__和__init__的调用

当创建对象的行为不符合预期时，添加简单的打印语句是最快的调试方法。

class DebugClass: def __new__(cls, *args, **kwargs): print(f“[__new__] cls: {cls}, args: {args}, kwargs: {kwargs}“) instance = super().__new__(cls) print(f“[__new__] created instance: {id(instance)}“) return instance def __init__(self, *args, **kwargs): print(f“[__init__] self: {id(self)}, args: {args}, kwargs: {kwargs}“) self.args = args obj = DebugClass(1, 2, key=“value“)

通过观察输出顺序和参数，可以清晰看到对象创建和初始化的全过程，帮助定位是__new__没有返回正确实例，还是参数在传递过程中出了问题。

7. 性能考量与设计模式应用

7.1__new__vs 类方法工厂

我们看到了__new__可以实现工厂模式。那么，它和传统的类方法工厂（@classmethod）相比如何？

建议：对于大多数“替代构造函数”的场景，使用类方法工厂是更Pythonic、更清晰的选择。保留__new__用于那些真正需要介入底层对象创建机制的场合。

7.2 对象池与__new__

对象池通过重用已创建的对象来减少资源分配和垃圾回收的开销。__new__是实现对象池的理想位置。

class ConnectionPool: _pool = [] # 空闲连接池 _in_use = set() # 使用中的连接 _max_size = 5 def __new__(cls, *args, **kwargs): # 如果池中有空闲连接，则取出并返回 if cls._pool: print(“Reusing connection from pool.“) instance = cls._pool.pop() else: # 检查是否超过最大限制 if len(cls._in_use) >= cls._max_size: raise RuntimeError(“Connection pool exhausted“) # 创建新连接 print(“Creating new connection.“) instance = super().__new__(cls) cls._in_use.add(instance) return instance def __init__(self, host, port): # 如果是从池中取出的，可能已经初始化过 if hasattr(self, ‘initialized‘): # 可以在这里重置连接状态，而不是重新建立连接 print(f“Re-initializing connection to {host}:{port}“) self.host = host self.port = port # 假设有一个重置方法 self._reset() return # 首次初始化 self.host = host self.port = port self.initialized = True self._connect() # 模拟建立真实连接 print(f“New connection initialized to {host}:{port}“) def release(self): “”“将连接放回池中”“” ConnectionPool._in_use.remove(self) ConnectionPool._pool.append(self) print(“Connection released to pool.“) def _connect(self): # 模拟昂贵的连接建立 pass def _reset(self): # 模拟重置连接状态 pass # 使用 conn1 = ConnectionPool(“db1“, 3306) conn2 = ConnectionPool(“db2“, 3306) conn1.release() conn3 = ConnectionPool(“db3“, 3306) # 应该重用conn1 print(conn1 is conn3) # True

注意事项：对象池的实现需要仔细处理并发问题（上面的例子不是线程安全的），并且要管理好对象的状态重置。__init__需要能够处理“重新初始化”的情况，避免重复分配资源。

7.3 元类与__new__结合实现注册模式

元类的__new__可以在类创建时自动将其注册到某个中央仓库，常用于插件系统或ORM映射。

class PluginRegistry: plugins = {} class PluginMeta(type): def __new__(metacls, name, bases, attrs): # 创建类 cls = super().__new__(metacls, name, bases, attrs) # 如果不是基类（AbstractPlugin），则进行注册 if name != ‘AbstractPlugin‘ and ‘plugin_id‘ in attrs: plugin_id = attrs[‘plugin_id‘] if plugin_id in PluginRegistry.plugins: raise KeyError(f“Plugin ID ‘{plugin_id}‘ already registered.“) PluginRegistry.plugins[plugin_id] = cls print(f“Registered plugin: {plugin_id} -> {name}“) return cls class AbstractPlugin(metaclass=PluginMeta): plugin_id = None # 子类必须定义 def run(self): raise NotImplementedError class HelloPlugin(AbstractPlugin): plugin_id = “hello“ def run(self): return “Hello World!“ class GoodbyePlugin(AbstractPlugin): plugin_id = “goodbye“ def run(self): return “Goodbye!“ # 自动注册完成 print(PluginRegistry.plugins) # {‘hello‘: <class ‘__main__.HelloPlugin‘>, ‘goodbye‘: <class ‘__main__.GoodbyePlugin‘>} # 通过ID获取插件类并实例化 plugin_cls = PluginRegistry.plugins[‘hello‘] plugin_instance = plugin_cls() print(plugin_instance.run()) # Hello World!

这种模式将类的注册自动化，避免了手动维护注册列表，减少了出错的可能。元类的__new__在类定义被解释器读取时执行，是执行此类“类级别”操作的绝佳时机。

理解__new__和__init__，就像是掌握了Python对象从无到有的完整蓝图。__new__负责从无到有的“创造”，决定了对象的出生和本质；__init__负责从零到一的“塑造”，赋予了对象初始的状态和个性。在日常开发中，你可能90%的时间都在和__init__打交道，但当你需要实现单例、不可变对象、自定义对象创建流程或进行元编程时，__new__就是你手中那把关键的钥匙。记住它们的分工与协作，在合适的场景运用合适的方法，能让你的代码更加优雅和强大。