元类：class 语句背后发生的事

class VolumeHandler:
    command = "volume"
    def handle(self, payload): ...

class PlayHandler:
    command = "play"
    def handle(self, payload): ...

HANDLERS = {
    "volume": VolumeHandler,
    "play": PlayHandler,
    # 每加一个类都要回来加一行，忘了就 404
}

class Handler:
    command: str = ""
    registry: dict[str, type] = {}

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        if cls.command:
            Handler.registry[cls.command] = cls

class VolumeHandler(Handler):
    command = "volume"
    def handle(self, payload): return f"vol {payload}"

class PlayHandler(Handler):
    command = "play"
    def handle(self, payload): return f"play {payload}"

print(Handler.registry)

{'volume': <class '__main__.VolumeHandler'>, 'play': <class '__main__.PlayHandler'>}

class Dog:
    pass

print(type(Dog))          # Dog 这个对象的类型
print(type(type))         # type 自己的类型是……自己

<class 'type'>
<class 'type'>

def bark(self):
    return f"{self.name}: woof"

Dog = type(
    "Dog",                       # 类名
    (object,),                   # 基类元组
    {
        "__init__": lambda self, name: setattr(self, "name", name),
        "bark": bark,
    },
)

print(Dog("Rex").bark())
print(type(Dog))

Rex: woof
<class 'type'>

class Field:
    """字段描述符：负责存取与类型检查。"""
    def __init__(self, column_type):
        self.column_type = column_type
        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):
        expected = {"INTEGER": int, "TEXT": str, "REAL": float}.get(self.column_type)
        if expected and not isinstance(value, expected) and value is not None:
            raise TypeError(f"{self.name} 期望 {expected.__name__}，来了 {type(value).__name__}")
        instance.__dict__[self.name] = value

class ModelMeta(type):
    """造类时顺手收集所有 Field，拼成表结构。"""
    def __new__(mcs, name, bases, namespace, **kwargs):
        cls = super().__new__(mcs, name, bases, namespace, **kwargs)
        columns = {}
        for base in bases:                     # 先继承父类字段
            columns.update(getattr(base, "_columns", {}))
        for key, value in namespace.items():   # 再收本类字段
            if isinstance(value, Field):
                columns[key] = value
        cls._columns = columns
        cls.__table__ = namespace.get("__table__", name.lower())
        return cls

class Model(metaclass=ModelMeta):
    def to_insert_sql(self):
        cols = ", ".join(self._columns)
        vals = ", ".join(repr(getattr(self, c)) for c in self._columns)
        return f"INSERT INTO {self.__table__} ({cols}) VALUES ({vals});"

class Product(Model):
    id = Field("INTEGER")
    name = Field("TEXT")
    price = Field("REAL")

print(Product.__table__, list(Product._columns))
p = Product()
p.id, p.name, p.price = 1, "widget", 9.9
print(p.to_insert_sql())
p.price = "九块九"

product ['id', 'name', 'price']
INSERT INTO product (id, name, price) VALUES (1, 'widget', 9.9);
TypeError: price 期望 float，来了 str

class TrackingMeta(type):
    @classmethod
    def __prepare__(mcs, name, bases, **kwargs):
        return {}          # 换成任意 Mapping 子类即可定制类体行为

class MetaA(type): pass
class MetaB(type): pass
class A(metaclass=MetaA): pass
class B(metaclass=MetaB): pass

class C(A, B):        # 谁来造 C？
    pass

Traceback (most recent call last):
  ...
TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases

class MetaAB(MetaA, MetaB):
    pass

class C(A, B, metaclass=MetaAB):
    pass

print(type(C))

<class '__main__.MetaAB'>