在 asdict 或序列化中將屬性包含在數據類中的推薦方法是什么？

Question

請注意，這類似於How to get @property methods in asdict? .

我有一個（凍結的）嵌套數據結構，如下所示。 定義了一些（完全）依賴於字段的屬性。

import copy
import dataclasses
import json
from dataclasses import dataclass

@dataclass(frozen=True)
class Bar:
    x: int
    y: int

    @property
    def z(self):
        return self.x + self.y

@dataclass(frozen=True)
class Foo:
    a: int
    b: Bar

    @property
    def c(self):
        return self.a + self.b.x - self.b.y

我可以序列化數據結構如下：

class CustomEncoder(json.JSONEncoder):
    def default(self, o):
        if dataclasses and dataclasses.is_dataclass(o):
            return dataclasses.asdict(o)
        return json.JSONEncoder.default(self, o)

foo = Foo(1, Bar(2,3))
print(json.dumps(foo, cls=CustomEncoder))

# Outputs {"a": 1, "b": {"x": 2, "y": 3}}

但是，我還想序列化屬性（ @property ）。 請注意，我不想使用__post_init__將屬性轉換為字段，因為我想凍結數據類。 我不想使用obj.__setattr__來處理凍結的字段。 我也不想預先計算 class 之外的屬性值並將它們作為字段傳遞。

我目前使用的解決方案是明確寫出每個 object 是如何序列化的，如下所示：

class CustomEncoder2(json.JSONEncoder):
    def default(self, o):
        if isinstance(o, Foo):
            return {
                "a": o.a,
                "b": o.b,
                "c": o.c
            }
        elif isinstance(o, Bar):
            return {
                "x": o.x,
                "y": o.y,
                "z": o.z
            }
        return json.JSONEncoder.default(self, o)

foo = Foo(1, Bar(2,3))
print(json.dumps(foo, cls=CustomEncoder2))

# Outputs {"a": 1, "b": {"x": 2, "y": 3, "z": 5}, "c": 0} as desired

對於幾層嵌套，這是可以管理的，但我希望有一個更通用的解決方案。 例如，這是一個（hacky）解決方案，它從數據類庫中猴子修補 _asdict_inner 實現。

def custom_asdict_inner(obj, dict_factory):
    if dataclasses._is_dataclass_instance(obj):
        result = []
        for f in dataclasses.fields(obj):
            value = custom_asdict_inner(getattr(obj, f.name), dict_factory)
            result.append((f.name, value))
        # Inject this one-line change
        result += [(prop, custom_asdict_inner(getattr(obj, prop), dict_factory)) for prop in dir(obj) if not prop.startswith('__')]
        return dict_factory(result)
    elif isinstance(obj, tuple) and hasattr(obj, '_fields'):
        return type(obj)(*[custom_asdict_inner(v, dict_factory) for v in obj])
    elif isinstance(obj, (list, tuple)):
        return type(obj)(custom_asdict_inner(v, dict_factory) for v in obj)
    elif isinstance(obj, dict):
        return type(obj)((custom_asdict_inner(k, dict_factory),
                          custom_asdict_inner(v, dict_factory))
                         for k, v in obj.items())
    else:
        return copy.deepcopy(obj)

dataclasses._asdict_inner = custom_asdict_inner

class CustomEncoder3(json.JSONEncoder):
    def default(self, o):
        if dataclasses and dataclasses.is_dataclass(o):
            return dataclasses.asdict(o)
        return json.JSONEncoder.default(self, o)

foo = Foo(1, Bar(2,3))
print(json.dumps(foo, cls=CustomEncoder3))

# Outputs {"a": 1, "b": {"x": 2, "y": 3, "z": 5}, "c": 0} as desired

是否有推薦的方法來實現我想要做的事情？

Answer 1

它似乎與一個方便的dataclass功能相矛盾：

Class(**asdict(obj)) == obj  # only for classes w/o nested dataclass attrs

如果你沒有找到任何相關的 pypi 包，你總是可以像這樣添加一個 2-liner：

from dataclasses import asdict as std_asdict

