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

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)

使用json模块(Python 2.6新增)或几乎总是安装的simplejson模块。

这似乎是一个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

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

你可以试试这个:

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

import json
j = json.loads(your_json)
u = User(**j)

只需创建一个新对象，并将参数作为映射传递。

你也可以有一个带有对象的JSON:

import json
class Address(object):
    def __init__(self, street, number):
        self.street = street
        self.number = number

    def __str__(self):
        return "{0} {1}".format(self.street, self.number)

class User(object):
    def __init__(self, name, address):
        self.name = name
        self.address = Address(**address)

    def __str__(self):
        return "{0} ,{1}".format(self.name, self.address)

if __name__ == '__main__':
    js = '''{"name":"Cristian", "address":{"street":"Sesame","number":122}}'''
    j = json.loads(js)
    print(j)
    u = User(**j)
    print(u)

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

from marshmallow_dataclass import dataclass

@dataclass
class User:
    name: str

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

改进lovasoa非常好的答案。

如果你正在使用python 3.6+，你可以使用: PIP安装棉花糖-enum和 PIP安装棉花糖数据类

它简单且类型安全。

你可以在string-json中转换你的类，反之亦然:

从对象到字符串Json:

    from marshmallow_dataclass import dataclass
    user = User("Danilo","50","RedBull",15,OrderStatus.CREATED)
    user_json = User.Schema().dumps(user)
    user_json_str = user_json.data

从String Json到Object:

    json_str = '{"name":"Danilo", "orderId":"50", "productName":"RedBull", "quantity":15, "status":"Created"}'
    user, err = User.Schema().loads(json_str)
    print(user,flush=True)

类定义:

class OrderStatus(Enum):
    CREATED = 'Created'
    PENDING = 'Pending'
    CONFIRMED = 'Confirmed'
    FAILED = 'Failed'

@dataclass
class User:
    def __init__(self, name, orderId, productName, quantity, status):
        self.name = name
        self.orderId = orderId
        self.productName = productName
        self.quantity = quantity
        self.status = status

    name: str
    orderId: str
    productName: str
    quantity: int
    status: OrderStatus