Python 元类：创造类的"类工厂"

引言：从"手工造车"到"汽车工厂"

想象你造车：

手工造车（class 定义）：自己画图纸、敲钢板、拧螺丝——一次造一辆，灵活但慢；
汽车工厂（type()）：流水线作业，输入参数就自动组装——快，但流水线固定，车型单一；
定制工厂（元类 metaclass）：你先造一个"能造任意车型的工厂"，之后想要什么车，工厂自动调整生产线——先定义"怎么造车"，再批量造车。

元类就是 Python 的"定制工厂"——不是创建实例，而是创建类本身。

一、类是怎么来的？从 `class` 到 `type()`

1.1 常规方式：`class` 定义

python

class Hello(object):
    def hello(self, name='world'):
        print('Hello, %s.' % name)

Python 解释器遇到 class 时，运行时才创建这个类——不是编译时就定死的。

python

h = Hello()
print(type(Hello))   # <class 'type'>    ← Hello 的类型是 type
print(type(h))       # <class '__main__.Hello'>  ← h 的类型是 Hello

关键洞察：Hello 这个类，是 type 这个"类工厂"生产出来的。

1.2 进阶方式：`type()` 动态创建类

python

def fn(self, name='world'):
    print('Hello, %s.' % name)

# 等价于 class Hello(object): hello = fn
Hello = type('Hello', (object,), dict(hello=fn))

h = Hello()
h.hello()   # Hello, world.

type() 的三个参数：

参数	作用	类比
`'Hello'`	类名	车型名称
`(object,)`	父类集合	基于哪个底盘
`dict(hello=fn)`	方法/属性	配置清单

生活化理解：class Hello 是手工写图纸，type('Hello', ...) 是把图纸参数输入电脑，3D 打印出来——结果一样，方式不同。

二、元类：控制"类怎么被创造"

2.1 什么是元类？

实例 ← 由类创建
类   ← 由元类创建

层级	创建者	被创建者
实例	`Hello()`	`h`
类	`type` 或自定义元类	`Hello`
元类	`type`（元类的元类还是 type）	自定义元类

核心思想：元类是类的模板——你定义元类，然后用它来"生产"类。

2.2 第一个元类：给类自动加方法

python

# 元类必须继承 type
class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        # 给类添加一个 add 方法
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)

# 使用元类创建类
class MyList(list, metaclass=ListMetaclass):
    pass

# 测试
L = MyList()
L.add(1)
print(L)   # [1]

# 普通 list 没有 add 方法
L2 = list()
L2.add(1)  # ❌ AttributeError

__new__ 的四个参数：

参数	含义
`cls`	正在创建的类对象（还没真正出生）
`name`	类名（如 `'MyList'`）
`bases`	父类元组（如 `(list,)`）
`attrs`	属性/方法字典（如 `{'__module__': '__main__', ...}`）

生活化理解：ListMetaclass 是汽车改装厂——MyList 生产线上下来时，被加装了 add 功能，普通 list 没有走这条线，所以没这功能。

2.3 为什么不直接写 `add` 方法？

python

class MyList(list):
    def add(self, value):
        self.append(value)

确实更简单！ 元类是"杀鸡用牛刀"——只有在需要批量、动态、自动化修改类时才有价值。

三、元类实战：编写一个简易 ORM

3.1 ORM 是什么？

ORM（对象关系映射）：把数据库表的一行，变成 Python 的一个对象。

数据库世界	Python 世界
表 `User`	类 `User`
行 `id=1, name='Michael'`	实例 `u = User(id=1, name='Michael')`
SQL `INSERT INTO User...`	`u.save()`

目标：用户只写类定义，save() 自动生成 SQL——用户感觉不到 SQL 的存在。

3.2 用户期待的接口

python

class User(Model):
    id = IntegerField('id')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')

# 创建实例并保存
u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
u.save()   # 自动生成并执行 INSERT 语句

3.3 实现步骤

第一步：定义字段类型 `Field`

