Python元类关键字参数无法被子类使用的问题排查

我尝试编写一个元类以辅助序列化，目的是尽可能让业务代码与序列化方式（如YAML或JSON）解耦，只需继承Serializable类即可无需过多关注序列化类型。现有YAML序列化代码基本可用，但我希望通过关键字参数指定Loader和Dumper（因PyYAML支持SafeLoader、FullLoader等）。我为Serializable类添加了Loader和Dumper关键字参数，该类可正常使用，但子类（如继承自Serializable的A类）的元类__new__方法无法获取到这些关键字参数，请问问题出在哪里？

import yaml

class SerializableMeta(type):
    @classmethod
    def __prepare__(cls, name, bases, **kwargs):
        return {"yaml_tag": None, "to_yaml": None, "from_yaml": None}

    def __new__(cls, name, bases, namespace, **kwargs):
        yaml_tag = f"!{name}"
        cls_ = super().__new__(cls, name, bases, namespace)
        cls_.yaml_tag = yaml_tag
        cls_.to_yaml = lambda dumper, obj: dumper.represent_mapping(yaml_tag, obj.__dict__)
        cls_.from_yaml = lambda loader, node: cls_(**loader.construct_mapping(node))
        kwargs["Dumper"].add_representer(cls_, cls_.to_yaml)
        kwargs["Loader"].add_constructor(yaml_tag, cls_.from_yaml)
        return cls_


class Serializable(metaclass=SerializableMeta, Dumper=yaml.Dumper, Loader=yaml.Loader):
    pass


class A(Serializable):
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def __repr__(self):
        return f"A({self.a}, {self.b})"

    def __eq__(self, other):
        if isinstance(other, A):
            return self.a == other.a and self.b == other.b
        else:
            return NotImplemented

问题原因 #

元类的**kwargs参数仅在显式定义类并指定metaclass参数时才会传入。子类继承父类时，Python不会自动将父类创建时传递给元类的关键字参数传递给子类的元类构造过程。因此创建子类A时，元类SerializableMeta的__new__方法无法获取到Loader和Dumper参数，会触发KeyError。

解决方案 #

将Loader和Dumper作为类属性存储在父类中，元类处理子类时从基类中提取这些属性；同时保留子类显式指定参数的灵活性。修改后的代码如下：

import yaml

class SerializableMeta(type):
    @classmethod
    def __prepare__(cls, name, bases, **kwargs):
        return {"yaml_tag": None, "to_yaml": None, "from_yaml": None}

    def __new__(cls, name, bases, namespace, **kwargs):
        yaml_tag = f"!{name}"
        cls_ = super().__new__(cls, name, bases, namespace)
        cls_.yaml_tag = yaml_tag
        cls_.to_yaml = lambda dumper, obj: dumper.represent_mapping(yaml_tag, obj.__dict__)
        cls_.from_yaml = lambda loader, node: cls_(**loader.construct_mapping(node))
        
        # 优先使用当前类传入的参数，无则从基类继承
        loader = kwargs.get("Loader")
        dumper = kwargs.get("Dumper")
        if not loader or not dumper:
            for base in bases:
                if hasattr(base, "Loader"):
                    loader = base.Loader
                if hasattr(base, "Dumper"):
                    dumper = base.Dumper
                if loader and dumper:
                    break
        
        if loader and dumper:
            # 将Loader/Dumper存为类属性，供后续子类继承
            cls_.Loader = loader
            cls_.Dumper = dumper
            dumper.add_representer(cls_, cls_.to_yaml)
            loader.add_constructor(yaml_tag, cls_.from_yaml)
        return cls_


class Serializable(metaclass=SerializableMeta, Dumper=yaml.Dumper, Loader=yaml.Loader):
    pass


class A(Serializable):
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def __repr__(self):
        return f"A({self.a}, {self.b})"

    def __eq__(self, other):
        if isinstance(other, A):
            return self.a == other.a and self.b == other.b
        else:
            return NotImplemented

# 测试序列化与反序列化
a = A(1, 2)
yaml_str = yaml.dump(a)
loaded_a = yaml.load(yaml_str, Loader=yaml.Loader)
print(loaded_a == a)  # 输出 True

方案说明 #

1. 参数继承逻辑：元类优先读取当前类创建时传入的Loader/Dumper参数，若未传入则遍历基类提取已存储的类属性。
2. 类属性存储：将Loader/Dumper存为类属性，确保子类继承后可直接获取，无需重复传递参数。
3. 灵活性保留：子类仍可通过显式传递参数覆盖父类的配置，例如：

   class B(Serializable, Loader=yaml.SafeLoader, Dumper=yaml.SafeDumper):
       pass
   

内容的提问来源于stack exchange，提问作者Steven Dickinson