如何动态地创建一个类？

type()

type()

type(name, bases, dict)

MyDynamicClass

object

value

greet

def dynamic_greet(self):
    return f"Hello from {self.name} with value {self.value}"

MyDynamicClass = type('MyDynamicClass', (object,), {
    'name': 'DefaultDynamic',
    'value': 100,
    'greet': dynamic_greet
})

# 使用这个动态创建的类
obj = MyDynamicClass()
print(obj.name)
print(obj.value)
print(obj.greet())

# 也可以动态添加方法或属性
def new_method(self, message):
    return f"This is a new method saying: {message}"

# 注意：直接添加到类字典中，会影响所有实例
MyDynamicClass.new_feature = new_method
print(obj.new_feature("World"))

# 而元类则提供了一种更深层次的控制。元类本身就是创建类的“类”。
# 默认情况下，所有类都是由`type`这个元类创建的。
# 当你定义一个类时，Python会调用其元类的`__new__`方法来创建类对象，
# 然后调用`__init__`方法来初始化这个类对象。
# 这意味着，如果你定义了自己的元类，就可以在类创建的整个过程中注入自定义逻辑。

class MyMeta(type):
    def __new__(cls, name, bases, dct):
        # 在这里可以修改或添加类属性、方法等
        # 比如，强制所有类名都以"Dynamic"开头
        if not name.startswith('Dynamic'):
            name = 'Dynamic' + name
        # 强制添加一个默认方法
        if 'version' not in dct:
            dct['version'] = '1.0'

        print(f"Creating class {name} using MyMeta...")
        # 确保调用父元类的__new__来实际创建类
        return super().__new__(cls, name, bases, dct)

    def __init__(cls, name, bases, dct):
        print(f"Initializing class {name} using MyMeta...")
        super().__init__(cls, name, bases, dct)
        # 可以在这里做一些后处理，比如注册类
        cls.registry[name] = cls

    registry = {} # 一个简单的注册表

class MyProduct(metaclass=MyMeta):
    # 这个类将由MyMeta创建
    def __init__(self, id):
        self.id = id

    def get_info(self):
        return f"Product ID: {self.id}, Version: {self.version}"

class AnotherProduct(metaclass=MyMeta):
    pass

p = MyProduct(123)
print(p.get_info())
print(MyProduct.version)
print(MyMeta.registry) # 查看注册表

class User(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()

models.Model

CharField

EmailField

User

save()

filter()

if/else

type()

type()

type()

# 示例：根据配置动态生成一个处理器类
def create_processor_class(config_name, process_logic):
    def process(self, data):
        print(f"Processing data with {self.name}: {data}")
        process_logic(data)

    return type(f"{config_name}Processor", (object,), {
        'name': config_name,
        'process': process
    })

# 动态创建两个不同的处理器
ProcessorA = create_processor_class("ConfigA", lambda d: print(f"Logic A for {d}"))
ProcessorB = create_processor_class("ConfigB", lambda d: print(f"Logic B for {d}"))

pa = ProcessorA()
pb = ProcessorB()
pa.process("data1")
pb.process("data2")

type()

type()

type()

dct