Question

3.7中的标准库可以将数据类递归转换为dict（来自文档的示例）：

from dataclasses import dataclass, asdict
from typing import List

@dataclass
class Point:
     x: int
     y: int

@dataclass
class C:
     mylist: List[Point]

p = Point(10, 20)
assert asdict(p) == {'x': 10, 'y': 20}

c = C([Point(0, 0), Point(10, 4)])
tmp = {'mylist': [{'x': 0, 'y': 0}, {'x': 10, 'y': 4}]}
assert asdict(c) == tmp

我正在寻找一种在嵌套时将dict转换回数据类的方法。 C(**tmp)之类的东西只有在数据类的字段是简单类型而不是数据类本身的情况下才起作用。我熟悉jsonpickle，但是它带有突出的安全警告。

Answer 1

下面是asdict的CPython实现 –或明确地说，它使用的内部递归辅助函数_asdict_inner：

# Source: https://github.com/python/cpython/blob/master/Lib/dataclasses.py

def _asdict_inner(obj, dict_factory):
    if _is_dataclass_instance(obj):
        result = []
        for f in fields(obj):
            value = _asdict_inner(getattr(obj, f.name), dict_factory)
            result.append((f.name, value))
        return dict_factory(result)
    elif isinstance(obj, tuple) and hasattr(obj, '_fields'):
        # [large block of author comments]
        return type(obj)(*[_asdict_inner(v, dict_factory) for v in obj])
    elif isinstance(obj, (list, tuple)):
        # [ditto]
        return type(obj)(_asdict_inner(v, dict_factory) for v in obj)
    elif isinstance(obj, dict):
        return type(obj)((_asdict_inner(k, dict_factory),
                          _asdict_inner(v, dict_factory))
                         for k, v in obj.items())
    else:
        return copy.deepcopy(obj)

asdict只是通过一些断言来调用上述内容，默认情况下是dict_factory=dict。

如何修改它以创建带有所需类型标记的输出字典，如评论中所述？

1。添加类型信息

我的尝试涉及创建自dict继承的自定义返回包装：

class TypeDict(dict):
    def __init__(self, t, *args, **kwargs):
        super(TypeDict, self).__init__(*args, **kwargs)

        if not isinstance(t, type):
            raise TypeError("t must be a type")

        self._type = t

    @property
    def type(self):
        return self._type

查看原始代码，只需修改第一个子句即可使用此包装，因为其他子句仅处理dataclass-es的容器：

# only use dict for now; easy to add back later
def _todict_inner(obj):
    if is_dataclass_instance(obj):
        result = []
        for f in fields(obj):
            value = _todict_inner(getattr(obj, f.name))
            result.append((f.name, value))
        return TypeDict(type(obj), result)

    elif isinstance(obj, tuple) and hasattr(obj, '_fields'):
        return type(obj)(*[_todict_inner(v) for v in obj])
    elif isinstance(obj, (list, tuple)):
        return type(obj)(_todict_inner(v) for v in obj)
    elif isinstance(obj, dict):
        return type(obj)((_todict_inner(k), _todict_inner(v))
                         for k, v in obj.items())
    else:
        return copy.deepcopy(obj)

进口：

from dataclasses import dataclass, fields, is_dataclass

# thanks to Patrick Haugh
from typing import *

# deepcopy 
import copy

使用的功能：

# copy of the internal function _is_dataclass_instance
def is_dataclass_instance(obj):
    return is_dataclass(obj) and not is_dataclass(obj.type)

# the adapted version of asdict
def todict(obj):
    if not is_dataclass_instance(obj):
         raise TypeError("todict() should be called on dataclass instances")
    return _todict_inner(obj)

使用示例数据类进行测试：

c = C([Point(0, 0), Point(10, 4)])

print(c)
cd = todict(c)

print(cd)
# {'mylist': [{'x': 0, 'y': 0}, {'x': 10, 'y': 4}]}

print(cd.type)
# <class '__main__.C'>

结果符合预期。

2。转换回dataclass

asdict使用的递归例程可以重新用于反向过程，但需要进行一些相对较小的更改：

def _fromdict_inner(obj):
    # reconstruct the dataclass using the type tag
    if is_dataclass_dict(obj):
        result = {}
        for name, data in obj.items():
            result[name] = _fromdict_inner(data)
        return obj.type(**result)

    # exactly the same as before (without the tuple clause)
    elif isinstance(obj, (list, tuple)):
        return type(obj)(_fromdict_inner(v) for v in obj)
    elif isinstance(obj, dict):
        return type(obj)((_fromdict_inner(k), _fromdict_inner(v))
                         for k, v in obj.items())
    else:
        return copy.deepcopy(obj)