python

class Field(object):
    def __init__(self, name, column_type):
        self.name = name
        self.column_type = column_type

    def __str__(self):
        return '<%s:%s>' % (self.__class__.__name__, self.name)

class StringField(Field):
    def __init__(self, name):
        super().__init__(name, 'varchar(100)')

class IntegerField(Field):
    def __init__(self, name):
        super().__init__(name, 'bigint')

作用：StringField('username') 表示"这是数据库的 varchar 字段，字段名是 username"。

第二步：编写元类 `ModelMetaclass`

python

class ModelMetaclass(type):
    def __new__(cls, name, bases, attrs):
        # 排除 Model 本身
        if name == 'Model':
            return type.__new__(cls, name, bases, attrs)

        print('Found model: %s' % name)

        # 收集所有 Field 属性
        mappings = dict()
        for k, v in attrs.items():
            if isinstance(v, Field):
                print('Found mapping: %s ==> %s' % (k, v))
                mappings[k] = v

        # 从类属性中删除 Field（防止实例属性遮盖）
        for k in mappings.keys():
            attrs.pop(k)

        # 保存映射关系和表名
        attrs['__mappings__'] = mappings
        attrs['__table__'] = name   # 简化：表名 = 类名

        return type.__new__(cls, name, bases, attrs)

元类做了什么：

扫描：找出类里所有 Field 类型的属性；
收集：把属性名 → Field 对象的映射存到 __mappings__；
清理：从类属性中删除 Field，防止实例属性冲突；
标记：记录表名 __table__。

第三步：基类 `Model`

python

