Come convertire i dati JSON in un oggetto Python

Voglio usare Python per convertire i dati JSON in un oggetto Python.

Ricevo oggetti di dati JSON dall'API di Facebook, che desidero archiviare nel mio database.

La mia vista corrente in Django (Python) ( request.POSTcontiene il JSON):

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

• Funziona bene, ma come posso gestire oggetti dati JSON complessi?

• Non sarebbe molto meglio se potessi in qualche modo convertire questo oggetto JSON in un oggetto Python per un facile utilizzo?

Puoi farlo in una riga, usando namedtuplee 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

o, per riutilizzarlo facilmente:

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)

Se si desidera gestire le chiavi che non sono buoni nomi degli attributi, controlla namedtuples'rename parametro .

Consulta la sezione intitolata Specializzazione della decodifica degli oggetti JSON nella json documentazione del modulo . Puoi usarlo per decodificare un oggetto JSON in un tipo Python specifico.

Ecco un esempio:

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'>

Aggiornare

Se si desidera accedere ai dati in un dizionario tramite il modulo json, procedere come segue:

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

Proprio come un normale dizionario.

Questo non è il golf del codice, ma qui è il mio trucco più breve, usando types.SimpleNamespacecome contenitore per oggetti JSON.

Rispetto alla namedtuplesoluzione leader , è:

• probabilmente più veloce / più piccolo in quanto non crea una classe per ogni oggetto
• più breve
• nessuna renameopzione, e probabilmente la stessa limitazione su chiavi che non sono identificatori validi (utilizza setattrsotto le copertine)

Esempio:

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)

Puoi provare questo:

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)

Basta creare un nuovo oggetto e passare i parametri come una mappa.

Ecco un'alternativa rapida e sporca al sottaceto JSON

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()

Per oggetti complessi, è possibile utilizzare Pickup JSON

Libreria Python per serializzare qualsiasi grafico a oggetti arbitrario in JSON. Può prendere quasi qualsiasi oggetto Python e trasformarlo in JSON. Inoltre, può ricostituire l'oggetto in Python.

Se stai usando Python 3.5+, puoi usare jsonsper serializzare e deserializzare su semplici oggetti Python vecchi:

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()

Puoi anche FbApiUserereditare da jsons.JsonSerializableper maggiore eleganza:

user = FbApiUser.from_json(response)

Questi esempi funzioneranno se la tua classe è composta da tipi predefiniti di Python, come stringhe, numeri interi, elenchi, orari, ecc. La jsonslib richiederà comunque suggerimenti di tipo per tipi personalizzati.

Se si utilizza python 3.6+, è possibile utilizzare marshmallow-dataclass . Contrariamente a tutte le soluzioni sopra elencate, è sia semplice che sicuro:

from marshmallow_dataclass import dataclass

@dataclass
class User:
    name: str

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

Migliorare l'ottima risposta del lovasoa.

Se stai usando python 3.6+, puoi usare:
pip install marshmallow-enume
pip install marshmallow-dataclass

È semplice e sicuro.

Puoi trasformare la tua classe in uno string-json e viceversa:

Dall'oggetto alla stringa 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

Da String Json a Object:

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

Definizioni di classe:

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

Ho scritto un piccolo (de) serializzazione chiamato any2any che aiuta a fare trasformazioni complesse tra due tipi di Python.

Nel tuo caso, immagino che tu voglia trasformarti da un dizionario (ottenuto con json.loads) in un oggetto complesso response.education ; response.name, con una struttura nidificata response.education.id, ecc ... Quindi è esattamente per questo che è fatto questo framework. La documentazione non è ancora eccezionale, ma utilizzando any2any.simple.MappingToObject, dovresti essere in grado di farlo molto facilmente. Per favore chiedi se hai bisogno di aiuto.

Poiché nessuno ha fornito una risposta simile alla mia, la pubblicherò qui.

È una classe solida che può facilmente convertire avanti e indietro tra json stre dictche ho copiato dalla mia risposta a un'altra domanda :

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)

Modifica della risposta @DS un po ', per caricare da un file:

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)

Una cosa: non è possibile caricare articoli con numeri in anticipo. Come questo:

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

Perché "1_first_item" non è un nome campo python valido.

Durante la ricerca di una soluzione, mi sono imbattuto in questo post del blog: https://blog.mosthege.net/2016/11/12/json-deserialization-of-nested-objects/

Utilizza la stessa tecnica indicata nelle risposte precedenti ma con un uso di decoratori. Un'altra cosa che ho trovato utile è il fatto che restituisce un oggetto tipizzato alla fine della deserializzazione

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)

Uso:

@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)

Espandendo un po 'la risposta di DS, se hai bisogno che l'oggetto sia mutabile (quale nametuple non lo è), puoi usare la libreria recordclass invece di namedtuple:

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()))

L'oggetto modificato può quindi essere riconvertito molto facilmente in json usando simplejson :

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

Se stai usando Python 3.6 o versioni successive, potresti dare un'occhiata a squema , un modulo leggero per strutture di dati tipizzate staticamente. Semplifica la lettura del codice e allo stesso tempo fornisce una semplice convalida, conversione e serializzazione dei dati senza ulteriore lavoro. Puoi pensarlo come un'alternativa più sofisticata e supponente alle coppie di nomi e agli occhiali. Ecco come puoi usarlo:

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()

Ero alla ricerca di una soluzione che funzionasse recordclass.RecordClass, supporti oggetti nidificati e funzionasse sia per la serializzazione json che per la deserializzazione json.

Espandendo la risposta di DS e espandendo la soluzione di BeneStr, ho pensato a quanto segue che sembra funzionare:

Codice:

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)

Uso:

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
#  }
#}

Le risposte fornite qui non restituiscono il tipo di oggetto corretto, quindi ho creato questi metodi di seguito. Inoltre falliscono se provi ad aggiungere più campi alla classe che non esiste nel JSON dato:

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

Il miglior approccio che sono riuscito a raggiungere con le mie conoscenze è stato questo.
Nota che questo codice tratta anche set ().
Questo approccio è generico e richiede solo l'estensione della classe (nel secondo esempio).
Nota che lo sto solo facendo ai file, ma è facile modificare il comportamento secondo i tuoi gusti.

Tuttavia questo è un CoDec.

Con un po 'più di lavoro puoi costruire la tua classe in altri modi. Presumo un costruttore predefinito per istanziarlo, quindi aggiorno il dict di classe.

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)

modificare

Con un po 'più di ricerca ho trovato un modo per generalizzare senza la necessità della chiamata al metodo del registro SUPERCLASS , usando una metaclasse

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

Puoi usare

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

dove

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]

Per una soluzione generica, a prova di futuro.

Usa il jsonmodulo ( nuovo in Python 2.6 ) o il simplejsonmodulo che è quasi sempre installato.