使用的功能：

def is_dataclass_dict(obj):
    return isinstance(obj, TypeDict)

def fromdict(obj):
    if not is_dataclass_dict(obj):
        raise TypeError("fromdict() should be called on TypeDict instances")
    return _fromdict_inner(obj)

测试：

c = C([Point(0, 0), Point(10, 4)])
cd = todict(c)
cf = fromdict(cd)

print(c)
# C(mylist=[Point(x=0, y=0), Point(x=10, y=4)])

print(cf)
# C(mylist=[Point(x=0, y=0), Point(x=10, y=4)])

再次达到预期。

Answer 2

我是dacite的作者，该工具简化了从字典创建数据类的过程。

该库只有一个功能from_dict-这是用法的一个简单示例：

from dataclasses import dataclass
from dacite import from_dict

@dataclass
class User:
    name: str
    age: int
    is_active: bool

data = {
    'name': 'john',
    'age': 30,
    'is_active': True,
}

user = from_dict(data_class=User, data=data)

assert user == User(name='john', age=30, is_active=True)

此外，dacite支持以下功能：

嵌套结构
（基本）类型检查
可选字段（即键入。Optional）
联盟
收藏
价值转型和转型
重新映射字段名称

...而且经过了良好的测试-100％的代码覆盖率！

要安装dacite，只需使用pip（或pipenv）：

$ pip install dacite

Answer 3

您可以使用mashumaro根据该方案从字典创建数据类对象。来自该库的Mixin向数据类添加了方便的from_dict和to_dict方法：

from dataclasses import dataclass
from typing import List
from mashumaro import DataClassDictMixin

@dataclass
class Point(DataClassDictMixin):
     x: int
     y: int

@dataclass
class C(DataClassDictMixin):
     mylist: List[Point]

p = Point(10, 20)
tmp = {'x': 10, 'y': 20}
assert p.to_dict() == tmp
assert Point.from_dict(tmp) == p

c = C([Point(0, 0), Point(10, 4)])
tmp = {'mylist': [{'x': 0, 'y': 0}, {'x': 10, 'y': 4}]}
assert c.to_dict() == tmp
assert C.from_dict(tmp) == c

Answer 4

如果您的目标是从现有的，预定义的数据类中生成 JSON ，然后编写自定义的编码器和解码器挂钩。请勿在此处使用dataclasses.asdict()，而应在JSON中记录对原始数据类的（安全）引用。

jsonpickle是不安全的，因为它存储对任意 Python对象的引用，并将数据传递给它们的构造函数。通过这样的引用，我可以获得jsonpickle来引用内部Python数据结构并随意创建和执行函数，类和模块。但这并不意味着您不能不安全地处理此类引用。在使用它之前，只需验证您仅导入（而不是调用），然后验证该对象是实际的数据类类型即可。

可以使框架足够通用，但仍然仅限于JSON可序列化的类型加上基于dataclass的实例：

import dataclasses
import importlib
import sys

def dataclass_object_dump(ob):
    datacls = type(ob)
    if not dataclasses.is_dataclass(datacls):
        raise TypeError(f"Expected dataclass instance, got '{datacls!r}' object")
    mod = sys.modules.get(datacls.__module__)
    if mod is None or not hasattr(mod, datacls.__qualname__):
        raise ValueError(f"Can't resolve '{datacls!r}' reference")
    ref = f"{datacls.__module__}.{datacls.__qualname__}"
    fields = (f.name for f in dataclasses.fields(ob))
    return {**{f: getattr(ob, f) for f in fields}, '__dataclass__': ref}

def dataclass_object_load(d):
    ref = d.pop('__dataclass__', None)
    if ref is None:
        return d
    try:
        modname, hasdot, qualname = ref.rpartition('.')
        module = importlib.import_module(modname)
        datacls = getattr(module, qualname)
        if not dataclasses.is_dataclass(datacls) or not isinstance(datacls, type):
            raise ValueError
        return datacls(**d)
    except (ModuleNotFoundError, ValueError, AttributeError, TypeError):
        raise ValueError(f"Invalid dataclass reference {ref!r}") from None

这使用JSON-RPC-style class hints来命名数据类，并且在加载时被验证仍然是具有相同字段的数据类。不会对字段的值进行类型检查（因为这是完全不同的鱼）。

