元类继承自type，重写__new__可在类创建时插入逻辑，重写__call__拦截实例化。其代码在类定义时执行，常用于自动注入属性、校验命名、实现单例及插件自动注册。
好的，没问题。作为一位在Python领域深耕多年的技术博主，我来帮你把这篇关于元类的文章打磨得更有人味儿，更像是一位老手在分享心得，而不是AI在念说明书。
咱们开始。
上篇我们聊到，`type`本质上就是个类工厂，所有类都是它一手创建的。`class`语句背后，其实就是一次 `type()` 调用。
那么，如果我们也写一个自己的类工厂，用它来替换掉默认的 `type`，会发生什么？
## 第一个元类
其实，自己动手写一个元类并不复杂。它本质上就是一个继承了 `type` 的类。你只需要重写它的 `__new__` 方法，就能在类被创建的那一刻插入自己的逻辑。
```python
class SimpleMeta(type):
def __new__(mcs, name, bases, namespace):
print(f" 正在创建类: {name}")
cls = super().__new__(mcs, name, bases, namespace)
return cls
class MyClass(metaclass=SimpleMeta):
pass
# 输出: 正在创建类: MyClass
print(type(MyClass)) #
—— 不再是 type
```
看，就这么简单。在 `class MyClass(metaclass=SimpleMeta):` 这行里，`metaclass=SimpleMeta` 就是在告诉 Python：“嘿，创建 `MyClass` 的时候，别走默认的 `type()` 流程，用我的 `SimpleMeta()` 来搞。”
试试多创建几个类，你就能看到效果：
```python
class Another(metaclass=SimpleMeta):
pass
class AndAnother(metaclass=SimpleMeta):
pass
# 输出:
# 正在创建类: Another
# 正在创建类: AndAnother
```
每一个标记了 `SimpleMeta` 的类，都会走进 `__new__` 方法。这就是元类的精髓——**在类被创建的那一刻，截胡**。
### 这几个参数是干嘛的？
`__new__` 里的四个参数，和 `type()` 的三个参数是一一对应的：
| 参数 | 含义 | 来源 |
| :--- | :--- | :--- |
| `mcs` | 元类本身 | Python 自动传入 |
| `name` | 正在创建的类名 | 对应 `type()` 的第一个参数 |
| `bases` | 父类元组 | 对应 `type()` 的第二个参数 |
| `namespace` | 类体中定义的所有属性和方法的字典 | 对应 `type()` 的第三个参数 |
你可以试着把 `namespace` 打印出来看看，一切会更清晰：
```python
class DebugMeta(type):
def __new__(mcs, name, bases, namespace):
print(f" namespace = {namespace}")
return super().__new__(mcs, name, bases, namespace)
class Sample(metaclass=DebugMeta):
x = 10
def hello(self):
return "hi"
# 输出:
# namespace = {'__module__': '__main__', '__qualname__': 'Sample', 'x': 10, 'hello': }
```
看到了吧，`x = 10` 和 `def hello` 都老老实实地躺在字典里。这意味着你可以在元类里读它、改它，甚至任性到拒绝创建这个类。
## 实战一：自动注入属性
理解了参数，咱们来点实用的。假设你有一堆类，都需要一个叫 `version` 的默认属性，但你又不想在每个类里都手动写一遍。
```python
class AutoAttrMeta(type):
def __new__(mcs, name, bases, namespace):
cls = super().__new__(mcs, name, bases, namespace)
if not hasattr(cls, 'version'):
cls.version = "1.0"
return cls
class Service(metaclass=AutoAttrMeta):
pass
class AdvancedService(Service):
version = "2.0" # 自己定义了，不会被覆盖
class BasicService(metaclass=AutoAttrMeta):
pass
print(Service.version) # 1.0 ← 自动加上了
print(AdvancedService.version) # 2.0 ← 自己定义的，没被覆盖
print(BasicService.version) # 1.0 ← 也自动加上了
```
思路很直白：类建好后，扫一眼它有没有 `version` 属性，没有就顺手补上。
这就是元类最典型的用法——**在类被定义的那一刻，帮你把琐事办了**。Django 的 Model 类就是这么干的：你写了个 `class User(models.Model):`，背后的元类早就悄悄帮你插入了 `__tablename__`、`__fields__` 一堆东西。当个甩手掌柜，舒服。
## 实战二：在类定义时就拦住错误
元类还能用来做校验。与其让代码跑到一半才发现字段名拼写错了，不如在类定义的时候就让它直接报错。这才是真正的防御性编程。
```python
class LowercaseMeta(type):
def __new__(mcs, name, bases, namespace):
for attr_name in namespace:
if not attr_name.startswith('_') and attr_name != attr_name.lower():
raise TypeError(
f"类 '{name}' 中的属性 '{attr_name}' 必须全小写！"
)
return super().__new__(mcs, name, bases, namespace)
class GoodClass(metaclass=LowercaseMeta):
my_field = 1 # ✓ 小写
another_field = 2 # ✓ 小写
print(GoodClass.my_field) # 1 —— 没问题
try:
class BadClass(metaclass=LowercaseMeta):
BadField = 1 # ✗ 大写了！
except TypeError as e:
print(e) # 类 'BadClass' 中的属性 'BadField' 必须全小写！
```
可以想象一下，那个叫 `BadField` 的属性在类被定义的那一刻就被扼杀在摇篮里了。这个错误绝不会等到你调用某个方法时才突然冒出来吓你一跳——它在模块被 `import` 的瞬间就发生了，非常早，非常安全。
## 实战三：单例模式
单例模式大家都熟悉：一个类只能有一个实例。不管你怎么 `new`，拿到的都是同一个对象。
要实现这个，我们需要拦截的不是类的创建，而是**实例的创建**。回顾一下，当你写 `Foo()` 的时候，Python 实际上是在调用 `type.__call__()`。这个 `__call__` 会依次调用类的 `__new__` 和 `__init__`。元类可以重写这个 `__call__`，在实例化时插入自己的逻辑。
```python
class SingletonMeta(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
print(f" 创建 {cls.__name__} 的唯一实例")
cls._instances[cls] = super().__call__(*args, **kwargs)
else:
print(f" 返回已有实例")
return cls._instances[cls]
class Database(metaclass=SingletonMeta):
def __init__(self):
self.connection_id = id(self)
db1 = Database() # 创建 Database 的唯一实例
db2 = Database() # 返回已有实例
print(db1 is db2) # True —— 同一个对象
print(db1.connection_id == db2.connection_id) # True
```
调用链是这样的：
```
Database()
│
▼
SingletonMeta.__call__(Database) ← 元类拦截
│
├─ 第一次 → super().__call__() → Database.__new__() → Database.__init__()
│
└─ 之后 → 直接返回缓存的实例
```
可以这样理解：元类的 `__call__` 是站在 `类()` 这个操作之上的总调度，它来决定要不要去调用类的 `__new__` 和 `__init__`。
## 实战四：插件自动注册
最后一个例子，也是在实际项目中非常有用的——插件自动注册。你可以定义一堆子类，它们不需要任何手动注册操作，定义出来就自动出现在一个“注册表”里。
```python
class PluginMeta(type):
registry = {}
def __new__(mcs, name, bases, namespace):
cls = super().__new__(mcs, name, bases, namespace)
if name != "Base": # 跳过基类本身
mcs.registry[name] = cls
return cls
class Base(metaclass=PluginMeta):
pass
class AuthPlugin(Base):
def authenticate(self):
return "authenticated"
class LogPlugin(Base):
def log(self, msg):
return f"LOG: {msg}"
# 不需要手动注册，定义类的时候就完成了
print(list(PluginMeta.registry.keys())) # ['AuthPlugin', 'LogPlugin']
# 可以通过名字动态实例化
plugin = PluginMeta.registry["AuthPlugin"]()
print(plugin.authenticate()) # authenticated
```
这种“定义即注册”的模式在插件系统、策略模式、序列化框架里非常常见。本质上，就是利用了元类在类定义时执行的特性。
## 一个关键的细节：执行时机
最后，聊聊元类代码的执行时机。它是在什么时候跑的呢？
**是在类定义的时候，不是在实例化的时候。**
```python
class TraceMeta(type):
def __new__(mcs, name, bases, namespace):
print(f" [元类] 正在创建 {name}")
return super().__new__(mcs, name, bases, namespace)
print("开始定义类...")
class A(metaclass=TraceMeta):
pass
print("类定义完成")
# 输出:
# 开始定义类...
# [元类] 正在创建 A
# 类定义完成
```
可以很清楚地看到，当模块被 `import` 的那一刻，元类就已经跑完了。之后不管你对 `A` 进行多少次实例化，元类的 `__new__` 方法都不会再执行（当然，如果你重写了 `__call__`，那么每次实例化都会触发 `__call__`）。
## 回顾一下
到这里，我们已经掌握了元类最核心的几件事：
1. 元类就是一个继承自 `type` 的类工厂，重写 `__new__` 可以在类创建时做任何事。
2. 重写 `__call__` 可以拦截实例化，决定 `__new__` 和 `__init__` 是否被调用。
3. 元类的代码在类定义时执行，而不是实例化时。
当然，元类的能力远不止于此。它还能控制类的命名空间、自定义 `isinstance` 的行为、处理继承链上的元类冲突等等。
**下一篇，我们接着聊这些进阶内容，以及一个更重要的问题：什么时候该用元类，什么时候千万别用。** 
