如何创建一个处理具有不同名称的嵌套字典的数据类？

Question

我正在使用英雄联盟 API 中的数据来学习 Python、JSON 和数据类。我使用英安岩创建了父类和子类，允许使用以下语法访问数据：champs.data['Ahri']['key']。但是，我想知道是否有一种方法可以创建一个将键作为字段返回的类，以便可以使用以下语法访问数据：champs.data.Ahri.key。

这是工作代码：

from dataclasses import dataclass
from dacite import from_dict

j1 = {'type': 'champion',
      'data': {'Aatrox': {'id': 'Aatrox', 'key': '266', 'name': 'Aatrox'},
      'Ahri': {'id': 'Ahri', 'key': '103', 'name': 'Ahri'}}}

@dataclass
class C:
    type: str
    data: dict

@dataclass
class P:
    type: str
    data: dict

champs = from_dict(data_class=P, data=j1)
champs.data['Ahri']['key']

Answer 1

如果是我，我可能会留下/制作 champions 一本字典。 访问它

然后像 champions['Ahri'].key一样

import dataclasses

@dataclasses.dataclass
class Champion:
    id: str
    key: str
    name: str

j1 = {
    'type': 'champion',
    'data': {
        'Aatrox': {'id': 'Aatrox', 'key': '266', 'name': 'Aatrox'},
        'Ahri': {'id': 'Ahri', 'key': '103', 'name': 'Ahri'}
    }
}

champions = {
    champion["id"]: Champion(**champion)
    for champion in j1["data"].values()
}

print(champions['Ahri'].key)

：结果 103

但是，如果您真的热衷于 champions.Ahri.key > 然后你可以将 Champions 实现为一个空类，并

import dataclasses

@dataclasses.dataclass
class Champion:
    id: str
    key: str
    name: str

@dataclasses.dataclass
class Champions:
    pass

j1 = {
    'type': 'champion',
    'data': {
        'Aatrox': {'id': 'Aatrox', 'key': '266', 'name': 'Aatrox'},
        'Ahri': {'id': 'Ahri', 'key': '103', 'name': 'Ahri'}
    }
}

champions = Champions()
for champion in j1["data"].values():
    setattr(champions, champion["id"], Champion(**champion))

print(champions.Ahri.key)

再次使用 setattr() 给出 103

注意：@dataclass 装饰器可能会被省略来自冠军()。

Answer 2

您可能获得的最接近的结果 - 至少以足够安全的方式 - 正如@JonSG建议的，使用champs.data['Ahri'].key。

这是一个使用 dataclass-wizard 的简单示例。它不像我所知的英安岩那样进行严格类型检查。

相反，它选择在可能的情况下进行隐式类型的强制转换，这在某些情况下很有用；您可以在下面看到一个示例 - 在本例中，将 str 转换为带注释的 int。

注意：此示例应适用于包含 __future__ 导入的 Python 3.7+。

from __future__ import annotations

from dataclasses import dataclass
from dataclass_wizard import fromdict


data = {
    'type': 'champion',
    'data': {
          'Aatrox': {'id': 'Aatrox', 'key': '266', 'name': 'Aatrox'},
          'Ahri': {'id': 'Ahri', 'key': '103', 'name': 'Ahri'},
    }
}


@dataclass
class P:
    type: str
    data: dict[str, Character]


@dataclass
class Character:
    id: str
    key: int
    name: str


champs = fromdict(P, data)

print(champs)
print(champs.data['Ahri'].key)

输出：

P(type='champion', data={'Aatrox': Character(id='Aatrox', key=266, name='Aatrox'), 'Ahri': Character(id='Ahri', key=103, name='Ahri')})
103

Answer 3

如何做到这一点

d = {
    "type": "champion",
    "data": {
        "Aatrox": {"id": "Aatrox", "key": "266", "name": "Aatrox"},
        "Ahri": {"id": "Ahri", "key": "103", "name": "Ahri"},
    },
}


def dict_to_class(d) -> object:
    if isinstance(d, dict):

        class C:
            pass

        for k, v in d.items():
            setattr(C, k, dict_to_class(v))
        return C
    else:
        return d


champ = dict_to_class(d)

print(champ.data.Ahri.key)
# 103

这里的关键是 setatter 内置方法，它接受一个对象、一个字符串和一些值，并在该对象上创建一个属性（字段），根据字符串命名并包含值。

不要这样做！

我必须强调，这样做几乎没有充分的理由。当处理未知形状的 JSON 数据时，表示它的正确方法是一个dict。

如果您确实知道数据的形状，则应该创建一个专门的数据类，如下所示：

from dataclasses import dataclass

d = {
    "type": "champion",
    "data": {
        "Aatrox": {"id": "Aatrox", "key": "266", "name": "Aatrox"},
        "Ahri": {"id": "Ahri", "key": "103", "name": "Ahri"},
    },
}

@dataclass
class Champion:
    id: str
    key: str
    name: str

champions = {name: Champion(**attributes) for name, attributes in d["data"].items()}

print(champions)
# {'Aatrox': Champion(id='Aatrox', key='266', name='Aatrox'), 'Ahri': Champion(id='Ahri', key='103', name='Ahri')}

print(champions["Aatrox"].key)
# 266

Answer 4

英安岩文档有一个关于 嵌套结构 的部分，非常接近您想要的内容。他们逐字使用的示例如下：

@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))

我们可以访问任意深度的字段，例如 result.ax == 'test'。

此数据与您的数据之间的关键区别在于 data 键下的字典具有具有任意值的键（Aatrox、Ahri 等） 。英安岩未设置为动态创建新的字段名称，因此您将获得的最好结果类似于@JonSG 的后半部分 answer，使用setattr动态构建新字段。

不过，让我们想象一下您将如何使用这些数据。也许您希望某个点能够迭代您的冠军，以便执行过滤/转换等。手术。可以迭代python中的字段，但你必须真正深入研究python内部，这意味着你的代码会更少可读/一般可理解。

更好的方法是采用以下方法之一：

1. 将 j1 预处理为适合您要使用的结构的形状，然后使用英安岩和适合新结构的 dataclass。例如，将 data 字典的值拉出到列表中也许是有意义的。
2. 使用英安岩分步进行处理。例如，如下所示：

from dataclasses import dataclass
from dacite import from_dict


@dataclass
class TopLevel:
    type: str
    data: dict


j1 = {
    "type": "champion",
    "data": {
        "Aatrox": {"id": "Aatrox", "key": "266", "name": "Aatrox"},
        "Ahri": {"id": "Ahri", "key": "103", "name": "Ahri"},
    },
}

champions = from_dict(data_class=TopLevel, data=j1)
# champions.data is a dict of dicts

@dataclass
class Champion:
    id: str
    key: str
    name: str


# transform champions.data into a dict of Champions
for k, v in champions.data.items():
    champions.data[k] = from_dict(data_class=Champion, data=v)

# now, you can do interesting things like the following filter operation
start_with_a = [
    champ for champ in champions.data.values() if champ.name.lower().startswith("a")
]
print(start_with_a)
# [Champion(id='Aatrox', key='266', name='Aatrox'), Champion(id='Ahri', key='103', name='Ahri')]