将它们用作default和object_hook的{{1}}和json.dump[s]()参数：

json.dump[s]()

或使用相同的钩子创建JSONEncoder和JSONDecoder类的实例。

除了使用完全限定的模块和类名之外，您还可以使用单独的注册表来映射允许的类型名；对照注册表进行编码，然后再进行解码，以确保您在开发时不会忘记注册数据类。

Answer 5

只需要五个衬里即可。

def dataclass_from_dict(klass, d):
    try:
        fieldtypes = {f.name:f.type for f in dataclasses.fields(klass)}
        return klass(**{f:dataclass_from_dict(fieldtypes[f],d[f]) for f in d})
    except:
        return d # Not a dataclass field

样品用量：

from dataclasses import dataclass, asdict

@dataclass
class Point:
    x: float
    y: float

@dataclass
class Line:
    a: Point
    b: Point

line = Line(Point(1,2), Point(3,4))
assert line == dataclass_from_dict(Line, asdict(line))

完整代码，包括往返于json的代码，此处为要点：https://gist.github.com/gatopeich/1efd3e1e4269e1e98fae9983bb914f22

Answer 6

不使用其他模块，您可以使用__post_init__函数将dict值自动转换为正确的类型。在__init__之后调用此函数。

from dataclasses import dataclass, asdict


@dataclass
class Bar:
    fee: str
    far: str

@dataclass
class Foo:
    bar: Bar

    def __post_init__(self):
        if isinstance(self.bar, dict):
            self.bar = Bar(**self.bar)

foo = Foo(bar=Bar(fee="La", far="So"))

d= asdict(foo)
print(d)  # {'bar': {'fee': 'La', 'far': 'So'}}
o = Foo(**d)
print(o)  # Foo(bar=Bar(fee='La', far='So'))

此解决方案的另一个好处是能够使用非数据类对象。只要它的str函数可以被转换回，它就是公平的游戏。例如，它可以用于在内部将str字段保留为IP4Address。

Answer 7

我尚未提到的一个可能的解决方案是使用 dataclasses-json。此库提供 dataclass 实例与 JSON 之间的转换，以及与 dict 之间的转换（如 dacite 和 mashumaro，在之前的答案中已建议）。

dataclasses-json 需要用 @dataclass_json 和 @dataclass 修饰类。然后装饰类获得几个成员函数，用于与 JSON 和与 dict 之间的转换：

from_dict(...)
from_json(...)
to_dict(...)
to_json(...)

这是问题中原始代码的略微修改版本。我已经添加了所需的 @dataclass_json 装饰器和 assert，以便从 dict 转换为 Point 和 C 的实例：

from dataclasses import dataclass, asdict
from dataclasses_json import dataclass_json
from typing import List

@dataclass_json
@dataclass
class Point:
     x: int
     y: int

@dataclass_json
@dataclass
class C:
     mylist: List[Point]

p = Point(10, 20)

assert asdict(p) == {'x': 10, 'y': 20}
assert p == Point.from_dict({'x': 10, 'y': 20})

c = C([Point(0, 0), Point(10, 4)])

tmp = {'mylist': [{'x': 0, 'y': 0}, {'x': 10, 'y': 4}]}

assert asdict(c) == tmp
assert c == C.from_dict(tmp)

Answer 8

undictify是一个可能有用的库。这是一个最小的用法示例：

import json
from dataclasses import dataclass
from typing import List, NamedTuple, Optional, Any

from undictify import type_checked_constructor


@type_checked_constructor(skip=True)
@dataclass
class Heart:
    weight_in_kg: float
    pulse_at_rest: int


@type_checked_constructor(skip=True)
@dataclass
class Human:
    id: int
    name: str
    nick: Optional[str]
    heart: Heart
    friend_ids: List[int]


tobias_dict = json.loads('''
    {
        "id": 1,
        "name": "Tobias",
        "heart": {
            "weight_in_kg": 0.31,
            "pulse_at_rest": 52
        },
        "friend_ids": [2, 3, 4, 5]
    }''')

tobias = Human(**tobias_dict)

Answer 9

Validobj就是这样做的。与其他库相比，它提供了一个更简单的界面（目前仅提供一个功能），并强调了信息丰富的错误消息。例如，给定类似

的架构

import dataclasses
from typing import Optional, List


@dataclasses.dataclass
class User:
    name: str
    phone: Optional[str] = None
    tasks: List[str] = dataclasses.field(default_factory=list)

一个错误

