Python 元编程怎么用于框架开发和数据校验？

先弄清楚：元编程到底在改什么

写 Python 框架时，经常会遇到一种需求：用户只写几行类定义，框架却能自动生成字段、校验规则、查询语句或接口对象。Django ORM、Pydantic、SQLAlchemy、表单库和很多 API SDK 都有这种味道。它们背后常用的就是元编程。

元编程的重点，是把“对象怎么创建、类怎么创建、属性怎么访问”这些过程开放出来。普通业务代码通常操作对象；元编程会再往前一步，操作类、方法、属性协议，甚至在运行时生成类。

常见工具包括：元类、动态属性、动态方法、描述符、property、type() 动态建类和类装饰器。它们适合做框架层能力，不太适合塞进每个业务函数里。

元类：控制类创建过程

在 Python 里，类本身也是对象。普通对象由类创建，类由元类创建。默认情况下，大部分类的元类都是 type。

python
class User:
    pass

u = User()

print(type(u))     # <class '__main__.User'>
print(type(User))  # <class 'type'>

如果要在“类被创建时”统一检查或改造类，就可以写自定义元类。比如下面这个元类要求类必须声明 required_attr，并给类补上一个标记属性：

python
class ValidateMeta(type):
    def __new__(mcls, name, bases, namespace):
        if name != 'Base' and 'required_attr' not in namespace:
            raise TypeError(f'{name} must define required_attr')

        namespace['created_by_meta'] = True
        return super().__new__(mcls, name, bases, namespace)

class Base(metaclass=ValidateMeta):
    pass

class Service(Base):
    required_attr = 'ok'

print(Service.created_by_meta)  # True

元类常见用途有三类：

• 收集声明式字段：ORM、表单、序列化框架会扫描类属性，把字段整理到 _fields 里。
• 约束类定义：要求子类必须声明某些属性或方法，或者必须带类型标注。
• 改变实例化行为：例如注册表、插件系统、单例缓存等。

单例也能用元类实现，但要谨慎。下面的写法会让同一个类只创建一个实例：

python
class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Config(metaclass=SingletonMeta):
    def __init__(self, value):
        self.value = value

c1 = Config('first')
c2 = Config('second')
print(c1 is c2)  # True
print(c1.value)  # second

注意这里第二次初始化仍然会执行 __init__，所以 value 被改成了 second。这类细节很容易被忽略，也是元类代码需要写清楚文档的原因。

动态属性和动态方法：让对象按规则响应

__getattr__ 会在正常属性查找失败后触发，适合做“按命名规则生成属性”的能力。__setattr__ 会拦截赋值，适合把外部赋值统一存进内部字典。

python
class DynamicRecord:
    def __init__(self):
        super().__setattr__('_data', {})

    def __setattr__(self, name, value):
        if name.startswith('_'):
            super().__setattr__(name, value)
        else:
            self._data[name] = value

    def __getattr__(self, name):
        if name.startswith('get_'):
            key = name[4:]
            return self._data.get(key)
        raise AttributeError(name)

record = DynamicRecord()
record.name = 'Alice'
record.age = 25

print(record.get_name)  # Alice
print(record.get_age)   # 25

动态方法可以直接挂到类上，也可以用 types.MethodType 绑定到某个实例上。区别是：挂到类上会成为所有实例的方法，绑定到实例上只影响当前对象。

python
import types

class Greeter:
    pass

def hello(self, name):
    return f'Hello, {name}'

Greeter.hello = hello
print(Greeter().hello('Alice'))  # Hello, Alice

def only_this(self):
    return 'only this instance'

g = Greeter()
g.only_this = types.MethodType(only_this, g)
print(g.only_this())

这里最好少碰 __getattribute__，因为它会拦截所有属性访问，包括内部属性。除非非常确定查找顺序和递归边界，否则调试成本会很高。

描述符：把属性访问做成可复用规则

只要一个对象实现了 __get__、__set__ 或 __delete__，它就可以作为描述符使用。描述符最适合做字段校验、懒加载、缓存属性、权限控制这类“每个字段都要同一套规则”的事情。

