`Python`的`元类`：`__prepare__`和`__new__`在`自定义`类创建中的`作用`。

Python 元类：__prepare__ 和 __new__ 在自定义类创建中的作用

大家好，今天我们来深入探讨 Python 元类中两个非常重要的方法：__prepare__ 和 __new__。理解这两个方法对于掌握元类，进而实现高级的类定制和元编程至关重要。我们将通过讲解、代码示例和对比分析，全面了解它们在类创建过程中的作用。

元类的基础概念回顾

在深入 __prepare__ 和 __new__ 之前，我们先简要回顾一下元类的基本概念。

在 Python 中，一切皆对象。类本身也是对象，而创建类的“类”就是元类。默认情况下，type 是 Python 中所有类的元类。我们可以通过继承 type 来自定义元类，从而控制类的创建过程。

简单来说，元类负责以下工作：

1. 拦截类的创建。
2. 修改类的定义。
3. 返回修改后的类。

类创建的流程

要理解 __prepare__ 和 __new__ 的作用，需要了解类创建的完整流程。当解释器遇到 class 语句时，会执行以下步骤：

1. 确定元类 (Metaclass Determination): 首先，确定用于创建该类的元类。这通常遵循以下规则：

   • 如果类定义中显式指定了 metaclass 关键字参数，则使用该元类。
   • 如果没有显式指定，则使用父类的元类（如果存在父类）。
   • 如果父类也没有元类，则使用默认元类 type。

2. 调用 __prepare__ (Preparation): 如果元类定义了 __prepare__ 方法，则调用该方法。__prepare__ 方法接收元类自身、类名以及类的所有父类作为参数，并且必须返回一个命名空间 (Namespace)。这个命名空间将用于存储类的属性和方法。如果没有定义 __prepare__，默认情况下会返回一个普通的字典 dict。

3. 执行类体 (Class Body Execution): 在准备好的命名空间中执行类体中的代码。类体中定义的属性和方法会被添加到该命名空间中。

4. 调用 __new__ (Creation): 元类的 __new__ 方法被调用，接收元类自身、类名、父类元组以及包含类属性和方法的命名空间作为参数。__new__ 方法负责创建并返回类对象。

5. 调用 __init__ (Initialization): 元类的 __init__ 方法被调用，接收类对象、类名、父类元组以及包含类属性和方法的命名空间作为参数。__init__ 方法可以对类对象进行进一步的初始化。

6. 返回类对象 (Class Object Return): __new__ 创建的类对象被返回，赋值给类名。

__prepare__ 方法详解

__prepare__ 方法是元类中一个静态方法，它的主要作用是为类创建过程提供一个自定义的命名空间。默认情况下，这个命名空间是一个普通的字典 dict，但我们可以通过 __prepare__ 方法返回其他类型的命名空间，例如 OrderedDict 或其他自定义的映射类型。

__prepare__ 的签名:

@staticmethod
def __prepare__(name: str, bases: tuple[type, ...]) -> dict[str, object]:
    ...

• name: 即将被创建的类的名称。
• bases: 一个包含基类的元组。
• 返回值: 一个字典或类似映射的对象，用作类的命名空间。

__prepare__ 的作用:

1. 自定义命名空间: 这是 __prepare__ 最主要的作用。我们可以使用 OrderedDict 来保持类成员定义的顺序，或者使用其他自定义的映射类型来实现更复杂的逻辑。

2. 预处理类属性: 在类体执行之前，可以对类属性进行预处理。例如，可以检查类属性的类型，或者根据某些条件修改类属性的值。

3. 实现类成员的可见性控制: 可以控制哪些类成员对外部可见。

__prepare__ 的示例:

from collections import OrderedDict

class MyMeta(type):
    @staticmethod
    def __prepare__(name, bases):
        print(f"MyMeta.__prepare__ called for class {name}")
        return OrderedDict()  # 使用 OrderedDict 作为命名空间

    def __new__(cls, name, bases, namespace):
        print(f"MyMeta.__new__ called for class {name}")
        return super().__new__(cls, name, bases, namespace)

    def __init__(cls, name, bases, namespace):
        print(f"MyMeta.__init__ called for class {name}")
        super().__init__(name, bases, namespace)

