Python动态创建类：type、metaclass与类工厂实战

1. 为什么需要动态创建类

1.1 动态建类的典型应用场景

先说结论：动态创建class不是炫技，它是Python里处理"类结构在运行时才能确定"这类问题的标准解法。

我最早遇到这类需求是做配置驱动的采集系统。当时要对接十几个不同的数据源，每个数据源返回的字段都不一样，少的五六个，多的二十几个。如果用静态类，就得写十几个几乎一样的class，字段名改一下，__init__里赋值改一下，逻辑完全相同，纯纯的体力活。后来改成根据配置动态生成class，一份代码通吃全部数据源，改配置就能上线新数据源。

类似的场景还有很多，我简单列几个高频的：

• ORM框架：数据库表的字段在一开始并不知道，需要在读取表结构后动态生成Model类。
• 组件化/插件系统：根据配置文件、目录结构或者网络协议动态加载并构造不同类型的组件。
• 测试替身（Mock）：根据接口签名动态生成带特定方法的假类。
• DSL（领域特定语言）：将用户写的类 JSON 配置翻译成可执行的类。
• 数据序列化框架：根据数据schema的定义动态构造对应的数据载体类。

说白了，静态class解决的是"结构已知"的问题，动态class解决的是"结构未知、需要在运行时根据数据决定"的问题。两者并不是谁替代谁，而是面对不同约束条件时的不同工具。

1.2 动态创建与静态声明的关键差异

用静态方式声明一个类：

python复制class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say(self):
        return f"我是{self.name}，今年{self.age}岁"

用动态方式创建同样的类：

python复制def say(self):
    return f"我是{self.name}，今年{self.age}岁"

Person = type(
    'Person',
    (),
    {
        '__init__': lambda self, name, age: (setattr(self, 'name', name), setattr(self, 'age', age)),
        'say': say,
    }
)

两种写法产生的类，从行为上讲几乎是一样的，都能实例化、都能调用方法、都能被继承。但动态写法有几个静态写法做不到的优势：

• 类名、父类、方法、属性全部可以用变量代替，完全数据驱动。
• 可以在运行时决定这个类是否存在、叫什么名字、继承谁。
• 可以用一个函数批量生产一批结构相似但字段不同的类。

当然，动态创建也有代价。代码可读性降低，IDE自动补全几乎失效，代码中type('SomeName', (), {...})里的'SomeName'只是个字符串，重构工具根本追踪不到。这些坑后面我会专门讲。

2. 动态创建类的底层机制：type() 与类对象

2.1 类本身也是一个对象

要真正理解动态创建类，首先要接受一个关键认知：在Python里，类也是对象，一种特殊的对象，它的类型是 type。

你看：

python复制class Foo:
    pass

print(type(Foo))  # <class 'type'>

Foo是一个对象，这个对象的类型是type。也就是说，type是类的"模板工厂"，它会创建一个类对象。我们平时写的class语法，本质上是Python解释器帮我们调用了type来创建这个类对象。

这里可以做一个生活化类比：如果类是一把椅子的设计图纸，那么type就是打印图纸的机器。平时我们写class Foo，相当于手动把图画好交给机器复印；而动态创建，就是直接操作这台复印机，输入"图纸长什么样"的参数，让它当场印一张出来。

理解了这个，后面很多问题都会豁然开朗。

2.2 type() 的三个参数到底在做什么

type()函数有两种用法。一种我们很熟，查看对象的类型：

python复制print(type(42))  # <class 'int'>

另一种是创建新类：

python复制MyClass = type('MyClass', (BaseClass,), {'attr': 1, 'method': some_func})

三个参数分别对应一个类的三个核心组成部分：

看到没有，这三个参数恰好把一个类拆成了三个可编程的零件。name是字符串，bases是元组，dict是字典。字符串、元组、字典是什么？是数据。数据就可以从配置文件里读、从数据库里查、从网络接口里拿。

比如我们要"声明"一个类，但又不写死在代码里，可以用变量代替：

python复制class_name = 'Person'
parent_classes = (object,)
class_body = {'__init__': lambda self: None}

Person = type(class_name, parent_classes, class_body)
print(Person.__name__)  # Person
print(Person.__bases__)  # (<class 'object'>,)

这就是动态创建的核心要义：把原本写死在代码里的结构，替换成运行时才能确定的数据。

3. 实操：从零到一动态创建class

3.1 最小可用例子

先来一个最简单、能立刻跑起来的例子。假设你要创建一个表示"坐标点"的类，包含 x、y 两个属性和一个计算距离的方法：

python复制def distance(self, other):
    return ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5

Point = type(
    'Point',
    (),
    {
        'x': 0,
        'y': 0,
        'distance': distance,
    }
)

p1 = Point()
p2 = Point()
p2.x = 3
p2.y = 4

print(p1.x, p1.y)   # 0 0
print(p2.distance(p1))  # 5.0

这里有几个细节值得注意：

1. distance是一个普通的函数，在动态创建时被塞进了类的命名空间里，成为实例方法。
2. 实例方法第一个参数仍然要写self。动态创建并不会自动帮你处理这个，你传进去的函数声明什么签名，方法就是什么签名。
3. 类属性可以用dict来初始化，这里的x: 0, y: 0就是类的默认属性。

3.2 带构造、继承和实例方法的类

真实项目中肯定不能只有类属性，更多的是实例化时传入数据。我们来构造一个更完整的类，包含 __init__、继承和多态：

python复制class BaseEntity:
    table_name = 'b