class Model(dict, metaclass=ModelMetaclass):
    def __init__(self, **kw):
        super().__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError("'Model' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value

    def save(self):
        fields = []
        params = []
        args = []
        for k, v in self.__mappings__.items():
            fields.append(v.name)
            params.append('?')
            args.append(getattr(self, k, None))

        sql = 'insert into %s (%s) values (%s)' % (
            self.__table__,
            ','.join(fields),
            ','.join(params)
        )
        print('SQL: %s' % sql)
        print('ARGS: %s' % str(args))

Model 继承 dict：让实例可以像字典一样存数据，u['name'] 或 u.name 都能访问。

第四步：用户使用

python

class User(Model):
    id = IntegerField('id')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')

u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
u.save()

输出：

Found model: User
Found mapping: id ==> <IntegerField:id>
Found mapping: name ==> <StringField:username>
Found mapping: email ==> <StringField:email>
Found mapping: password ==> <StringField:password>
SQL: insert into User (id,username,email,password) values (?,?,?,?)
ARGS: [12345, 'Michael', 'test@orm.org', 'my-pwd']

3.4 元类的"隐式继承"

python

class User(Model):   # 用户没写 metaclass！
    ...

用户定义 User 时没写 metaclass，但 Python 自动找到父类 Model 的 metaclass=ModelMetaclass，并用它来创建 User。

生活化理解：Model 是"定制工厂"的品牌，用户说"我要生产 User 牌汽车"，工厂自动用品牌标准流程——用户不需要知道工厂内部怎么运作。

四、知识链条：从实例到元类

实例（h = Hello()）
    ↑ 由谁创建？
类（Hello）
    ↑ 由谁创建？
type() 或 自定义元类（ListMetaclass / ModelMetaclass）
    ↑ 由谁创建？
type（元类的元类，终极工厂）

关键洞察：

class 定义 → Python 自动调用 type() 创建类；
metaclass=xxx → Python 调用 xxx 创建类，而不是 type；
元类是创建类的工具，让你能在"类出生前"修改它。

五、常见误区与避坑指南

5.1 误区一：元类是"高级特性，必须掌握"

错！元类是"非常专业的工具"，90% 的 Python 程序员一辈子用不到。

日常开发：用 class 定义类就够了；
框架开发（Django、SQLAlchemy）：才需要元类实现 ORM、插件系统等。

5.2 误区二：元类里写业务逻辑

python

class BadMetaclass(type):
    def __new__(cls, name, bases, attrs):
        # ❌ 在元类里连接数据库、发请求
        db.connect()
        return type.__new__(cls, name, bases, attrs)

修正：元类只负责修改类结构（加方法、改属性、收集信息），业务逻辑放类的方法里。

5.3 误区三：混淆 `new` 和 `init`

方法	时机	作用
`__new__`	类创建前	造出对象（可以修改类结构）
`__init__`	类创建后	初始化对象（不能改结构，只能改属性）

元类用 __new__，因为要在"类还没出生"时动手脚。

5.4 误区四：元类影响实例创建

python

class MyMeta(type):
    def __new__(cls, name, bases, attrs):
        attrs['x'] = 1
        return type.__new__(cls, name, bases, attrs)

class A(metaclass=MyMeta):
    pass

a = A()
print(a.x)   # 1，类属性被实例继承

元类修改的是类本身，不是实例。实例创建时，还是走 A() 的正常流程。

六、实际应用案例

案例 1：自动注册插件系统

python

class PluginMetaclass(type):
    """自动把所有插件类注册到全局插件表"""
    plugins = {}

    def __new__(cls, name, bases, attrs):
        new_class = type.__new__(cls, name, bases, attrs)
        if name != 'Plugin':   # 排除基类
            cls.plugins[name] = new_class
            print(f'插件已注册: {name}')
        return new_class

class Plugin(metaclass=PluginMetaclass):
    """插件基类"""
    def run(self):
        raise NotImplementedError

# 用户定义插件，自动注册，无需手动添加
class BackupPlugin(Plugin):
    def run(self):
        print('执行备份...')

class CleanPlugin(Plugin):
    def run(self):
        print('清理缓存...')

# 查看所有插件
print(PluginMetaclass.plugins)
# {'BackupPlugin': <class '__main__.BackupPlugin'>, 'CleanPlugin': <class '__main__.CleanPlugin'>}

# 动态执行
for name, plugin_cls in PluginMetaclass.plugins.items():
    plugin_cls().run()

生活化理解：PluginMetaclass 是公司前台——每个新员工（插件类）入职时自动登记到花名册，老板不用一个个手动加。

案例 2：API 接口自动参数校验

python

class APIMetaclass(type):
    """自动给 API 方法加参数类型检查"""
    def __new__(cls, name, bases, attrs):
        for attr_name, attr_value in attrs.items():
            if callable(attr_value) and not attr_name.startswith('_'):
                # 包装方法，加参数检查
                attrs[attr_name] = cls.wrap_with_check(attr_value)
        return type.__new__(cls, name, bases, attrs)

    @staticmethod
    def wrap_with_check(func):
        def wrapper(*args, **kwargs):
            print(f'[API] 调用 {func.__name__}，参数: {args[1:]}, {kwargs}')
            # 这里可以加类型检查、权限验证等
            return func(*args, **kwargs)
        return wrapper

class UserAPI(metaclass=APIMetaclass):
    def get_user(self, user_id):
        return {'id': user_id, 'name': 'Alice'}

    def create_user(self, name, age):
        return {'name': name, 'age': age}

# 使用
api = UserAPI()
api.get_user(123)
# [API] 调用 get_user，参数: (123,), {}
# {'id': 123, 'name': 'Alice'}

api.create_user('Bob', 25)
# [API] 调用 create_user，参数: ('Bob', 25), {}
# {'name': 'Bob', 'age': 25}

生活化理解：APIMetaclass 是机场安检——每个旅客（方法调用）都自动过一遍安检（参数检查），不用每个入口单独设安检员。

七、实战练习

练习：给所有类方法加日志

实现一个元类 LogMetaclass，让任何使用它的类，所有方法调用时自动打印日志：

python

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

class MyClass(metaclass=LogMetaclass):
    def hello(self):
        return 'world'

    def add(self, a, b):
        return a + b

# 测试
obj = MyClass()
obj.hello()      # 应打印: [LOG] 调用 hello
obj.add(1, 2)    # 应打印: [LOG] 调用 add

参考答案

python

class LogMetaclass(type):
    def __new__(cls, name, bases, attrs):
        for attr_name, attr_value in attrs.items():
            if callable(attr_value) and not attr_name.startswith('_'):
                attrs[attr_name] = cls.log_wrapper(attr_value)
        return type.__new__(cls, name, bases, attrs)

    @staticmethod
    def log_wrapper(func):
        def wrapper(*args, **kwargs):
            print(f'[LOG] 调用 {func.__name__}')
            return func(*args, **kwargs)
        return wrapper

八、小结

类的创建：class 定义 → Python 调用 type() → 类对象诞生；
type() 动态创建：type('Name', (bases,), dict(attrs)) 等价于 class 定义；
元类：继承 type，重写 __new__，在"类出生前"修改它；
使用方式：class MyClass(metaclass=MyMeta)，或父类声明后子类隐式继承；
核心价值：批量、自动化、框架级的类定制——ORM、插件系统、API 框架；
使用原则：99% 的情况不需要元类，需要时往往是写框架而非业务代码；
终极理解：元类是"类的类"——实例由类创建，类由元类创建，元类由 type 创建。

元类是 Python 的"元编程"终极武器——它让你在代码运行时动态创造代码，威力巨大，但也像核武器：不轻易使用，一旦使用，影响深远。

Python 元类：创造类的"类工厂" ​

引言：从"手工造车"到"汽车工厂" ​

一、类是怎么来的？从 class 到 type() ​

1.1 常规方式：class 定义 ​

1.2 进阶方式：type() 动态创建类 ​

二、元类：控制"类怎么被创造" ​

2.1 什么是元类？ ​

2.2 第一个元类：给类自动加方法 ​

2.3 为什么不直接写 add 方法？ ​

三、元类实战：编写一个简易 ORM ​

3.1 ORM 是什么？ ​

3.2 用户期待的接口 ​

3.3 实现步骤 ​

第一步：定义字段类型 Field ​

第二步：编写元类 ModelMetaclass ​

第三步：基类 Model ​

第四步：用户使用 ​

3.4 元类的"隐式继承" ​

四、知识链条：从实例到元类 ​

五、常见误区与避坑指南 ​

5.1 误区一：元类是"高级特性，必须掌握" ​

5.2 误区二：元类里写业务逻辑 ​

5.3 误区三：混淆 __new__ 和 __init__ ​

5.4 误区四：元类影响实例创建 ​

六、实际应用案例 ​

案例 1：自动注册插件系统 ​

案例 2：API 接口自动参数校验 ​

七、实战练习 ​

练习：给所有类方法加日志 ​

八、小结 ​

Python 元类：创造类的"类工厂"

引言：从"手工造车"到"汽车工厂"

一、类是怎么来的？从 `class` 到 `type()`

1.1 常规方式：`class` 定义

1.2 进阶方式：`type()` 动态创建类

二、元类：控制"类怎么被创造"

2.1 什么是元类？

2.2 第一个元类：给类自动加方法

2.3 为什么不直接写 `add` 方法？

三、元类实战：编写一个简易 ORM

3.1 ORM 是什么？

3.2 用户期待的接口

3.3 实现步骤

第一步：定义字段类型 `Field`

第二步：编写元类 `ModelMetaclass`

第三步：基类 `Model`

第四步：用户使用

3.4 元类的"隐式继承"

四、知识链条：从实例到元类

五、常见误区与避坑指南

5.1 误区一：元类是"高级特性，必须掌握"

5.2 误区二：元类里写业务逻辑

5.3 误区三：混淆 `new` 和 `init`

5.4 误区四：元类影响实例创建

六、实际应用案例

案例 1：自动注册插件系统

案例 2：API 接口自动参数校验

七、实战练习

练习：给所有类方法加日志

八、小结