我想将JSON数据转换为Python对象。
我从Facebook API收到JSON数据对象，我想将其存储在数据库中。
我的当前视图在Django (Python)(请求。POST包含JSON):
response = request.POST
user = FbApiUser(user_id = response['id'])
user.name = response['name']
user.username = response['username']
user.save()
这很好，但是如何处理复杂的JSON数据对象呢? 如果我能以某种方式将这个JSON对象转换为易于使用的Python对象，是不是会更好?
当前回答
这里有一个快速而肮脏的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()
其他回答
使用json模块(Python 2.6新增)或几乎总是安装的simplejson模块。
改进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
我正在寻找一个与recordclass一起工作的解决方案。RecordClass，支持嵌套对象，可用于json序列化和json反序列化。
扩展DS的答案，扩展BeneStr的解决方案，我想出了以下似乎有效的方法:
代码:
import json
import recordclass
class NestedRec(recordclass.RecordClass):
a : int = 0
b : int = 0
class ExampleRec(recordclass.RecordClass):
x : int = None
y : int = None
nested : NestedRec = NestedRec()
class JsonSerializer:
@staticmethod
def dumps(obj, ensure_ascii=True, indent=None, sort_keys=False):
return json.dumps(obj, default=JsonSerializer.__obj_to_dict, ensure_ascii=ensure_ascii, indent=indent, sort_keys=sort_keys)
@staticmethod
def loads(s, klass):
return JsonSerializer.__dict_to_obj(klass, json.loads(s))
@staticmethod
def __obj_to_dict(obj):
if hasattr(obj, "_asdict"):
return obj._asdict()
else:
return json.JSONEncoder().default(obj)
@staticmethod
def __dict_to_obj(klass, s_dict):
kwargs = {
key : JsonSerializer.__dict_to_obj(cls, s_dict[key]) if hasattr(cls,'_asdict') else s_dict[key] \
for key,cls in klass.__annotations__.items() \
if s_dict is not None and key in s_dict
}
return klass(**kwargs)
用法:
example_0 = ExampleRec(x = 10, y = 20, nested = NestedRec( a = 30, b = 40 ) )
#Serialize to JSON
json_str = JsonSerializer.dumps(example_0)
print(json_str)
#{
# "x": 10,
# "y": 20,
# "nested": {
# "a": 30,
# "b": 40
# }
#}
# Deserialize from JSON
example_1 = JsonSerializer.loads(json_str, ExampleRec)
example_1.x += 1
example_1.y += 1
example_1.nested.a += 1
example_1.nested.b += 1
json_str = JsonSerializer.dumps(example_1)
print(json_str)
#{
# "x": 11,
# "y": 21,
# "nested": {
# "a": 31,
# "b": 41
# }
#}
已经有多种可行的答案，但有一些由个人制作的小型库可以满足大多数用户的需求。
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)
我已经编写了一个名为any2any的小型(反)序列化框架，它可以帮助在两种Python类型之间进行复杂的转换。
在您的情况下，我猜您想从字典(通过json.loads获得)转换为复杂的对象response.education;Response.name，具有嵌套结构response.education.id，等等… 这就是这个框架的用途。文档还不是很好，但是通过使用any2any.simple。MappingToObject，你应该可以很容易地做到。如果需要帮助，请询问。
