元类

约 707 字大约 2 分钟

2026-08-17

类的创建过程

使用 class 关键字定义类时，Python 底层会调用元类来创建类：

class Dog:
    pass


# 等效于
class Dog(metaclass=type):
    pass


# 等效于
Dog = type("Dog", (), {})

# 等效于
Dog = type.__call__(type, "Dog", (), {})

也就是说，class 关键字只是语法糖，底层仍然是通过 type() 创建类。

自定义元类

通过继承 type，可以自定义元类，控制类的创建过程。

class MyMeta(type):
    def __new__(mcs, name, bases, namespace):
        print(f"正在创建类: {name}")
        print(f"父类: {bases}")
        print(f"属性: {list(namespace.keys())}")

        # 必须调用 type.__new__ 来真正创建类
        cls = super().__new__(mcs, name, bases, namespace)
        return cls


# 使用 metaclass 参数指定元类
class Dog(metaclass=MyMeta):
    species = "Canis familiaris"

    def bark(self):
        print("Woof!")


# 等效于
# def bark(self):
#     print("Woof!")


# Dog = type.__call__(MyMeta, "Dog", (), {"species": "Canis familiaris", "bark": bark})

# 输出：
# 正在创建类: Dog
# 父类: ()
# 属性: ['__module__', '__qualname__', 'species', 'bark']

参数说明：

mcs：元类自身（类似类方法中的 cls）
name：类名字符串
bases：父类元组
namespace：类属性的字典

深入：元类的查找顺序

子类会继承父类的元类：

class MyMeta(type):
    pass

class Base(metaclass=MyMeta):
    pass

class Child(Base):  # 自动继承 MyMeta
    pass

print(type(Child))  # <class '__main__.MyMeta'>

如果父类元类不兼容，需要使用更通用的元类：

class MetaA(type):
    pass

class MetaB(type):
    pass

class A(metaclass=MetaA):
    pass

class B(metaclass=MetaB):
    pass

# class C(A, B): pass  # TypeError! 元类冲突

# 解决方法：创建兼容的元类
class CommonMeta(MetaA, MetaB):
    pass

class C(A, B, metaclass=CommonMeta):  # 正常
    pass

总结

概念	说明
元类	创建类的类，默认是 `type`
`__new__`	创建类，返回类对象
`__init__`	初始化类，无返回值
`__call__`	控制类的实例化过程
应用场景	命名检查、自动注册、方法增强、ORM 等

作业

一、实现单例元类

编写一个元类 SingletonMeta，使得任何使用该元类的类都自动成为单例模式：

class SingletonMeta(type):
    # 你的代码
    pass

class Database(metaclass=SingletonMeta):
    def __init__(self, host):
        self.host = host

db1 = Database("localhost")
db2 = Database("remote")
print(db1 is db2)  # 应该输出 True
print(db1.host)    # 应该输出 localhost

二、自动注册子类

编写一个元类 PluginMeta，使得任何继承自 Plugin 的子类都会被自动注册到 PluginMeta.registry 字典中（键为类名，值为类本身）：

class PluginMeta(type):
    # 你的代码
    pass

class Plugin(metaclass=PluginMeta):
    pass

class ImagePlugin(Plugin):
    pass

class TextPlugin(Plugin):
    pass

print(PluginMeta.registry)
# 应该输出类似：{'ImagePlugin': <class '__main__.ImagePlugin'>, 'TextPlugin': <class '__main__.TextPlugin'>}

三、为所有方法添加日志

编写一个元类 LogMeta，自动为类中每个非私有方法（即不以 _ 开头的方法）添加执行日志。调用方法时，先打印 [LOG] 调用 {方法名}，再执行原方法：

class LogMeta(type):
    # 你的代码
    pass

class Calculator(metaclass=LogMeta):
    def add(self, a, b):
        return a + b
    
    def sub(self, a, b):
        return a - b

calc = Calculator()
print(calc.add(3, 5))
print(calc.sub(10, 4))

# 应该输出：
# [LOG] 调用 add
# 8
# [LOG] 调用 sub
# 6