วิธีการแปลงข้อมูล JSON เป็นวัตถุ Python

ฉันต้องการใช้ Python เพื่อแปลงข้อมูล JSON เป็นวัตถุ Python

ฉันได้รับวัตถุข้อมูล JSON จาก Facebook API ซึ่งฉันต้องการเก็บไว้ในฐานข้อมูลของฉัน

มุมมองปัจจุบันของฉันใน Django (Python) ( request.POSTมี JSON):

response = request.POST
user = FbApiUser(user_id = response['id'])
user.name = response['name']
user.username = response['username']
user.save()

• ทำงานได้ดี แต่ฉันจะจัดการกับวัตถุข้อมูล JSON ที่ซับซ้อนได้อย่างไร

• จะดีกว่านี้ไหมถ้าฉันจะแปลงวัตถุ JSON นี้เป็นวัตถุ Python เพื่อให้ใช้งานได้ง่าย

คุณสามารถทำได้ในหนึ่งบรรทัดโดยใช้namedtupleและobject_hook:

import json
from collections import namedtuple

data = '{"name": "John Smith", "hometown": {"name": "New York", "id": 123}}'

# Parse JSON into an object with attributes corresponding to dict keys.
x = json.loads(data, object_hook=lambda d: namedtuple('X', d.keys())(*d.values()))
print x.name, x.hometown.name, x.hometown.id

หรือเพื่อนำสิ่งนี้กลับมาใช้ใหม่ได้ง่าย:

def _json_object_hook(d): return namedtuple('X', d.keys())(*d.values())
def json2obj(data): return json.loads(data, object_hook=_json_object_hook)

x = json2obj(data)

หากคุณต้องการที่จะจัดการคีย์ที่มีชื่อแอตทริบิวต์ไม่ดีตรวจสอบnamedtupleของพารามิเตอร์rename

ตรวจสอบส่วนที่ชื่อเชี่ยวชาญ JSON วัตถุถอดรหัสในเอกสารโมดูลjson คุณสามารถใช้มันเพื่อถอดรหัสวัตถุ JSON เป็นชนิด Python ที่เจาะจง

นี่คือตัวอย่าง:

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

import json
def object_decoder(obj):
    if '__type__' in obj and obj['__type__'] == 'User':
        return User(obj['name'], obj['username'])
    return obj

json.loads('{"__type__": "User", "name": "John Smith", "username": "jsmith"}',
           object_hook=object_decoder)

print type(User)  # -> <type 'type'>

ปรับปรุง

หากคุณต้องการเข้าถึงข้อมูลในพจนานุกรมผ่านโมดูล json ให้ทำสิ่งนี้:

user = json.loads('{"__type__": "User", "name": "John Smith", "username": "jsmith"}')
print user['name']
print user['username']

เหมือนพจนานุกรมทั่วไป

นี่ไม่ใช่โค้ดกอล์ฟ แต่นี่เป็นกลอุบายที่สั้นที่สุดของฉันโดยใช้types.SimpleNamespaceเป็นคอนเทนเนอร์สำหรับวัตถุ JSON

เมื่อเทียบกับnamedtupleโซลูชั่นชั้นนำมันคือ:

• อาจเร็วกว่า / เล็กกว่าเนื่องจากไม่ได้สร้างคลาสสำหรับแต่ละวัตถุ
• สั้น
• ไม่มีrenameตัวเลือกและอาจเป็นข้อ จำกัด เดียวกันกับคีย์ที่ไม่ใช่ตัวระบุที่ถูกต้อง (ใช้setattrภายใต้หน้ากาก)

ตัวอย่าง:

from __future__ import print_function
import json

try:
    from types import SimpleNamespace as Namespace
except ImportError:
    # Python 2.x fallback
    from argparse import Namespace

data = '{"name": "John Smith", "hometown": {"name": "New York", "id": 123}}'

x = json.loads(data, object_hook=lambda d: Namespace(**d))

print (x.name, x.hometown.name, x.hometown.id)

คุณสามารถลองสิ่งนี้:

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

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

เพียงสร้างวัตถุใหม่แล้วส่งพารามิเตอร์เป็นแผนที่

นี่คือทางเลือก 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 Pickle

