在Python中创建嵌套数据类对象

Question

我有一个数据类对象，其中包含嵌套的数据类对象。但是，当我创建主对象时，嵌套的对象会变成字典：

@dataclass
class One:
    f_one: int
    f_two: str
    
@dataclass
class Two:
    f_three: str
    f_four: One


Two(**{'f_three': 'three', 'f_four': {'f_one': 1, 'f_two': 'two'}})

Two(f_three='three', f_four={'f_one': 1, 'f_two': 'two'})

obj = {'f_three': 'three', 'f_four': One(**{'f_one': 1, 'f_two': 'two'})}

Two(**obj)
Two(f_three='three', f_four=One(f_one=1, f_two='two'))

如您所见，只有**obj有效。

理想情况下，我想构造我的对象来获得这样的东西：

Two(f_three='three', f_four=One(f_one=1, f_two='two'))

除了在访问对象属性时手动将嵌套字典转换为相应的数据类对象之外，还有别的方法可以实现这一点吗？

Answer 1

您可以尝试dacite模块。这个包简化了从字典创建数据类-它还支持嵌套结构。

例子：

from dataclasses import dataclass
from dacite import from_dict

@dataclass
class A:
    x: str
    y: int

@dataclass
class B:
    a: A

data = {
    'a': {
        'x': 'test',
        'y': 1,
    }
}

result = from_dict(data_class=B, data=data)

assert result == B(a=A(x='test', y=1))

要安装英安岩，只需使用pip:

$ pip install dacite

Answer 2

为此，您可以使用post_init

from dataclasses import dataclass
@dataclass
class One:
    f_one: int
    f_two: str

@dataclass
class Two:
    f_three: str
    f_four: One
    def __post_init__(self):
        self.f_four = One(**self.f_four)

data = {'f_three': 'three', 'f_four': {'f_one': 1, 'f_two': 'two'}}

print(Two(**data))
# Two(f_three='three', f_four=One(f_one=1, f_two='two'))

Answer 3

这是一个与dataclasses模块本身一样复杂的请求，这意味着实现这种“嵌套字段”功能的最佳方法可能是定义一个新的修饰符，类似于@dataclass。

幸运的是，如果您不需要__init__方法的签名来反映字段及其默认值，例如通过调用dataclass呈现的类，这可以简单得多：一个类装饰器将调用原始dataclass并在其生成的__init__方法上包装一些功能，可以用一个简单的"…（*args，**kwargs）："样式函数来完成。

换句话说，所需要做的就是围绕生成的__init__方法编写一个包装器，该包装器将检查以“kwargs”传递的参数，检查是否有任何参数对应于“数据类字段类型”，如果有，则在调用原始__init__之前生成嵌套对象。也许这在英语中比在Python中更难拼写：

from dataclasses import dataclass, is_dataclass

def nested_dataclass(*args, **kwargs):
    def wrapper(cls):
        cls = dataclass(cls, **kwargs)
        original_init = cls.__init__
        def __init__(self, *args, **kwargs):
            for name, value in kwargs.items():
                field_type = cls.__annotations__.get(name, None)
                if is_dataclass(field_type) and isinstance(value, dict):
                     new_obj = field_type(**value)
                     kwargs[name] = new_obj
            original_init(self, *args, **kwargs)
        cls.__init__ = __init__
        return cls
    return wrapper(args[0]) if args else wrapper

注意，除了不用担心< code>__init__签名之外，这还忽略了传递< code>init=False -因为这无论如何都是没有意义的。

（返回行中的 if 负责使用命名参数调用或直接作为装饰器（如数据类本身）工作）

并在互动提示上：

In [85]: @dataclass
    ...: class A:
    ...:     b: int = 0
    ...:     c: str = ""
    ...:         

In [86]: @dataclass
    ...: class A:
    ...:     one: int = 0
    ...:     two: str = ""
    ...:     
    ...:         

In [87]: @nested_dataclass
    ...: class B:
    ...:     three: A
    ...:     four: str
    ...:     

In [88]: @nested_dataclass
    ...: class C:
    ...:     five: B
    ...:     six: str
    ...:     
    ...:     

In [89]: obj = C(five={"three":{"one": 23, "two":"narf"}, "four": "zort"}, six="fnord")

In [90]: obj.five.three.two
Out[90]: 'narf'

如果希望保留签名，我建议使用dataclasses模块本身中的私有helper函数来创建一个新的__init__。