def asdict(obj):
    return {**std_asdict(obj),
            **{a: getattr(obj, a) for a in getattr(obj, '__add_to_dict__', [])}}

然后，您可以以自定義但簡短的方式在 dicts 中指定您想要的內容：

@dataclass
class A:
    f: str
    __add_to_dict__ = ['f2']

    @property
    def f2(self):
        return self.f + '2'



@dataclass
class B:
    f: str

print(asdict(A('f')))
print(asdict(B('f')))

：

{'f2': 'f2', 'f': 'f'}
{'f': 'f'}

Answer 2

沒有“推薦”的方式來包含我所知道的它們。

這里有一些似乎有效的東西，我認為它可以滿足您的眾多要求。 它定義了一個自定義編碼器，當對象是dataclass而不是猴子修補（私有） dataclasses._asdict_inner()時調用其自己的_asdict()方法。 _asdict()函數並將代碼封裝（捆綁）在使用它的客戶編碼器中.

像你一樣，我使用dataclasses.asdict()的當前實現作為指南/模板，因為你所要求的基本上只是一個定制版本。 作為property的每個字段的當前值是通過調用其__get__方法獲得的。

import copy
import dataclasses
from dataclasses import dataclass, field
import json
import re
from typing import List

class MyCustomEncoder(json.JSONEncoder):
    is_special = re.compile(r'^__[^\d\W]\w*__\Z', re.UNICODE)  # Dunder name.

    def default(self, obj):
        return self._asdict(obj)

    def _asdict(self, obj, *, dict_factory=dict):
        if not dataclasses.is_dataclass(obj):
            raise TypeError("_asdict() should only be called on dataclass instances")
        return self._asdict_inner(obj, dict_factory)

    def _asdict_inner(self, obj, dict_factory):
        if dataclasses.is_dataclass(obj):
            result = []
            # Get values of its fields (recursively).
            for f in dataclasses.fields(obj):
                value = self._asdict_inner(getattr(obj, f.name), dict_factory)
                result.append((f.name, value))
            # Add values of non-special attributes which are properties.
            is_special = self.is_special.match  # Local var to speed access.
            for name, attr in vars(type(obj)).items():
                if not is_special(name) and isinstance(attr, property):
                    result.append((name, attr.__get__(obj)))  # Get property's value.
            return dict_factory(result)
        elif isinstance(obj, tuple) and hasattr(obj, '_fields'):
            return type(obj)(*[self._asdict_inner(v, dict_factory) for v in obj])
        elif isinstance(obj, (list, tuple)):
            return type(obj)(self._asdict_inner(v, dict_factory) for v in obj)
        elif isinstance(obj, dict):
            return type(obj)((self._asdict_inner(k, dict_factory),
                              self._asdict_inner(v, dict_factory)) for k, v in obj.items())
        else:
            return copy.deepcopy(obj)


if __name__ == '__main__':

    @dataclass(frozen=True)
    class Bar():
        x: int
        y: int

        @property
        def z(self):
            return self.x + self.y


    @dataclass(frozen=True)
    class Foo():
        a: int
        b: Bar

        @property
        def c(self):
            return self.a + self.b.x - self.b.y

        # Added for testing.
        d: List = field(default_factory=lambda: [42])  # Field with default value.


    foo = Foo(1, Bar(2,3))
    print(json.dumps(foo, cls=MyCustomEncoder))

輸出：

{"a": 1, "b": {"x": 2, "y": 3, "z": 5}, "d": [42], "c": 0}

Answer 3

如果適用於您的解決方案，您可以在基礎 class 上定義屬性，並讓具體類實現這些屬性。 這適用於asdict 。

from dataclasses import asdict, dataclass, field

@dataclass
class Liquid:

    volume: int
    price: int
    total_cost: int = field(init=False)


class Milk(Liquid):

    volume: int
    price: int

    @property
    def total_cost(self):
        return self.volume * self.price


milk = Milk(10)

print(asdict(milk))
>>>{'volume': 10, 'price': 3, 'total_cost': 30}