Python library สำหรับซีเรียลไลซ์กราฟวัตถุใด ๆ ลงใน JSON สามารถใช้วัตถุ Python ใดก็ได้และเปลี่ยนวัตถุเป็น JSON นอกจากนี้มันสามารถสร้างวัตถุกลับเป็น Python ได้อีกครั้ง

หากคุณใช้ Python 3.5+ คุณสามารถใช้jsonsเพื่อทำให้เป็นอนุกรมและดีซีเรียลไลซ์เป็นวัตถุ Python แบบเก่า:

import jsons

response = request.POST

# You'll need your class attributes to match your dict keys, so in your case do:
response['id'] = response.pop('user_id')

# Then you can load that dict into your class:
user = jsons.load(response, FbApiUser)

user.save()

คุณสามารถFbApiUserสืบทอดจากjsons.JsonSerializableเพื่อความสง่างามมากขึ้น:

user = FbApiUser.from_json(response)

ตัวอย่างเหล่านี้จะใช้งานได้ถ้าคลาสของคุณประกอบด้วยชนิดเริ่มต้นของ Python เช่นสตริงจำนวนเต็มรายการชุดข้อมูล ฯลฯjsonslib จะต้องการคำแนะนำประเภทสำหรับประเภทที่กำหนดเอง

หากคุณกำลังใช้หลาม 3.6 ขึ้นไปคุณสามารถใช้ขนมหวาน-dataclass ตรงกันข้ามกับวิธีแก้ปัญหาทั้งหมดที่กล่าวมาข้างต้นเป็นวิธีที่ง่ายและปลอดภัย

from marshmallow_dataclass import dataclass

@dataclass
class User:
    name: str

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

การปรับปรุงคำตอบที่ดีมากของ lovasoa

หากคุณใช้ python 3.6+ คุณสามารถใช้:
pip install marshmallow-enumและ
pip install marshmallow-dataclass

มันง่ายและพิมพ์ปลอดภัย

คุณสามารถเปลี่ยนชั้นเรียนของคุณใน string-json และในทางกลับกัน:

จาก Object ถึง String 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

ฉันได้เขียนกรอบการทำให้เป็นอนุกรมขนาดเล็ก (de) ที่เรียกว่าany2anyที่ช่วยทำการแปลงที่ซับซ้อนระหว่าง Python สองประเภท

ในกรณีของคุณฉันคิดว่าคุณต้องการแปลงจากพจนานุกรม (รับด้วยjson.loads) เป็นวัตถุที่ซับซ้อนresponse.education ; response.nameพร้อมโครงสร้างซ้อนกันresponse.education.idเป็นต้น ... นั่นคือสิ่งที่เฟรมเวิร์กทำ เอกสารยังไม่ดี แต่โดยใช้any2any.simple.MappingToObjectคุณควรจะสามารถทำได้ง่ายมาก โปรดถามว่าคุณต้องการความช่วยเหลือหรือไม่

ตั้งแต่ไม่มีใครให้คำตอบเหมือนของฉันฉันจะโพสต์ที่นี่

เป็นคลาสที่แข็งแกร่งที่สามารถแปลงไปมาระหว่าง json strและdictฉันได้คัดลอกจากคำตอบของฉันไปยังคำถามอื่นอย่างง่ายดาย :

import json

class PyJSON(object):
    def __init__(self, d):
        if type(d) is str:
            d = json.loads(d)

        self.from_dict(d)

    def from_dict(self, d):
        self.__dict__ = {}
        for key, value in d.items():
            if type(value) is dict:
                value = PyJSON(value)
            self.__dict__[key] = value

    def to_dict(self):
        d = {}
        for key, value in self.__dict__.items():
            if type(value) is PyJSON:
                value = value.to_dict()
            d[key] = value
        return d

    def __repr__(self):
        return str(self.to_dict())

    def __setitem__(self, key, value):
        self.__dict__[key] = value

    def __getitem__(self, key):
        return self.__dict__[key]

json_str = """... json string ..."""

py_json = PyJSON(json_str)

การแก้ไข @DS ตอบสนองเล็กน้อยเพื่อโหลดจากไฟล์:

def _json_object_hook(d): return namedtuple('X', d.keys())(*d.values())
def load_data(file_name):
  with open(file_name, 'r') as file_data:
    return file_data.read().replace('\n', '')