class MyClass(metaclass=MyMeta):
    attribute1 = "value1"
    attribute2 = "value2"

    def method1(self):
        pass

    attribute3 = "value3"

print(f"MyClass.__dict__ = {MyClass.__dict__}")

输出：

MyMeta.__prepare__ called for class MyClass
MyMeta.__new__ called for class MyClass
MyMeta.__init__ called for class MyClass
MyClass.__dict__ = {'__module__': '__main__', '__doc__': None, 'attribute1': 'value1', 'attribute2': 'value2', 'method1': <function MyClass.method1 at 0x...>, 'attribute3': 'value3', '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>}

在这个例子中，我们使用 OrderedDict 作为 MyClass 的命名空间。虽然最终 MyClass.__dict__ 仍然是一个普通的字典，但在类创建过程中，类成员的定义顺序被 OrderedDict 记录下来。需要注意的是，__dict__ 通常会转换为标准字典，除非你采取额外的步骤来保持 OrderedDict。如果需要持久化这种顺序，需要在__new__ 或 __init__ 中做一些处理。

更复杂的 __prepare__ 示例：属性类型检查

class TypedMeta(type):
    @staticmethod
    def __prepare__(name, bases):
        return {}  # 使用普通字典作为命名空间

    def __new__(cls, name, bases, namespace):
        for key, value in namespace.items():
            if key.startswith('_'):
                continue # 忽略私有属性
            if hasattr(value, '__annotations__'): # 检查是否是函数或者方法
                continue
            if not isinstance(value, (int, str, float, bool)):
                raise TypeError(f"Attribute {key} must be int, str, float, or bool")
        return super().__new__(cls, name, bases, namespace)

class TypedClass(metaclass=TypedMeta):
    valid_attribute: int = 10
    another_valid_attribute: str = "hello"
    _private_attribute = "secret" # 不进行类型检查

    def method(self):
        pass

    # invalid_attribute: list = [1, 2, 3]  # 会引发 TypeError

在这个例子中，__prepare__ 使用普通的字典作为命名空间，__new__ 方法遍历命名空间中的所有属性，并检查它们的类型是否为 int、str、float 或 bool。如果属性的类型不符合要求，则抛出 TypeError 异常。 注意，为了简化，这里跳过了对函数和方法的类型检查。

__new__ 方法详解

__new__ 方法是元类中负责创建类对象的静态方法。它类似于类的 __new__ 方法，但作用对象是类本身。 __new__ 必须返回一个类对象，通常是通过调用父类的 __new__ 方法来实现。

__new__ 的签名:

def __new__(cls: type[type], name: str, bases: tuple[type, ...], namespace: dict[str, object]) -> type:
    ...

• cls: 元类自身。
• name: 即将被创建的类的名称。
• bases: 一个包含基类的元组。
• namespace: 一个包含类属性和方法的字典，由 __prepare__ 方法返回并由类体填充。
• 返回值: 新创建的类对象。

__new__ 的作用:

1. 创建类对象: 这是 __new__ 最核心的作用。它负责分配内存，创建类的实例，并返回该实例。

2. 修改类属性: 在类对象创建之前，可以修改 namespace 中的类属性。

3. 控制类的创建: 可以根据某些条件决定是否创建类对象。

__new__ 的示例:

class SingletonMeta(type):
    _instances = {}

    def __new__(cls, name, bases, namespace):
        # 创建类对象
        new_class = super().__new__(cls, name, bases, namespace)
        cls._instances[name] = None  # 初始化实例
        return new_class

    def __call__(cls, *args, **kwargs):
        # 实现单例模式
        if cls._instances[cls.__name__] is None:
            cls._instances[cls.__name__] = super().__call__(*args, **kwargs)
        return cls._instances[cls.__name__]

class SingletonClass(metaclass=SingletonMeta):
    def __init__(self, value):
        self.value = value

instance1 = SingletonClass(10)
instance2 = SingletonClass(20)

print(instance1 is instance2)  # 输出 True
print(instance1.value) # 输出 10
print(instance2.value) # 输出 10

在这个例子中，SingletonMeta 元类实现了单例模式。 __new__ 方法创建类对象，并在 _instances 字典中初始化一个 None 值。 __call__ 方法负责控制类的实例化过程，确保只有一个实例被创建。

更复杂的 __new__ 示例：自动添加属性

class AutoAttributeMeta(type):
    def __new__(cls, name, bases, namespace):
        # 自动添加一个名为 'created_by' 的类属性
        namespace['created_by'] = 'AutoAttributeMeta'
        return super().__new__(cls, name, bases, namespace)

class MyClass(metaclass=AutoAttributeMeta):
    pass

print(MyClass.created_by)  # 输出 AutoAttributeMeta

在这个例子中，__new__ 方法自动向类中添加了一个名为 created_by 的属性，并将其值设置为 AutoAttributeMeta。

__init__ 方法简述

虽然我们主要关注 __prepare__ 和 __new__，但为了完整性，也简单介绍一下 __init__ 方法。__init__ 方法在 __new__ 创建类对象之后被调用，可以对类对象进行进一步的初始化。 它接收的参数与 __new__ 相同。

__init__ 的签名:

def __init__(cls: type[type], name: str, bases: tuple[type, ...], namespace: dict[str, object]) -> None:
    ...

__init__ 的作用:

1. 初始化类对象: 对类对象进行进一步的初始化，例如设置类的属性、添加方法等。

2. 执行类创建后的操作: 可以在类创建完成后执行一些额外的操作，例如注册类到某个系统中。

__prepare__ 和 __new__ 的对比

为了更好地理解 __prepare__ 和 __new__ 的区别和联系，我们用一个表格进行对比：

特性	__prepare__	__new__
作用	提供自定义的命名空间	创建类对象
调用时机	类体执行之前	类体执行之后，__init__ 之前
参数	元类自身、类名、父类元组	元类自身、类名、父类元组、命名空间
返回值	命名空间（字典或类似映射的对象）	类对象
是否必须定义	否，默认使用 dict 作为命名空间	否，默认调用父类的 __new__ 方法
主要用途	自定义类属性的存储方式、预处理类属性	创建类对象、修改类属性、控制类的创建

最佳实践与注意事项

1. 谨慎使用元类: 元类是一种强大的工具，但也增加了代码的复杂性。只有在确实需要高度定制类创建过程时才应该使用元类。

2. 理解类创建流程: 在使用元类之前，务必充分理解类创建的完整流程，包括 __prepare__、__new__ 和 __init__ 的调用时机和作用。

3. 遵循命名规范: 元类的命名通常以 Meta 结尾，例如 MyMeta。

4. 保持代码清晰: 元类中的代码应该简洁明了，避免过度复杂的逻辑。

5. 不要过度使用 __prepare__: 除非真的需要自定义命名空间，否则使用默认的 dict 即可。

6. __new__ 必须返回一个类对象: 如果 __new__ 没有返回一个类对象，将会导致类创建失败。

7. super() 的正确使用: 在 __new__ 和 __init__ 中，应该使用 super() 来调用父类的方法，以保证继承链的正确性。

应用场景

元类在以下场景中非常有用：

1. ORM (对象关系映射): 元类可以用来自动将数据库表的结构映射到类属性。

2. API 自动生成: 元类可以根据接口定义自动生成 API 代码。

3. 单例模式: 元类可以用来实现单例模式。

4. 属性验证: 元类可以用来验证类属性的类型和值。

5. 自动注册类: 元类可以将类自动注册到某个系统中。

6. 控制类的创建: 比如根据某些配置或者条件，决定是否创建类。

总结：__prepare__ 与 __new__ 的分工

__prepare__ 负责准备类的命名空间，可以控制类属性的存储方式和进行预处理。__new__ 负责创建类对象，可以修改类属性和控制类的创建过程。 它们共同协作，实现了对类创建过程的精细控制。