在 Python 中，一切皆对象。我们平时定义的 “类（class）” 也是一个对象。既然类是对象，那么创建这些对象的 “类” 又是什么呢？答案就是——元类（Metaclass）。
Python 元类是什么？
简单来说，元类就是用来创建类的类。小伙伴们可以将它理解为 “类的工厂”。当我们使用 class 关键字定义一个类时，Python 解释器在背后实际上是使用元类来创建这个类的。默认情况下，Python 中所有类的元类都是 type。
为了更好地理解元类，我们可以从以下两个层面来思考：
- 对象是类的实例。
- 类是元类的实例。
因此，当我们执行 class MyClass: pass 这段代码时，MyClass 这个类本身就是一个对象，而创建 MyClass 这个对象的 “类”，就是元类 type。
注意: 再次强调：在 Python 中，一切皆对象。类也不例外，它本身就是一个对象（即 type 类的实例对象）。
示例 1：使用 type() 查看对象的类型
name = 'Jack'
age = 18
class MyClass:
pass
obj = MyClass()
print(type(name))
print(type(age))
print(type(MyClass))
print(type(obj))运行结果如下。
<class 'str'>
<class 'int'>
<class 'type'>
<class '__main__.MyClass'>分析：
我们可以通过 type() 函数来查看一个对象的类型，或者一个类的类型。从结果可以看出，MyClass 的类型是 type。
小伙伴们一定要清楚：任何类都是 type 的实例，而 type 是 Python 默认的元类。
如何创建 Python 元类？
在 Python 中，我们可以通过继承 type 类来创建自己的元类，并通过 __new__() 或 __init__() 这两个魔法方法来控制类的创建行为。
我们先来看一个使用 type() 函数直接创建类的例子。这相当于手动调用元类 type 来创建类。
示例 2：使用 type() 创建类
# 使用 type() 创建一个类
# type(name, bases, dict)
# name: 类的名称
# bases: 类的基类（元组形式）
# dict: 类的属性和方法（字典形式）
MyClass = type('MyClass', (), {'value': 666, 'greet': lambda self: 'Hello from MyClass'})
# 创建 MyClass 的实例
obj = MyClass()
print(obj.value)
print(obj.greet())运行结果如下。
666
Hello from MyClass分析：
type 本身就是一个元类，可以用来动态地创建类。在这个例子中，我们使用 type() 函数创建了一个名为 MyClass 的类。这个类没有基类（() 表示空元组），并且包含一个属性 value 和一个方法 greet()。
示例 3：创建自定义的元类
class MyMetaclass(type):
def __new__(cls, name, bases, dct):
# 在类创建之前可以做一些事情，比如添加属性或方法
dct['version'] = '1.0'
dct['info'] = lambda self: f'This is {self.__class__.__name__}, version {self.version}'
return super().__new__(cls, name, bases, dct)
class MyCustomClass(metaclass=MyMetaclass):
def __init__(self, data):
self.data = data
def get_data(self):
return self.data
# 创建 MyCustomClass 的实例
obj = MyCustomClass('Python is awesome')
print(obj.version)
print(obj.info())
print(obj.get_data())运行结果如下。
1.0
This is MyCustomClass, version 1.0
Python is awesome分析：
在这个例子中，我们定义了一个名为 “MyMetaclass” 的类，它继承自 type 类。在 MyMetaclass 类的 __new__() 方法中，我们修改了类的属性字典 dct，并添加了 version 属性和 info() 方法。也就是说，所有使用 MyMetaclass 作为元类创建的类，都会自动拥有这些属性和方法。
在 MyCustomClass 类的定义中，我们通过 metaclass=MyMetaclass 指定了它的元类。当运行代码时，MyMetaclass 的 __new__() 方法会在 MyCustomClass 定义时被调用，从而在其创建过程中注入了额外的功能。
Python 元类的应用
元类在实际开发中虽然不常用，但在某些高级场景下却非常有用，比如下面两个场景。
1. 自动注册类
当我们需要在程序启动时自动收集所有特定类型的类时，元类可以派上用场。
示例 4：元类用于收集特定类
class PluginMetaclass(type):
plugins = {}
def __new__(cls, name, bases, dct):
new_class = super().__new__(cls, name, bases, dct)
if name != 'BasePlugin': # 排除基类本身
PluginMetaclass.plugins[name] = new_class
return new_class
class BasePlugin(metaclass=PluginMetaclass):
def execute(self):
raise NotImplementedError('子类必须实现 execute() 方法')
class MyPluginA(BasePlugin):
def execute(self):
print('执行插件 A')
class MyPluginB(BasePlugin):
def execute(self):
print('执行插件 B')
# 打印所有注册的插件
print('已注册插件：', PluginMetaclass.plugins)
# 通过名称获取并执行插件
plugin_a = PluginMetaclass.plugins['MyPluginA']()
plugin_a.execute()
plugin_b = PluginMetaclass.plugins['MyPluginB']()
plugin_b.execute()运行结果如下。
已注册插件： {'MyPluginA': <class '__main__.MyPluginA'>, 'MyPluginB': <class '__main__.MyPluginB'>}
执行插件 A
执行插件 B分析：
PluginMetaclass 在创建每个插件类时，都会将其注册到 PluginMetaclass.plugins 字典中。这样，我们就可以在运行时方便地访问和管理所有定义的插件。
2. ORM（对象关系映射）框架
许多 ORM 框架（如 SQLAlchemy、Django ORM 等）都是利用元类来动态地为模型类添加数据库相关的属性和方法。我们可以模拟一个非常简单的 ORM 模型定义，请看下面例子。
示例 5：元类用于 ORM 框架
class ModelMetaclass(type):
def __new__(cls, name, bases, dct):
if name != 'BaseModel':
# 为每个模型类添加一个特殊的字段列表
fields = []
for key, value in dct.items():
if isinstance(value, str) and value.startswith('__field__'):
fields.append(key)
dct['_fields'] = fields
return super().__new__(cls, name, bases, dct)
class BaseModel(metaclass=ModelMetaclass):
pass
class User(BaseModel):
id = '__field__id'
name = '__field__name'
email = '__field__email'
password = 'hidden' # 这个不会被视为字段
class Product(BaseModel):
product_id = '__field__product_id'
name = '__field__name'
price = '__field__price'
print(f'User 模型的字段: {User._fields}')
print(f'Product 模型的字段: {Product._fields}')运行结果如下。
User 模型的字段: ['id', 'name', 'email']
Product 模型的字段: ['product_id', 'name', 'price']分析：
ModelMetaclass 在创建 User 和 Product 类时，会自动扫描类定义中的特定模式（这里是 __field__ 前缀的字符串属性），并将这些属性名收集到 _fields 列表中。这模拟了 ORM 框架如何通过元类来自动识别数据库表的列。
从前面几个例子可以看出，元类是 Python 中一个强大且高级的特性，它允许我们在类被创建时进行干预和修改，从而实现更灵活和自动化的编程模式。然而，由于元类本身的复杂性，在大多数情况下，我们通常不需要直接使用元类，而是通过继承和组合来解决问题。只有在确实需要控制类的创建过程时，才应该考虑使用元类。
