Python中new, init, del内容详解

wang sum yuen

437人浏览 · 2026-03-11 17:01:13

wang sum yuen · 2026-03-11 17:01:13 发布

Python中`new`, `init`, `del`内容详解

引言

在Python中，类的定义与实例化过程涉及几个特殊的魔术方法，它们控制着对象的创建、初始化和销毁。这些方法以双下划线开头和结尾（例如__new__、__init__、__del__），在特定时机由Python解释器自动调用。理解这些方法对于掌握Python的对象模型、内存管理以及编写健壮的代码至关重要。

本文将对这三个核心方法进行详尽剖析，涵盖其作用、调用顺序、参数、返回值、注意事项，并结合大量代码示例展示它们的实际应用。同时，我们还将探讨高级话题如元类、不可变类型、单例模式、资源管理等，帮助读者深入理解Python对象生命周期的全貌。

一、对象的生命周期概览

在Python中，每个对象从诞生到销毁都会经历几个阶段：

创建：分配内存空间，准备一个“空”的对象。
初始化：为对象的属性赋予初始值，设置内部状态。
使用：对象参与程序运行，方法被调用，属性被访问。
销毁：对象不再被引用，被垃圾回收器回收，释放占用的资源。

对应的三个特殊方法分别是：

__new__(cls, ...)：负责创建对象，返回一个新实例。
__init__(self, ...)：负责初始化对象，设置实例的初始状态。
__del__(self)：在对象被销毁前执行清理操作。

需要注意的是，__new__是静态方法（尽管不需要显式装饰），__init__是实例方法，__del__也是实例方法。它们的调用时机和功能各有侧重，接下来我们逐一深入。

二、`new` 方法详解

2.1 定义与基本作用

__new__是Python中用于控制对象创建的静态方法。它在对象实例化时第一个被调用，负责生成并返回该类的实例。其典型定义如下：

python

class MyClass:
    def __new__(cls, *args, **kwargs):
        # 创建并返回实例
        instance = super().__new__(cls)
        return instance

第一个参数cls是当前正在实例化的类。
*args, **kwargs接收传递给构造器的所有参数（即MyClass(...)中的参数），这些参数随后会被传递给__init__。
必须返回一个实例对象。通常通过调用父类的__new__方法来创建实例，但也可以返回其他类的实例或已存在的对象。
如果__new__没有返回实例（或返回了非当前类的实例），则__init__不会被调用。

2.2 `new` 与 `init` 的区别

特性	`__new__`	`__init__`
调用时机	最先调用	在`__new__`之后，如果返回了当前类的实例
方法类型	静态方法（隐含@staticmethod）	实例方法
第一个参数	`cls`（类）	`self`（实例）
返回值	必须返回一个实例对象	必须返回`None`（否则引发TypeError）
主要职责	控制实例创建	初始化实例属性

当执行obj = MyClass(*args, **kwargs)时，Python内部大致执行以下操作：

调用MyClass.__new__(MyClass, *args, **kwargs)。
如果__new__返回了一个MyClass的实例（记作instance），则自动调用instance.__init__(*args, **kwargs)（前提是instance是MyClass的实例且__init__未被覆盖为不调用）。
返回instance给调用者。

如果__new__返回的不是MyClass的实例，则__init__不会被执行。

2.3 使用场景与示例

2.3.1 不可变类型的子类化

Python内置的不可变类型（如int、str、tuple）在创建后不能修改。当我们继承这些类时，需要在对象创建之前就完成值的设置，因此必须重写__new__而不是__init__。

示例：带单位的整数子类

python

class Inch(int):
    def __new__(cls, value, unit=""):
        # int是不可变类型，必须在__new__中初始化
        instance = super().__new__(cls, value)
        instance.unit = unit
        return instance

    def __str__(self):
        return f"{int(self)}{self.unit}"

i = Inch(12, "英寸")
print(i)          # 输出: 12英寸
print(i + 5)      # 输出: 17 (int运算仍返回int，但注意+返回int)

注意：int的子类在算术运算中可能会返回普通int，这与__new__无关，是int的运算机制决定的。

2.3.2 单例模式

单例模式确保一个类只有一个实例。通过在__new__中控制实例的创建，可以实现该模式。

示例：线程安全的单例

python

