如果你正在使用python 3.6+，你可以使用棉花糖-数据类。与上面列出的所有解决方案相反，它既简单，又类型安全:

from marshmallow_dataclass import dataclass

@dataclass
class User:
    name: str

user = User.Schema().load({"name": "Ramirez"})

使用python 3.7，我发现下面的代码非常简单有效。在本例中，将JSON从文件加载到字典中:

class Characteristic:
    def __init__(self, characteristicName, characteristicUUID):
        self.characteristicName = characteristicName
        self.characteristicUUID = characteristicUUID


class Service:
    def __init__(self, serviceName, serviceUUID, characteristics):
        self.serviceName = serviceName
        self.serviceUUID = serviceUUID
        self.characteristics = characteristics

class Definitions:
    def __init__(self, services):
        self.services = []
        for service in services:
            self.services.append(Service(**service))


def main():
    parser = argparse.ArgumentParser(
        prog="BLEStructureGenerator",
        description="Taking in a JSON input file which lists all of the services, "
                    "characteristics and encoded properties. The encoding takes in "
                    "another optional template services and/or characteristics "
                    "file where the JSON file contents are applied to the templates.",
        epilog="Copyright Brown & Watson International"
    )

    parser.add_argument('definitionfile',
                        type=argparse.FileType('r', encoding='UTF-8'),
                        help="JSON file which contains the list of characteristics and "
                             "services in the required format")
    parser.add_argument('-s', '--services',
                        type=argparse.FileType('r', encoding='UTF-8'),
                        help="Services template file to be used for each service in the "
                             "JSON file list")
    parser.add_argument('-c', '--characteristics',
                        type=argparse.FileType('r', encoding='UTF-8'),
                        help="Characteristics template file to be used for each service in the "
                             "JSON file list")

    args = parser.parse_args()
    definition_dict = json.load(args.definitionfile)
    definitions = Definitions(**definition_dict)

如果你正在寻找将JSON或任何复杂字典的类型安全反序列化到python类中，我强烈推荐python 3.7+的pydantic。它不仅有一个简洁的API(不需要编写“helper”样板)，可以与Python数据类集成，而且具有复杂和嵌套数据结构的静态和运行时类型验证。

使用示例:

from pydantic import BaseModel
from datetime import datetime

class Item(BaseModel):
    field1: str | int           # union
    field2: int | None = None   # optional
    field3: str = 'default'     # default values

class User(BaseModel):
    name: str | None = None
    username: str
    created: datetime           # default type converters
    items: list[Item] = []      # nested complex types

data = {
    'name': 'Jane Doe',
    'username': 'user1',
    'created': '2020-12-31T23:59:00+10:00',
    'items': [
        {'field1': 1, 'field2': 2},
        {'field1': 'b'},
        {'field1': 'c', 'field3': 'override'}
    ]
}

user: User = User(**data)

要了解更多细节和特性，请查看文档中的pydantic的rational部分。

这里有一个快速而肮脏的json pickle替代方案

import json

class User:
    def __init__(self, name, username):
        self.name = name
        self.username = username

    def to_json(self):
        return json.dumps(self.__dict__)

    @classmethod
    def from_json(cls, json_str):
        json_dict = json.loads(json_str)
        return cls(**json_dict)

# example usage
User("tbrown", "Tom Brown").to_json()
User.from_json(User("tbrown", "Tom Brown").to_json()).to_json()

这似乎是一个XY问题(问A实际问题在哪里B)。

问题的根源是:如何有效地引用/修改深嵌套的JSON结构，而不必做obj['foo']['bar'][42]['quux']，这带来了键入挑战，代码膨胀问题，可读性问题和错误捕获问题?

使用抢

from glom import glom

# Basic deep get

data = {'a': {'b': {'c': 'd'}}}

print(glom(data, 'a.b.c'))

它还将处理列表项:

我已经对一个简单的实现进行了基准测试:

def extract(J, levels):
    # Twice as fast as using glom
    for level in levels.split('.'):
        J = J[int(level) if level.isnumeric() else level]
    return J

．.． 并且在复杂的JSON对象上返回0.14ms，而朴素的impl则返回0.06ms。

它还可以处理复杂的查询，例如取出所有foo.bar.记录，其中.name == 'Joe Bloggs'

编辑:

另一种性能方法是递归地使用覆盖__getitem__和__getattr__的类:

class Ob:
    def __init__(self, J):
        self.J = J

    def __getitem__(self, index):
        return Ob(self.J[index])

    def __getattr__(self, attr):
        value = self.J.get(attr, None)
        return Ob(value) if type(value) in (list, dict) else value

现在你可以做:

ob = Ob(J)

# if you're fetching a final raw value (not list/dict
ob.foo.bar[42].quux.leaf

# for intermediate values
ob.foo.bar[42].quux.J

这一基准测试也出奇地好。与我之前的天真冲动相当。如果有人能找到一种方法来整理非叶查询的访问，请留下评论!

已经有多种可行的答案，但有一些由个人制作的小型库可以满足大多数用户的需求。

json2object就是一个例子。给定一个已定义的类，它将json数据反序列化到您的自定义模型，包括自定义属性和子对象。

它的使用非常简单。一个来自图书馆wiki的例子:

从json2object导入jsontoobject作为Jo 类学生: def __init__(自我): 自我。firstName =无 自我。lastName = None 自我。courses =[课程(")] 类课程: 定义__init__(self, name): Self.name = name 数据= " '{ “firstName”:“詹姆斯”, “姓”:“债券”, “课程”:[{ “名称”:“战斗”}, ｛ “名称”:“射击”} ］ } “‘ model = Student() Result = jo.deserialize(数据，模型) print (result.courses [0] . name)