def json2obj(file_name): return json.loads(load_data(file_name), object_hook=_json_object_hook)

สิ่งหนึ่งที่: ไม่สามารถโหลดรายการที่มีตัวเลขอยู่ข้างหน้า แบบนี้:

{
  "1_first_item": {
    "A": "1",
    "B": "2"
  }
}

เนื่องจาก "1_first_item" ไม่ใช่ชื่อเขตข้อมูลของงูหลามที่ถูกต้อง

ในขณะที่ค้นหาวิธีการแก้ปัญหาฉันได้พบกับโพสต์บล็อกนี้: https://blog.mosthege.net/2016/11/12/json-deserialization-of-nested-objects/

มันใช้เทคนิคเดียวกับที่ระบุไว้ในคำตอบก่อนหน้า แต่ด้วยการใช้งานของนักตกแต่ง อีกสิ่งหนึ่งที่ฉันพบว่ามีประโยชน์คือความจริงที่ว่ามันส่งคืนวัตถุที่พิมพ์เมื่อสิ้นสุดการดีซีเรียลไลเซชัน

class JsonConvert(object):
    class_mappings = {}

    @classmethod
    def class_mapper(cls, d):
        for keys, cls in clsself.mappings.items():
            if keys.issuperset(d.keys()):   # are all required arguments present?
                return cls(**d)
        else:
            # Raise exception instead of silently returning None
            raise ValueError('Unable to find a matching class for object: {!s}'.format(d))

    @classmethod
    def complex_handler(cls, Obj):
        if hasattr(Obj, '__dict__'):
            return Obj.__dict__
        else:
            raise TypeError('Object of type %s with value of %s is not JSON serializable' % (type(Obj), repr(Obj)))

    @classmethod
    def register(cls, claz):
        clsself.mappings[frozenset(tuple([attr for attr,val in cls().__dict__.items()]))] = cls
        return cls

    @classmethod
    def to_json(cls, obj):
        return json.dumps(obj.__dict__, default=cls.complex_handler, indent=4)

    @classmethod
    def from_json(cls, json_str):
        return json.loads(json_str, object_hook=cls.class_mapper)

การใช้งาน:

@JsonConvert.register
class Employee(object):
    def __init__(self, Name:int=None, Age:int=None):
        self.Name = Name
        self.Age = Age
        return

@JsonConvert.register
class Company(object):
    def __init__(self, Name:str="", Employees:[Employee]=None):
        self.Name = Name
        self.Employees = [] if Employees is None else Employees
        return

company = Company("Contonso")
company.Employees.append(Employee("Werner", 38))
company.Employees.append(Employee("Mary"))

as_json = JsonConvert.to_json(company)
from_json = JsonConvert.from_json(as_json)
as_json_from_json = JsonConvert.to_json(from_json)

assert(as_json_from_json == as_json)

print(as_json_from_json)

การขยายคำตอบของ DS ถ้าคุณต้องการให้อ็อบเจกต์ผันแปรได้ (ซึ่งไม่ได้ชื่อว่า named tuple) คุณสามารถใช้ไลบรารี่ไลบรารีคลาสแทนการตั้งชื่อว่า

import json
from recordclass import recordclass

data = '{"name": "John Smith", "hometown": {"name": "New York", "id": 123}}'

# Parse into a mutable object
x = json.loads(data, object_hook=lambda d: recordclass('X', d.keys())(*d.values()))

วัตถุที่ถูกดัดแปลงนั้นสามารถแปลงกลับเป็น json ได้อย่างง่ายดายมากโดยใช้simplejson :

x.name = "John Doe"
new_json = simplejson.dumps(x)

หากคุณใช้ Python 3.6 หรือใหม่กว่าคุณสามารถดูsquemaซึ่งเป็นโมดูลน้ำหนักเบาสำหรับโครงสร้างข้อมูลที่พิมพ์แบบคงที่ มันทำให้โค้ดของคุณอ่านง่ายในขณะเดียวกันก็ให้การตรวจสอบความถูกต้องของข้อมูลการแปลงและการทำให้เป็นอนุกรมโดยไม่ต้องทำงานพิเศษ คุณสามารถคิดว่ามันเป็นทางเลือกที่ซับซ้อนมากขึ้นและมีความคิดเห็นที่มีชื่อกับ tuples และ dataclasses นี่คือวิธีการใช้งาน:

from uuid import UUID
from squema import Squema


class FbApiUser(Squema):
    id: UUID
    age: int
    name: str

    def save(self):
        pass


user = FbApiUser(**json.loads(response))
user.save()

ฉันกำลังค้นหาวิธีแก้ปัญหาที่ทำงานร่วมกับ recordclass.RecordClassสนับสนุนวัตถุที่ซ้อนกันและใช้ได้กับทั้งการทำให้เป็นอนุกรม json และ deserialization 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
#  }
#}

คำตอบที่ให้ไว้ที่นี่ไม่ส่งคืนชนิดของวัตถุที่ถูกต้องดังนั้นฉันจึงสร้างวิธีการเหล่านี้ด้านล่าง นอกจากนี้ยังล้มเหลวหากคุณพยายามเพิ่มเขตข้อมูลเพิ่มเติมในคลาสที่ไม่มีอยู่ใน JSON ที่กำหนด:

def dict_to_class(class_name: Any, dictionary: dict) -> Any:
    instance = class_name()
    for key in dictionary.keys():
        setattr(instance, key, dictionary[key])
    return instance


def json_to_class(class_name: Any, json_string: str) -> Any:
    dict_object = json.loads(json_string)
    return dict_to_class(class_name, dict_object)

Python3.x

สิ่งที่ดีที่สุดที่ฉันสามารถเข้าถึงได้ด้วยความรู้ของฉันคือสิ่งนี้
โปรดทราบว่ารหัสนี้ถือว่าชุด () เกินไป
วิธีการนี้เป็นวิธีการทั่วไปที่ต้องการการขยายชั้นเรียน (ในตัวอย่างที่สอง)
โปรดทราบว่าฉันแค่ทำมันกับไฟล์ แต่มันง่ายที่จะปรับเปลี่ยนพฤติกรรมตามรสนิยมของคุณ

อย่างไรก็ตามนี่คือ CoDec

ด้วยการทำงานเพิ่มอีกเล็กน้อยคุณสามารถสร้างชั้นเรียนของคุณในรูปแบบอื่นได้ ฉันถือว่าตัวสร้างเริ่มต้นให้เป็นอินสแตนซ์นั้นจากนั้นฉันอัพเดทคลาส dict

import json
import collections


class JsonClassSerializable(json.JSONEncoder):

    REGISTERED_CLASS = {}

    def register(ctype):
        JsonClassSerializable.REGISTERED_CLASS[ctype.__name__] = ctype

    def default(self, obj):
        if isinstance(obj, collections.Set):
            return dict(_set_object=list(obj))
        if isinstance(obj, JsonClassSerializable):
            jclass = {}
            jclass["name"] = type(obj).__name__
            jclass["dict"] = obj.__dict__
            return dict(_class_object=jclass)
        else:
            return json.JSONEncoder.default(self, obj)

    def json_to_class(self, dct):
        if '_set_object' in dct:
            return set(dct['_set_object'])
        elif '_class_object' in dct:
            cclass = dct['_class_object']
            cclass_name = cclass["name"]
            if cclass_name not in self.REGISTERED_CLASS:
                raise RuntimeError(
                    "Class {} not registered in JSON Parser"
                    .format(cclass["name"])
                )
            instance = self.REGISTERED_CLASS[cclass_name]()
            instance.__dict__ = cclass["dict"]
            return instance
        return dct

    def encode_(self, file):
        with open(file, 'w') as outfile:
            json.dump(
                self.__dict__, outfile,
                cls=JsonClassSerializable,
                indent=4,
                sort_keys=True
            )

    def decode_(self, file):
        try:
            with open(file, 'r') as infile:
                self.__dict__ = json.load(
                    infile,
                    object_hook=self.json_to_class
                )
        except FileNotFoundError:
            print("Persistence load failed "
                  "'{}' do not exists".format(file)
                  )


class C(JsonClassSerializable):

    def __init__(self):
        self.mill = "s"


JsonClassSerializable.register(C)


