如何在 Python 中覆盖数据类属性的名称？

Question

我正在使用dataclass 解析（HTTP 请求/响应）JSON 对象，今天我遇到了一个问题，需要在我的类中使用 transformation/alias 属性名称。

from dataclasses import dataclass, asdict
from typing import List
import json


@dataclass
class Foo:
    foo_name: str # foo_name -> FOO NAME


@dataclass
class Bar:
    bar_name: str # bar_name -> barName


@dataclass
class Baz:
    baz_name: str # baz_name -> B A Z
    baz_foo: List[Foo] # baz_foo -> BAZ FOO
    baz_bar: List[Bar] # baz_bar -> BAZ BAR

目前：

# encode
baz_e = Baz("name", [{"foo_name": "one"}, {"foo_name": "two"}], [{"bar_name": "first"}])
json_baz_e = json.dumps(asdict(baz_e))
print(json_baz_e)
# {"baz_name": "name", "baz_foo": [{"foo_name": "one"}, {"foo_name": "two"}], "baz_bar": [{"bar_name": "first"}]}


# decode
json_baz_d = {
    "baz_name": "name", 
    "baz_foo": [{"foo_name": "one"}, {"foo_name": "two"}], 
    "baz_bar":[{"bar_name": "first"}]
}
baz_d = Baz(**json_baz_d) # back to class instance
print(baz_d)
# Baz(baz_name='name', baz_foo=[{'foo_name': 'one'}, {'foo_name': 'two'}], baz_bar=[{'bar_name': 'first'}])

预期：

# encode
baz_e = Baz("name", [{"FOO NAME": "one"}, {"FOO NAME": "two"}], [{"barName": "first"}])
json_baz_e = json.dumps(asdict(baz_e))


# decode
json_baz_d = {
    "B A Z": "name", 
    "BAZ FOO": [{"FOO NAME": "one"}, {"FOO NAME": "two"}], 
    "BAZ BAR":[{"barName": "first"}]
}
baz_d = Baz(**json_baz_d) # back to class instance

是唯一的解决方案dataclasses-json，还是没有额外的库仍有可能？

Answer 1

您当然可以为此使用 dataclasses-json，但是如果您不需要 marshmallow 架构的优势，您可以使用像 dataclass-wizard 这样的替代解决方案，即类似地，构建在数据类之上的 JSON 序列化库。它支持此处需要的 alias 字段映射；另一个好处是它在 Python stdlib 之外没有任何依赖项，除了 Python typing-extensions 模块。

有一个 few choices 可用于指定 alias 字段映射，但在下面的示例中，我选择了两个选项来说明：

• json_field，可以认为是dataclasses.field的别名
• 可以在元配置中为数据类指定的 json_key_to_field 映射

from dataclasses import dataclass
from typing import List

from dataclass_wizard import JSONWizard, json_field


@dataclass
class Foo:
    # pass all=True, so reverse mapping (field -> JSON) is also added
    foo_name: str = json_field('FOO NAME', all=True)


@dataclass
class Bar:
    # default key transform is `camelCase`, so alias is not needed here
    bar_name: str


@dataclass
class Baz(JSONWizard):

    class _(JSONWizard.Meta):
        json_key_to_field = {
            # Pass '__all__', so reverse mapping (field -> JSON) is also added
            '__all__': True,
            'B A Z': 'baz_name',
            'BAZ FOO': 'baz_foo',
            'BAZ BAR': 'baz_bar'
        }

    baz_name: str
    baz_foo: List[Foo]
    baz_bar: List[Bar]


# encode
baz_e = Baz("name", [Foo('one'), Foo('two')], [Bar('first')])
json_baz_d = baz_e.to_dict()

print(json_baz_d)
# {'B A Z': 'name', 'BAZ FOO': [{'FOO NAME': 'one'}, {'FOO NAME': 'two'}], 'BAZ BAR': [{'barName': 'first'}]}

# decode
baz_d = Baz.from_dict(json_baz_d)  # back to class instance

print(repr(baz_d))
# > Baz(baz_name='name', baz_foo=[Foo(foo_name='one'), Foo(foo_name='two')], baz_bar=[Bar(bar_name='first')])