class Singleton:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            with cls._lock:
                if not cls._instance:
                    cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self, value=None):
        # 注意：__init__每次实例化都会调用，需要避免重复初始化
        if not hasattr(self, '_initialized'):
            self.value = value
            self._initialized = True

# 测试
a = Singleton(10)
b = Singleton(20)
print(a is b)   # True
print(a.value)  # 10 (第一次初始化)
print(b.value)  # 10 (因为a和b是同一个对象，且第二次__init__未修改value)

这里我们使用了双重检查锁来保证线程安全。注意__init__在单例中可能会被多次调用，所以需要额外的标志防止重复初始化。

2.3.3 缓存/池化对象

类似享元模式，可以复用已创建的对象，避免重复分配内存。

示例：复用相同参数的对象

python

class Point:
    _cache = {}

    def __new__(cls, x, y):
        key = (x, y)
        if key not in cls._cache:
            print(f"创建新实例 ({x}, {y})")
            instance = super().__new__(cls)
            instance.x = x
            instance.y = y
            cls._cache[key] = instance
        return cls._cache[key]

    def __init__(self, x, y):
        # 因为可能复用对象，__init__可能被多次调用，所以需要小心处理
        # 这里我们假设每次都需要初始化，但缓存会阻止新创建
        pass

# 测试
p1 = Point(1, 2)   # 创建新实例 (1, 2)
p2 = Point(1, 2)   # 从缓存返回
p3 = Point(3, 4)   # 创建新实例 (3, 4)
print(p1 is p2)    # True

在这个例子中，__new__负责缓存管理，但我们需要在创建时手动设置属性，因为__init__对于缓存对象可能不会按预期执行（或者我们可以在__init__中也做处理）。更好的实践是将属性设置放在__new__中，并确保__init__为空。

2.3.4 元类中的`new`

元类是类的类，控制类的创建过程。元类的__new__方法在类定义时被调用，用于创建类对象。

python

class Meta(type):
    def __new__(cls, name, bases, namespace):
        # 在类创建前可以修改命名空间
        namespace['version'] = 1.0
        return super().__new__(cls, name, bases, namespace)

class MyClass(metaclass=Meta):
    pass

print(MyClass.version)  # 1.0

这里不展开元类，但说明__new__在元层级的应用。

2.4 注意事项

必须返回实例：__new__如果不返回对象，则__init__不会被调用，并且实例化结果为None（除非抛出异常）。如果返回的对象不是当前类的实例，则__init__跳过。
调用父类的__new__：通常使用super().__new__(cls)来分配内存，它会调用object.__new__(cls)。object.__new__是所有新式类的最终基类实现，它分配一个空对象。
参数传递：__new__和__init__接收相同的参数（除了第一个参数不同）。如果__new__需要不同的参数签名，必须保持一致，否则可能导致__init__调用失败。
不可变类型：对于不可变类型，__new__是唯一可以设置初始值的地方。
避免滥用：大多数类不需要重写__new__，默认实现已经足够。只有需要控制实例创建时才重写。

三、`init` 方法详解

3.1 定义与基本作用

__init__是Python类的初始化方法，在实例创建后自动调用，用于设置对象的初始状态。它接受self作为第一个参数，随后是构造时传入的其他参数。

python

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

当执行p = Person("Alice", 30)时，Python内部已经通过__new__创建了一个实例，然后将该实例作为self传递给__init__，执行初始化代码。

3.2 返回值要求

__init__必须返回None（显式或隐式）。如果返回任何非None对象，会引发TypeError。

python

class BadInit:
    def __init__(self):
        return 42   # TypeError: __init__() should return None

3.3 在继承中的行为

当子类定义__init__时，如果需要调用父类的初始化逻辑，必须显式调用super().__init__(...)。否则，父类的__init__不会自动执行。

示例：继承与初始化

python

class Animal:
    def __init__(self, species):
        self.species = species
        print("Animal init")

class Dog(Animal):
    def __init__(self, name, species="犬科"):
        super().__init__(species)   # 调用父类初始化
        self.name = name
        print("Dog init")

d = Dog("旺财")
# 输出:
# Animal init
# Dog init

如果不调用super().__init__()，则species属性不会被设置。

3.4 多继承与方法解析顺序（MRO）