>>> import validobj
>>> validobj.parse_input({
...      'phone': '555-1337-000', 'address': 'Somewhereville', 'nme': 'Zahari'}, User
... )
Traceback (most recent call last):
...
WrongKeysError: Cannot process value into 'User' because fields do not match.
The following required keys are missing: {'name'}. The following keys are unknown: {'nme', 'address'}.
Alternatives to invalid value 'nme' include:
  - name

All valid options are:
  - name
  - phone
  - tasks

查看给定字段上的错字。

Answer 10

from validated_dc import ValidatedDC
from dataclasses import dataclass

from typing import List, Union


@dataclass
class Foo(ValidatedDC):
    foo: int


@dataclass
class Bar(ValidatedDC):
    bar: Union[Foo, List[Foo]]


foo = {'foo': 1}
instance = Bar(bar=foo)
print(instance.get_errors())  # None
print(instance)               # Bar(bar=Foo(foo=1))

list_foo = [{'foo': 1}, {'foo': 2}]
instance = Bar(bar=list_foo)
print(instance.get_errors())  # None
print(instance)               # Bar(bar=[Foo(foo=1), Foo(foo=2)])

validated_dc：
https://github.com/EvgeniyBurdin/validated_dc

并查看更详细的示例：
https://github.com/EvgeniyBurdin/validated_dc/blob/master/examples/detailed.py

Answer 11

也支持列表的简单解决方案（并且可以扩展为其他通用用途）

from dataclasses import dataclass, asdict, fields, is_dataclass
from typing import List
from types import GenericAlias

def asdataclass(klass, d):
    if not is_dataclass(klass):
        return d
    values = {}
    for f in fields(klass):
        if isinstance(f.type, GenericAlias) and f.type.__origin__ == list:
            values[f.name] = [asdataclass(f.type.__args__[0], d2) for d2 in d[f.name]]
        else:
            values[f.name] = asdataclass(f.type,d[f.name])
    return klass(**values)

@dataclass
class Point:
    x: int
    y: int

@dataclass
class C:
    mylist: list[Point]
    title: str = ""

c = C([Point(0, 0), Point(10, 4)])

assert c == asdataclass(C, asdict(c))

基于https://stackoverflow.com/a/54769644/871166

Answer 12

我真的认为 gatopeich 在 this 答案中提出的概念是解决这个问题的最佳方法。

我已经修正并文明化了他的代码。这是从字典加载数据类的正确函数：

def dataclass_from_dict(cls: type, src: t.Mapping[str, t.Any]) -> t.Any:
    field_types_lookup = {
        field.name: field.type
        for field in dataclasses.fields(cls)
    }

    constructor_inputs = {}
    for field_name, value in src.items():
        try:
            constructor_inputs[field_name] = dataclass_from_dict(field_types_lookup[field_name], value)
        except TypeError as e:
            # type error from fields() call in recursive call
            # indicates that field is not a dataclass, this is how we are
            # breaking the recursion. If not a dataclass - no need for loading
            constructor_inputs[field_name] = value
        except KeyError:
            # similar, field not defined on dataclass, pass as plain field value
            constructor_inputs[field_name] = value

return cls(**constructor_inputs)

然后您可以使用以下内容进行测试：

@dataclass
class Point:
    x: float
    y: float


@dataclass
class Line:
    a: Point
    b: Point

p1, p2 = Point(1,1), Point(2,2)
line = Line(p1, p1)

assert line == dataclass_from_dict(Line, asdict(line))

Answer 13

我建议使用复合模式来解决此问题，主要优点是您可以继续向该模式添加类并让它们表现出相同的方式。

from dataclasses import dataclass
from typing import List


@dataclass
class CompositeDict:
    def as_dict(self):
        retval = dict()
        for key, value in self.__dict__.items():
            if key in self.__dataclass_fields__.keys():
                if type(value) is list:
                    retval[key] = [item.as_dict() for item in value]
                else:
                    retval[key] = value
        return retval

@dataclass
class Point(CompositeDict):
    x: int
    y: int


@dataclass
class C(CompositeDict):
    mylist: List[Point]


c = C([Point(0, 0), Point(10, 4)])
tmp = {'mylist': [{'x': 0, 'y': 0}, {'x': 10, 'y': 4}]}
assert c.as_dict() == tmp

请注意，您可以在CompositeDict类中采用一种工厂模式，该模式可以处理其他情况，例如嵌套字典，元组等，这将节省很多样板。

dict的Python数据类

13 个答案: