第十三章 元类编程：掌控类的“造物主”

说实话，很多 Python 开发者写了几年代码，都没碰过元类。这很正常。但如果你想真正理解 Python 的面向对象，元类就是绕不过去的一关。它不是什么黑魔法，说白了，就是“创建类的类”。

我个人习惯把元类比作“类的模具”。普通类是你的模具，用来造对象。而元类，就是用来造这个模具的模具。你想想看，这玩意儿一旦掌握了，你就能在类被创建出来之前，偷偷修改它的行为。是不是有点“造物主”的感觉？

type 与元类：一切类的源头

在 Python 里，type 就是最根本的元类。你可能见过用 type 来检查对象类型，比如 type(42) 返回 <class 'int'>。但 type 还有一个更强大的用法——动态创建类。

举个例子，下面这两段代码是等价的：

# 传统方式
class Foo:
    bar = 100

# 用 type 动态创建
Foo = type('Foo', (), {'bar': 100})

看到了吗？type(name, bases, dict) 直接返回一个类。第一个参数是类名，第二个是父类元组，第三个是类属性和方法。我在项目中曾经用这个技巧，在运行时根据配置文件动态生成不同的数据模型类，省掉了大量重复代码。

但 type 只是起点。真正的元类编程，是继承 type 来定制类的创建逻辑。

__new__ vs __init__：类的“出生”与“满月”

很多初学者搞不清 __new__ 和 __init__ 的区别。我打个比方你就明白了：

• __new__ 是“接生婆”，负责把类（或对象）带到这个世界上来。它返回一个实例。
• __init__ 是“满月酒”，负责给这个新生的实例布置房间、贴标签。它不返回任何东西。

在元类中，__new__ 在类被创建时调用，__init__ 在类创建完成后调用。看个例子：

class MyMeta(type):
    def __new__(cls, name, bases, attrs):
        print(f"【__new__】正在创建类: {name}")
        # 可以在这里修改 attrs
        attrs['version'] = 1.0
        return super().__new__(cls, name, bases, attrs)

    def __init__(cls, name, bases, attrs):
        print(f"【__init__】类 {name} 已创建完成")
        super().__init__(name, bases, attrs)

class MyClass(metaclass=MyMeta):
    pass

# 输出:
# 【__new__】正在创建类: MyClass
# 【__init__】类 MyClass 已创建完成

嗯，这里要注意：__new__ 必须返回一个类对象，否则 __init__ 不会被调用。我曾经踩过这个坑，在 __new__ 里忘了写 return，结果类创建出来是个 None，排查了半天。

控制类的创建过程：你能做什么？

元类最实用的地方，就是在类被定义时自动注入代码。比如：

• 自动给所有方法加上日志
• 强制要求子类实现某些方法
• 注册所有子类到一个全局字典
• 实现单例模式

我个人最常用的是“注册模式”。比如写一个插件系统，我希望所有继承自 BasePlugin 的类，都自动注册到一个列表中。用元类几行代码就搞定了：

_plugins = []

class PluginMeta(type):
    def __init__(cls, name, bases, attrs):
        super().__init__(name, bases, attrs)
        if name != 'BasePlugin':
            _plugins.append(cls)

class BasePlugin(metaclass=PluginMeta):
    pass

class PluginA(BasePlugin):
    pass

class PluginB(BasePlugin):
    pass

print(_plugins)  # [<class 'PluginA'>, <class 'PluginB'>]

你看，类一被定义，就自动注册了。完全不需要手动调用任何函数。

实战案例：单例模式元类

单例模式，说白了就是一个类只能有一个实例。用元类实现是最优雅的方式之一。为什么？因为元类控制了类的创建，而单例控制的是实例的创建——这两者天然契合。

来看代码：

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            # 第一次调用，正常创建实例
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        return cls._instances[cls]

class Database(metaclass=SingletonMeta):
    def __init__(self):
        print("数据库连接已创建")

# 测试
db1 = Database()  # 输出: 数据库连接已创建
db2 = Database()  # 不输出任何内容
print(db1 is db2)  # True

这里的关键是重写了元类的 __call__ 方法。当你调用 Database() 时，实际上调用的是 SingletonMeta.__call__。第一次调用时创建实例并缓存，后续直接返回缓存。

我曾经在一个高并发服务里用过这个元类单例，结果线上出现了两个数据库连接实例，排查了半天才发现是线程安全问题。后来加了个 threading.Lock 就解决了。

知识体系总览

下面这张图帮你理清元类的核心逻辑：

好了，这一章的内容就到这里。记住，元类编程是 Python 进阶路上的一道分水岭。跨过去，你对面向对象的理解会上一个台阶。

---