python
class ValidatedField:
    def __init__(self, expected_type, required=False, default=None):
        self.expected_type = expected_type
        self.required = required
        self.default = default
        self.name = None

    def __set_name__(self, owner, name):
        self.name = '_' + name

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return getattr(instance, self.name, self.default)

    def __set__(self, instance, value):
        if self.required and value is None:
            raise ValueError(f'{self.name} is required')
        if value is not None and not isinstance(value, self.expected_type):
            raise TypeError(f'{self.name} expects {self.expected_type.__name__}')
        setattr(instance, self.name, value)

class User:
    name = ValidatedField(str, required=True)
    age = ValidatedField(int, default=18)

u = User()
u.name = 'Alice'
u.age = 25
print(u.name, u.age)

property 其实也是描述符的一种常用封装。它更轻，适合单个类里的计算属性或受控赋值；如果同一套字段规则要在很多类里复用，描述符更合适。

python
class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value <= 0:
            raise ValueError('radius must be positive')
        self._radius = value

    @property
    def area(self):
        return 3.14159 * self._radius ** 2

circle = Circle(5)
print(circle.area)

用 type 动态创建类

type(name, bases, namespace) 可以在运行时创建类。它适合处理“类结构来自配置、数据库、接口 schema”的场景，比如根据 API schema 生成响应对象。

python
def __init__(self, name):
    self.name = name

def greet(self):
    return f'Hello, {self.name}'

DynamicUser = type(
    'DynamicUser',
    (object,),
    {
        '__init__': __init__,
        'greet': greet,
        'source': 'runtime'
    }
)

user = DynamicUser('Alice')
print(user.greet())
print(user.source)

动态类也能创建子类：

python
class BasePlugin:
    def run(self):
        return 'base'

Plugin = type('Plugin', (BasePlugin,), {
    'name': 'csv_importer',
    'run': lambda self: 'import csv'
})

print(Plugin().run())  # import csv

这类代码要注意可读性。动态生成的类最好保留清晰的类名、模块名和文档字符串，否则日志、报错和调试器里只会出现一堆看不懂的运行时对象。

类装饰器：很多时候比元类更顺手

类装饰器接收一个类，修改后再返回。它不改变类创建机制，理解成本比元类低。只是给类补方法、补属性或做注册时，优先考虑类装饰器。

python
registry = {}

def register(name):
    def decorator(cls):
        registry[name] = cls
        cls.plugin_name = name
        return cls
    return decorator

@register('email')
class EmailPlugin:
    pass

print(registry['email'] is EmailPlugin)
print(EmailPlugin.plugin_name)

类装饰器也能做轻量单例：

python
def singleton(cls):
    instance = None

    def wrapper(*args, **kwargs):
        nonlocal instance
        if instance is None:
            instance = cls(*args, **kwargs)
        return instance

    return wrapper

@singleton
class Database:
    pass

不过这种写法会把类替换成函数，类型检查、继承和调试信息可能受影响。生产代码里如果要保留完整类语义，通常会选择更明确的工厂函数或容器管理。

ORM、表单和 API 校验里的典型写法

ORM 是元编程最常见的应用之一。用户声明字段，元类收集字段，描述符控制赋值，模型基类负责初始化。这就是很多框架“少写配置”的来源。

python
class Field:
    def __init__(self, field_type, primary_key=False):
        self.field_type = field_type
        self.primary_key = primary_key
        self.name = None

    def __set_name__(self, owner, name):
        self.name = name

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__.get(self.name)

    def __set__(self, instance, value):
        if not isinstance(value, self.field_type):
            raise TypeError(f'{self.name} expects {self.field_type.__name__}')
        instance.__dict__[self.name] = value

class ModelMeta(type):
    def __new__(mcls, name, bases, namespace):
        fields = {
            key: value
            for key, value in namespace.items()
            if isinstance(value, Field)
        }
        namespace['_fields'] = fields
        return super().__new__(mcls, name, bases, namespace)

class Model(metaclass=ModelMeta):
    def __init__(self, **kwargs):
        for name in self._fields:
            if name in kwargs:
                setattr(self, name, kwargs[name])

    def to_dict(self):
        return {name: getattr(self, name) for name in self._fields}

class User(Model):
    id = Field(int, primary_key=True)
    name = Field(str)
    age = Field(int)