在多继承场景下，super()会根据MRO（方法解析顺序）依次调用父类的初始化方法。MRO由C3线性化算法确定，可以通过类名.__mro__查看。

python

class A:
    def __init__(self):
        print("A init")
        super().__init__()  # 继续调用MRO中的下一个

class B:
    def __init__(self):
        print("B init")
        super().__init__()

class C(A, B):
    def __init__(self):
        print("C init")
        super().__init__()

c = C()
# 输出:
# C init
# A init
# B init
# (注意：B之后没有再调用object.__init__，因为object的__init__无操作)

注意：super().__init__()会沿着MRO链继续调用，而不是直接调用父类。这在多继承中非常有用，可以保证每个父类都被正确初始化。

3.5 何时需要重写`init`

需要设置实例属性时。
需要执行一些初始检查或资源获取时（如打开文件、网络连接，但更推荐用上下文管理器）。
在子类中扩展父类的初始化行为。

3.6 一些技巧和陷阱

3.6.1 避免重复初始化

在某些设计模式（如单例、缓存）中，__init__可能会被多次调用（因为每次实例化都会触发）。可以在__init__中检查是否已经初始化过：

python

class LazyInit:
    def __init__(self):
        if hasattr(self, '_initialized'):
            return
        self._initialized = True
        # 其他初始化代码...

3.6.2 使用`new`绕过`init`

有时我们希望创建对象但不执行初始化，可以借助__new__直接创建实例而不调用__init__。例如：

python

class NoInit:
    def __init__(self):
        print("初始化执行")

# 绕过__init__
obj = NoInit.__new__(NoInit)
print(obj)        # <__main__.NoInit object at ...>
# __init__ 没有被调用

这种方式在某些高级场景（如反序列化、对象重建）中可能有用，但通常不推荐在常规代码中使用。

3.6.3 参数默认值与可变对象

在__init__中使用可变默认参数要小心，因为默认值在函数定义时创建一次，所有实例共享。

python

class Bad:
    def __init__(self, items=[]):   # 共享列表！
        self.items = items

a = Bad()
a.items.append(1)
b = Bad()
print(b.items)   # [1]   ❌ 意外共享

正确做法是使用None并在内部创建新列表。

3.6.4 显式调用`init`

虽然__init__通常由解释器自动调用，但也可以手动调用（在已创建的实例上）来重新初始化对象。例如：

python

p = Person("Alice", 30)
p.__init__("Bob", 25)   # 重新初始化
print(p.name)   # Bob

但这种用法很少见，且容易造成混乱，除非有明确的设计意图，否则应避免。

四、`del` 方法详解

4.1 定义与基本作用

__del__是Python的析构方法，在对象被垃圾回收之前由解释器调用。它用于执行清理工作，如释放外部资源（文件句柄、网络连接等）。其定义如下：

python

class Resource:
    def __del__(self):
        print("对象被销毁，释放资源")

当对象引用计数降为零，或者被垃圾回收器收集时，__del__会被调用。注意，调用时机是不确定的，特别是在存在循环引用或程序退出时。

4.2 调用时机与限制

引用计数归零：当对象的引用计数变为0时，Python会立即调用__del__并回收内存（CPython）。
垃圾回收：如果存在循环引用，且对象定义了__del__，则垃圾回收器会将其视为不可达但需要析构的对象，放入gc.garbage列表，除非你手动打破循环或调用gc.collect()。
程序退出：在解释器关闭时，会尝试清理所有对象，但可能无法保证所有__del__都被调用，尤其当模块已销毁时。

因此，__del__不能作为资源释放的可靠机制。更推荐使用上下文管理器（with语句）或显式close()方法。

4.3 示例：观察`del`的调用

python

import time

class Demo:
    def __init__(self, name):
        self.name = name
        print(f"{self.name} 创建")

    def __del__(self):
        print(f"{self.name} 销毁")

# 正常情况
d = Demo("A")
del d          # 显式删除引用，立即输出 "A 销毁"
time.sleep(0.1)

# 函数作用域内
def test():
    d2 = Demo("B")
test()         # 函数结束，d2引用消失，输出 "B 销毁"

# 循环引用
class Node:
    def __init__(self, name):
        self.name = name
        self.ref = None
    def __del__(self):
        print(f"{self.name} 销毁")