# True
assert baz_e == baz_d

---

NB：我注意到我想指出的一件显而易见的事情，因为它似乎不会导致预期的行为。在上面的问题中，您似乎正在实例化一个 Baz 实例，如下所示：

baz_e = Baz("name", [{"foo_name": "one"}, {"foo_name": "two"}], [{"bar_name": "first"}])

但是，请注意，在这种情况下，baz_foo 字段的值是 Python dict 对象的列表，而不是 Foo 实例的列表。为了解决这个问题，在上述解决方案中，我将{"foo_name": "one"} 更改为Foo('one')。

Answer 2

dataclasses-json 的解决方案可能使代码更具可读性和更清晰。

pip install dataclasses-json

这个library 提供了一个简单的API，用于对dataclasses 与JSON 进行编码和解码。

import json
from typing import List
from dataclasses import dataclass, asdict, field
from dataclasses_json import config, dataclass_json


@dataclass_json
@dataclass
class Foo:
    foo_name: str = field(metadata=config(field_name="FOO NAME")) # foo_name -> FOO NAME


@dataclass_json
@dataclass
class Bar:
    bar_name: str = field(metadata=config(field_name="barName")) # bar_name -> barName


@dataclass_json
@dataclass
class Baz:
    baz_name: str = field(metadata=config(field_name="B A Z")) # baz_name -> B A Z
    baz_foo: List[Foo] = field(metadata=config(field_name="BAZ FOO")) # baz_foo -> BAZ FOO
    baz_bar: List[Bar] = field(metadata=config(field_name="BAZ BAR")) # baz_bar -> BAZ BAR


# encode
baz_e = Baz("name", [{"FOO NAME": "one"}, {"FOO NAME": "two"}], [{"barName": "first"}])
print(baz_e.to_dict())
# {'B A Z': 'name', 'BAZ FOO': [{'FOO NAME': 'one'}, {'FOO NAME': 'two'}], 'BAZ BAR': [{'barName': 'first'}]}


# decode
json_baz_d = {
    "B A Z": "name", 
    "BAZ FOO": [{"FOO NAME": "one"}, {"FOO NAME": "two"}], 
    "BAZ BAR":[{"barName": "first"}]
}
baz_d = Baz.from_dict(json_baz_d) # back to class instance
print(baz_d)
# Baz(baz_name='name', baz_foo=[Foo(foo_name='one'), Foo(foo_name='two')], baz_bar=[Bar(bar_name='first')])


# Mini test
test_from_to = Baz.from_json(baz_e.to_json())
print(test_from_to)
# Baz(baz_name='name', baz_foo=[Foo(foo_name='one'), Foo(foo_name='two')], baz_bar=[Bar(bar_name='first')])

test_to_from = Baz.to_json(test_from_to)
print(test_to_from)
# {"B A Z": "name", "BAZ FOO": [{"FOO NAME": "one"}, {"FOO NAME": "two"}], "BAZ BAR": [{"barName": "first"}]}

从 camelCase（或 kebab-case）编码或解码？

• JSON 字母大小写约定为 camelCase，在 Python 中成员约定为snake_case。

• 您可以将其配置为在类级别和字段级别从其他套管方案进行编码/解码。

from dataclasses import dataclass, field
from dataclasses_json import LetterCase, config, dataclass_json


# changing casing at the class level
@dataclass_json(letter_case=LetterCase.CAMEL)
@dataclass
class Foo:
    foo_bar: str
    foo_baz: str


f = Foo('one', 'two').to_json() 
print(f)
# {"fooBar": "one", "fooBaz": "two"}


# at the field level
@dataclass_json
@dataclass
class Foo:
    foo_bar: str = field(metadata=config(letter_case=LetterCase.CAMEL))
    foo_baz: str


f = Foo('one', 'two').to_json() 
print(f)
# {"fooBar": "one", "foo_baz": "two"}

ff = Foo.from_json(f)
print(ff)
# Foo(foo_bar='one', foo_baz='two')

注意：

• 如果出现错误：

ImportError: cannot import name '_TypedDictMeta' from 'typing_extensions'

您可能有旧版本的打字扩展，有必要将其更新到最新版本。

pip install typing-extensions -U