user = User(id=1, name='Alice', age=25)
print(user.to_dict())

表单校验也很像 ORM，只是字段目标从“数据库列”变成了“用户输入”。字段对象负责校验，表单基类负责按字段列表处理输入。

python
class FormField:
    def __init__(self, field_type, required=False, default=None):
        self.field_type = field_type
        self.required = required
        self.default = default
        self.name = None

    def __set_name__(self, owner, name):
        self.name = name

    def validate(self, value):
        if self.required and value is None:
            raise ValueError(f'{self.name} is required')
        if value is not None and not isinstance(value, self.field_type):
            raise TypeError(f'{self.name} has invalid type')

class FormMeta(type):
    def __new__(mcls, name, bases, namespace):
        namespace['_fields'] = {
            key: value for key, value in namespace.items()
            if isinstance(value, FormField)
        }
        return super().__new__(mcls, name, bases, namespace)

class Form(metaclass=FormMeta):
    def __init__(self, **data):
        for name, field in self._fields.items():
            value = data.get(name, field.default)
            field.validate(value)
            setattr(self, name, value)

class UserForm(Form):
    name = FormField(str, required=True)
    age = FormField(int, default=18)

form = UserForm(name='Alice')
print(form.name, form.age)

API 响应校验可以用类装饰器来做。接口 schema 变化时，装饰器负责注入 __init__ 和 validate，调用方仍然使用普通类。

python
def validated_response(schema):
    def decorator(cls):
        def validate(self, data):
            for field, field_type in schema.items():
                if field not in data:
                    raise ValueError(f'missing field: {field}')
                if not isinstance(data[field], field_type):
                    raise TypeError(f'{field} has invalid type')

        def __init__(self, data):
            self.validate(data)
            for key, value in data.items():
                setattr(self, key, value)

        cls.validate = validate
        cls.__init__ = __init__
        return cls

    return decorator

@validated_response({'name': str, 'age': int, 'email': str})
class UserResponse:
    pass

resp = UserResponse({'name': 'Alice', 'age': 25, 'email': 'a@example.com'})
print(resp.email)

选择哪种元编程工具

可以用一个简单判断来选：

• 只想控制单个属性的读取或赋值，用 property。
• 同一套属性规则要复用到多个类，用描述符。
• 想根据字段声明收集类信息，用元类。
• 只想给类补方法、补属性或做注册，用类装饰器。
• 类结构来自运行时配置，再考虑 type() 动态建类。
• 只是在对象上临时挂一个方法，用 types.MethodType 或直接给类赋函数。

元类能力最强，但通常不是第一选择。很多需求用描述符或类装饰器已经足够，而且更容易被同事读懂。

注意事项：性能、调试和文档

元编程会把一部分逻辑藏到类创建、属性访问或装饰阶段。代码能少写，但排查问题时要多看一层。

性能上，描述符、property、__getattr__ 都会参与属性访问路径。单次开销通常不大，但在高频循环、序列化大量对象、ORM 批量构造模型时可能放大。昂贵计算可以用缓存描述符：

python
class cached_property:
    def __init__(self, func):
        self.func = func
        self.name = func.__name__

    def __get__(self, instance, owner):
        if instance is None:
            return self
        if self.name not in instance.__dict__:
            instance.__dict__[self.name] = self.func(instance)
        return instance.__dict__[self.name]

调试上，动态生成的方法和类要保留可读名称。必要时设置 __name__、__qualname__、__module__ 和 __doc__，不要让错误栈只剩 wrapper 或 DynamicClass。

文档上，需要把隐式规则写明白：哪些属性会自动生成，什么时候触发校验，元类会给类添加哪些字段，装饰器会不会替换原类。元编程本身没错，麻烦通常来自规则藏得太深。

最后怎么取舍

Python 元编程适合放在框架边界：ORM 字段声明、表单校验、API 响应模型、插件注册、缓存属性和运行时类生成。它能把重复样板代码收起来，让使用者写更少的声明。

业务代码里则要克制。能用普通函数解决的，不必上元类；能用类装饰器解决的，不必改类创建流程；能用 property 写清楚的，不必做复杂描述符。好的元编程代码应该让调用方更简单，而不是让维护者猜半天。