a = Node("X")
b = Node("Y")
a.ref = b
b.ref = a
del a, b       # 此时引用计数不为0（互相引用），__del__不会立即调用
import gc
gc.collect()   # 强制垃圾回收，可能输出 "X 销毁" "Y 销毁"（但取决于Python版本和回收机制）

注意：在CPython中，如果对象定义了__del__，垃圾回收器会将其视为不可回收（除非可以证明无循环），因此需要谨慎处理。

4.4 与`init`的对应关系

__del__可以看作是__init__的逆操作，但并不保证一定会成对出现。例如，如果对象创建后从未被销毁（如全局对象），__del__可能永远不会被调用。

4.5 注意事项和最佳实践

不要依赖__del__释放重要资源：因为调用时机不确定，可能造成资源泄露。使用with语句或try...finally更可靠。
避免在__del__中引发异常：如果在__del__中抛出异常，解释器会打印栈跟踪但不会传播，可能导致清理不完全。
避免在__del__中访问可能已被销毁的全局变量：因为模块在解释器关闭时可能已被清理。
循环引用的处理：如果需要使用__del__，应确保打破循环引用，或使用weakref弱引用。
替代方案：对于文件、网络连接等资源，实现close()方法，并建议用户显式调用，同时实现上下文管理器（__enter__/__exit__）。

示例：更好的资源管理

python

class ManagedResource:
    def __init__(self, filename):
        self.file = open(filename)

    def close(self):
        if hasattr(self, 'file'):
            self.file.close()
            print("资源已关闭")

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()

    def __del__(self):
        self.close()   # 作为最后的保障，但不要依赖

# 使用with
with ManagedResource('data.txt') as res:
    # 使用资源
    pass   # 退出时自动调用close

这样既保证了显式关闭，也提供了后备。

五、对象生命周期完整示例

为了直观展示三个方法的调用顺序，我们构建一个简单的类，观察其创建和销毁过程。

python

class LifeCycle:
    def __new__(cls, *args, **kwargs):
        print("1. __new__ 调用")
        instance = super().__new__(cls)
        print("   实例创建完成，内存地址:", id(instance))
        return instance

    def __init__(self, value):
        print("2. __init__ 调用")
        self.value = value
        print("   初始化完成，value =", self.value)

    def __del__(self):
        print("3. __del__ 调用，清理对象", id(self))

print("开始创建对象")
obj = LifeCycle(42)
print("对象使用中，value =", obj.value)
print("删除引用")
del obj
print("程序结束")

输出示例：

text

开始创建对象
1. __new__ 调用
   实例创建完成，内存地址: 140735182089344
2. __init__ 调用
   初始化完成，value = 42
对象使用中，value = 42
删除引用
3. __del__ 调用，清理对象 140735182089344
程序结束

可以看到严格的顺序：__new__创建实例 → __init__初始化 → 使用 → __del__销毁。

如果对象在程序结束时仍然存活，__del__也会在解释器关闭前被调用（但不能保证）。

六、高级主题与深入探讨

6.1 `new`在元类中的应用

元类可以控制类的创建。元类的__new__方法在类定义时执行，用于动态修改类。结合__new__和元类，可以实现更强大的模式，如自动注册子类、属性验证等。

示例：使用元类自动为类添加ID

python

class AutoIDMeta(type):
    def __new__(cls, name, bases, namespace):
        namespace['id'] = name.lower() + "_id"
        return super().__new__(cls, name, bases, namespace)

class Animal(metaclass=AutoIDMeta):
    pass

class Dog(Animal):
    pass

print(Animal.id)   # animal_id
print(Dog.id)      # dog_id

6.2 不可变对象与`new`的深入

对于自定义的不可变对象，需要重写__new__并可能重写__setattr__来防止修改。Python的namedtuple是一个例子，但其实现使用元类和__new__。

示例：简单的不可变类

python

class ImmutablePoint:
    def __new__(cls, x, y):
        instance = super().__new__(cls)
        # 直接设置属性，因为之后不允许修改
        instance._x = x
        instance._y = y
        return instance

    @property
    def x(self):
        return self._x

    @property
    def y(self):
        return self._y

    def __setattr__(self, key, value):
        if key in ('_x', '_y'):   # 允许内部设置一次
            super().__setattr__(key, value)
        else:
            raise AttributeError("Immutable object cannot be modified")