class B(JsonClassSerializable):

    def __init__(self):
        self.a = 1230
        self.c = C()


JsonClassSerializable.register(B)


class A(JsonClassSerializable):

    def __init__(self):
        self.a = 1
        self.b = {1, 2}
        self.c = B()

JsonClassSerializable.register(A)

A().encode_("test")
b = A()
b.decode_("test")
print(b.a)
print(b.b)
print(b.c.a)

แก้ไข

จากการวิจัยเพิ่มเติมพบว่ามีวิธีการพูดคุยทั่วไปโดยไม่ต้องใช้วิธีการลงทะเบียนSUPERCLASSโดยใช้metaclass

import json
import collections

REGISTERED_CLASS = {}

class MetaSerializable(type):

    def __call__(cls, *args, **kwargs):
        if cls.__name__ not in REGISTERED_CLASS:
            REGISTERED_CLASS[cls.__name__] = cls
        return super(MetaSerializable, cls).__call__(*args, **kwargs)


class JsonClassSerializable(json.JSONEncoder, metaclass=MetaSerializable):

    def default(self, obj):
        if isinstance(obj, collections.Set):
            return dict(_set_object=list(obj))
        if isinstance(obj, JsonClassSerializable):
            jclass = {}
            jclass["name"] = type(obj).__name__
            jclass["dict"] = obj.__dict__
            return dict(_class_object=jclass)
        else:
            return json.JSONEncoder.default(self, obj)

    def json_to_class(self, dct):
        if '_set_object' in dct:
            return set(dct['_set_object'])
        elif '_class_object' in dct:
            cclass = dct['_class_object']
            cclass_name = cclass["name"]
            if cclass_name not in REGISTERED_CLASS:
                raise RuntimeError(
                    "Class {} not registered in JSON Parser"
                    .format(cclass["name"])
                )
            instance = REGISTERED_CLASS[cclass_name]()
            instance.__dict__ = cclass["dict"]
            return instance
        return dct

    def encode_(self, file):
        with open(file, 'w') as outfile:
            json.dump(
                self.__dict__, outfile,
                cls=JsonClassSerializable,
                indent=4,
                sort_keys=True
            )

    def decode_(self, file):
        try:
            with open(file, 'r') as infile:
                self.__dict__ = json.load(
                    infile,
                    object_hook=self.json_to_class
                )
        except FileNotFoundError:
            print("Persistence load failed "
                  "'{}' do not exists".format(file)
                  )


class C(JsonClassSerializable):

    def __init__(self):
        self.mill = "s"


class B(JsonClassSerializable):

    def __init__(self):
        self.a = 1230
        self.c = C()


class A(JsonClassSerializable):

    def __init__(self):
        self.a = 1
        self.b = {1, 2}
        self.c = B()


A().encode_("test")
b = A()
b.decode_("test")
print(b.a)
# 1
print(b.b)
# {1, 2}
print(b.c.a)
# 1230
print(b.c.c.mill)
# s

คุณสามารถใช้ได้

x = Map(json.loads(response))
x.__class__ = MyClass

ที่ไหน

class Map(dict):
    def __init__(self, *args, **kwargs):
        super(Map, self).__init__(*args, **kwargs)
        for arg in args:
            if isinstance(arg, dict):
                for k, v in arg.iteritems():
                    self[k] = v
                    if isinstance(v, dict):
                        self[k] = Map(v)

        if kwargs:
            # for python 3 use kwargs.items()
            for k, v in kwargs.iteritems():
                self[k] = v
                if isinstance(v, dict):
                    self[k] = Map(v)

    def __getattr__(self, attr):
        return self.get(attr)

    def __setattr__(self, key, value):
        self.__setitem__(key, value)

    def __setitem__(self, key, value):
        super(Map, self).__setitem__(key, value)
        self.__dict__.update({key: value})

    def __delattr__(self, item):
        self.__delitem__(item)

    def __delitem__(self, key):
        super(Map, self).__delitem__(key)
        del self.__dict__[key]

สำหรับโซลูชันทั่วไปที่มีอนาคต

ใช้jsonโมดูล ( ใหม่ใน Python 2.6 ) หรือsimplejsonโมดูลที่ติดตั้งเกือบตลอดเวลา