p = ImmutablePoint(1, 2)
print(p.x, p.y)   # 1 2
# p.x = 3         # 抛出异常

注意：这里在__new__中直接设置了内部属性（以单下划线开头），并重写__setattr__防止后续修改。这是一种实现方式，但更简洁的可能是使用@dataclass(frozen=True)（Python 3.7+）。

6.3 使用`new`实现工厂模式

工厂模式通常用一个静态方法返回不同类的实例，但也可以利用__new__根据参数返回不同的子类实例。

python

class Shape:
    def __new__(cls, shape_type, *args, **kwargs):
        if cls is Shape:   # 如果是直接调用Shape，则选择子类
            if shape_type == 'circle':
                return super().__new__(Circle)
            elif shape_type == 'square':
                return super().__new__(Square)
            else:
                raise ValueError("Unknown shape type")
        else:
            # 如果是子类直接实例化，走正常流程
            return super().__new__(cls)

    def area(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return 3.14 * self.radius ** 2

class Square(Shape):
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

# 通过工厂创建
c = Shape('circle', 5)
s = Shape('square', 4)
print(c.area())   # 78.5
print(s.area())   # 16

这样Shape类本身充当了工厂，根据参数返回相应的子类实例。但注意，直接实例化子类仍然有效。

6.4 `del`与垃圾回收的深入

CPython使用引用计数为主，标记-清除和分代回收为辅的垃圾回收机制。当对象存在循环引用且定义了__del__，垃圾回收器会将其放入gc.garbage列表，需要程序员手动处理。这可能导致内存泄漏。

示例：循环引用与__del__

python

import gc

class A:
    def __init__(self, name):
        self.name = name
        self.other = None
    def __del__(self):
        print(f"{self.name} 被销毁")

class B:
    def __init__(self, name):
        self.name = name
        self.other = None
    def __del__(self):
        print(f"{self.name} 被销毁")

a = A('A')
b = B('B')
a.other = b
b.other = a

del a, b
print(gc.collect())   # 触发垃圾回收
# 输出（可能）：
# 4
# A 被销毁
# B 被销毁

实际上，Python的垃圾回收器能够处理循环引用，即使定义了__del__，但如果它们构成了一个引用环且没有外部引用，回收器会在收集阶段调用__del__（在Python 3.4+中，通过PEP 442改进了这一点，使得定义了__del__的对象也能被安全回收，但前提是__del__不复活对象）。因此现代Python中循环引用问题有所缓解，但仍需注意。

6.5 `init`在多重继承中的协同

在复杂的多重继承中，为了确保所有父类的__init__都被调用，必须使用super()并保持一致的参数签名。设计良好的类应该支持**kwargs来传递未使用的参数。

python

class Base:
    def __init__(self, **kwargs):
        print("Base init")
        super().__init__(**kwargs)   # 最终调用object.__init__

class A(Base):
    def __init__(self, a, **kwargs):
        print("A init")
        self.a = a
        super().__init__(**kwargs)

class B(Base):
    def __init__(self, b, **kwargs):
        print("B init")
        self.b = b
        super().__init__(**kwargs)

class C(A, B):
    def __init__(self, a, b, c):
        print("C init")
        super().__init__(a=a, b=b, c=c)   # 传递所有参数
        self.c = c

obj = C(a=1, b=2, c=3)
print(obj.__dict__)   # {'a': 1, 'b': 2, 'c': 3}
# 输出顺序: C init, A init, B init, Base init

这里每个类只处理自己关心的参数，并将剩余参数通过**kwargs向上传递，最终Base的__init__调用super().__init__(**kwargs)（即object.__init__）结束链条。这种模式称为“合作式多重继承”。

6.6 性能考虑

__new__和__init__的调用开销相对较小，但在频繁创建对象的场景下（如循环中），需要注意。如果__new__中进行了复杂计算或I/O，会影响性能。另一方面，__del__的调用时机不确定，可能导致延迟释放资源，影响系统吞吐量。

七、常见错误与最佳实践

7.1 常见错误

忘记在__new__中返回实例：导致实例化为None。

python

class Broken:
    def __new__(cls):
        pass   # 没有返回
b = Broken()   # b 是 None

在__init__中返回非None值：引发TypeError。
依赖__del__释放重要资源：可能导致资源泄露。
在__del__中访问可能已销毁的全局变量：如模块函数、其他对象。
循环引用导致__del__不被调用（旧版Python）。
在继承中忘记调用super().__init__：父类状态未初始化。

7.2 最佳实践

保持__new__简单：除非必要，不要重写__new__。默认实现通常足够。
__init__只做初始化：不要执行耗时操作或可能失败的操作（可考虑用类方法或工厂函数替代）。
使用with语句管理资源，而不是__del__。
在多重继承中使用super()和**kwargs，确保所有父类初始化。
如果必须重写__new__，记得调用父类__new__并返回实例。
避免在__del__中引发异常，用try/except捕获。
测试对象销毁：可以使用weakref.finalize注册回调，观察对象销毁时机。

八、总结

本文详细探讨了Python中三个核心的生命周期方法：__new__、__init__和__del__。我们了解到：

__new__负责创建对象，返回实例，适用于不可变类型、单例、缓存等场景。
__init__负责初始化对象，设置属性，是面向对象编程中最常用的方法。
__del__在对象销毁前调用，但不可靠，应避免依赖。

通过大量的代码示例，我们展示了它们的使用方法、注意事项以及高级应用。理解这些方法的内部机制，有助于我们编写更健壮、更高效的Python代码，同时也能更深入地理解Python的对象模型和内存管理。

在实际开发中，大多数时候我们只需要定义__init__，而__new__和__del__则用于特定场景。合理使用它们，可以让我们更好地控制对象的生命周期，实现更优雅的设计模式。

希望本文能为读者提供全面而深入的理解，为后续的Python进阶学习打下坚实基础。

AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

DeepSeek Harness 深度解析：一切皆插件的开源 AI Agent 框架如何运行？

AI Agent技术社区

2026年，集团企业想要AI落地，选RPA还是Agent？

AI Agent技术社区

从「能说」到「能做」：一份理清 AI Agent 的学习笔记

AI Agent技术社区

所有评论(0)

查看更多评论

wang sum yuen

@2511_93835513

已为社区贡献60条内容

Python中__new__, __init__, __del__内容详解

wang sum yuen

Python中__new__, __init__, __del__内容详解

引言

一、对象的生命周期概览

二、__new__ 方法详解

2.1 定义与基本作用

2.2 __new__ 与 __init__ 的区别

2.3 使用场景与示例

2.3.1 不可变类型的子类化

2.3.2 单例模式

2.3.3 缓存/池化对象

2.3.4 元类中的__new__

2.4 注意事项

三、__init__ 方法详解

3.1 定义与基本作用

3.2 返回值要求

3.3 在继承中的行为

3.4 多继承与方法解析顺序（MRO）

3.5 何时需要重写__init__

3.6 一些技巧和陷阱

3.6.1 避免重复初始化

3.6.2 使用__new__绕过__init__

3.6.3 参数默认值与可变对象

3.6.4 显式调用__init__

四、__del__ 方法详解

4.1 定义与基本作用

4.2 调用时机与限制

4.3 示例：观察__del__的调用

4.4 与__init__的对应关系

4.5 注意事项和最佳实践

五、对象生命周期完整示例

六、高级主题与深入探讨

6.1 __new__在元类中的应用

6.2 不可变对象与__new__的深入

6.3 使用__new__实现工厂模式

6.4 __del__与垃圾回收的深入

6.5 __init__在多重继承中的协同

6.6 性能考虑

七、常见错误与最佳实践

7.1 常见错误

7.2 最佳实践

八、总结

所有评论(0)

温馨提示：您尚未绑定手机号

wang sum yuen

Python中new, init, del内容详解

Python中`new`, `init`, `del`内容详解

二、`new` 方法详解

2.2 `new` 与 `init` 的区别

2.3.4 元类中的`new`

三、`init` 方法详解

3.5 何时需要重写`init`

3.6.2 使用`new`绕过`init`

3.6.4 显式调用`init`

四、`del` 方法详解

4.3 示例：观察`del`的调用

4.4 与`init`的对应关系

6.1 `new`在元类中的应用

6.2 不可变对象与`new`的深入

6.3 使用`new`实现工厂模式

6.4 `del`与垃圾回收的深入

6.5 `init`在多重继承中的协同