Cum se face serializabil o clasă JSON

Aveți o idee despre rezultatul așteptat? De exemplu, asta va face?

>>> f  = FileItem("/foo/bar")
>>> magic(f)
'{"fname": "/foo/bar"}'

În acest caz, puteți doar să sunați la json.dumps(f.__dict__).

Dacă doriți o ieșire mai personalizată, va trebui să subclasați JSONEncoder și să implementați propria dvs. serializare personalizată.

Pentru un exemplu banal, vezi mai jos.

>>> from json import JSONEncoder
>>> class MyEncoder(JSONEncoder):
        def default(self, o):
            return o.__dict__    

>>> MyEncoder().encode(f)
'{"fname": "/foo/bar"}'

Apoi treceți această clasă în metoda json.dumps() ca cls kwarg:

json.dumps(cls=MyEncoder)

Dacă doriți și să decodați, va trebui să furnizați un object_hook personalizat JSONDecoder clasă. De exemplu:

>>> def from_json(json_object):
        if 'fname' in json_object:
            return FileItem(json_object['fname'])
>>> f = JSONDecoder(object_hook = from_json).decode('{"fname": "/foo/bar"}')
>>> f
<__main__.FileItem object at 0x9337fac>
>>> 

Iată o soluție simplă pentru o caracteristică simplă:

.toJSON() Metoda

În loc de o clasă serializabilă JSON, implementați o metodă de serializare:

import json

class Object:
    def toJSON(self):
        return json.dumps(self, default=lambda o: o.__dict__, 
            sort_keys=True, indent=4)

Așa că îl sunați doar pentru a serializa:

me = Object()
me.name = "Onur"
me.age = 35
me.dog = Object()
me.dog.name = "Apollo"

print(me.toJSON())

va scoate:

{
    "age": 35,
    "dog": {
        "name": "Apollo"
    },
    "name": "Onur"
}

Pentru clase mai complexe, puteți lua în considerare instrumentul jsonpickle:

jsonpickle este o bibliotecă Python pentru serializarea și deserializarea obiectelor complexe Python către și de la JSON.

Bibliotecile standard Python pentru codificarea Python în JSON, cum ar fi json, simplejson și demjson ale stdlib, pot gestiona doar primitivele Python care au un echivalent JSON direct (de exemplu, dict, liste, șiruri de caractere, int etc.). jsonpickle se bazează pe aceste biblioteci și permite ca structurile de date mai complexe să fie serializate în JSON. jsonpickle este extrem de configurabil și extensibil, permițând utilizatorului să aleagă backend-ul JSON și să adauge backend-uri suplimentare.

(link către jsonpickle pe PyPi)

Majoritatea răspunsurilor implică schimbarea apelului la json.dumps(), ceea ce nu este întotdeauna posibil sau de dorit (se poate întâmpla în interiorul unei componente cadru, de exemplu).

Dacă doriți să puteți apela json.dumps(obj) așa cum este, atunci o soluție simplă este moștenirea de la dict:

class FileItem(dict):
    def __init__(self, fname):
        dict.__init__(self, fname=fname)

f = FileItem('tasks.txt')
json.dumps(f)  #No need to change anything here

Acest lucru funcționează dacă clasa dvs. este doar reprezentarea de bază a datelor, pentru lucruri mai complicate puteți seta întotdeauna cheile în mod explicit.

Îmi place Răspunsul lui Onur, dar m-ar extinde pentru a include o metodă opțională toJSON() pentru ca obiectele să se serializeze:

def dumper(obj):
    try:
        return obj.toJSON()
    except:
        return obj.__dict__
print json.dumps(some_big_object, default=dumper, indent=2)

Doar adăugați metoda to_json la clasa dvs. astfel:

def to_json(self):
  return self.message # or how you want it to be serialized

Și adăugați acest cod (de la acest răspuns), undeva în partea de sus a tuturor:

from json import JSONEncoder

def _default(self, obj):
    return getattr(obj.__class__, "to_json", _default.default)(obj)

_default.default = JSONEncoder().default
JSONEncoder.default = _default

Acesta va patch modulul json atunci când este importat, astfel încât JSONEncoder.default() verifică automat o metodă specială „to_json()” și o folosește pentru a codifica obiectul dacă este găsit.

Așa cum a spus Onur, dar de data aceasta nu trebuie să actualizați fiecare json.dumps() din proiectul dvs.

O altă opțiune este să includeți dumpingul JSON în propria sa clasă:

import json

class FileItem:
    def __init__(self, fname):
        self.fname = fname

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

Sau, chiar mai bine, subclasarea clasei FileItem dintr-o clasă JsonSerializable:

import json

class JsonSerializable(object):
    def toJson(self):
        return json.dumps(self.__dict__)

    def __repr__(self):
        return self.toJson()


class FileItem(JsonSerializable):
    def __init__(self, fname):
        self.fname = fname

Testare:

>>> f = FileItem('/foo/bar')
>>> f.toJson()
'{"fname": "/foo/bar"}'
>>> f
'{"fname": "/foo/bar"}'
>>> str(f) # string coercion
'{"fname": "/foo/bar"}'

După cum sa menționat în multe alte răspunsuri, puteți transmite o funcție către json.dumps pentru a converti obiectele care nu sunt unul dintre tipurile acceptate implicit într-un tip acceptat. În mod surprinzător, niciunul dintre ele nu menționează cel mai simplu caz, și anume utilizarea funcției încorporate vars pentru a converti obiectele într-un dict care să conțină toate atributele lor:

json.dumps(obj, default=vars)

Rețineți că aceasta acoperă numai cazuri de bază, dacă aveți nevoie de o serializare mai specifică pentru anumite tipuri (de exemplu, excluderea anumitor atribute sau pentru obiecte care nu au un atribut __dict__), trebuie să utilizați o funcție personalizată sau un JSONEncoder așa cum este descris în celelalte răspunsuri. .

Am întâlnit această problemă zilele trecute și am implementat o versiune mai generală a unui codificator pentru obiecte Python, care poate tratează obiecte imbricate și câmpuri moștenite:

import json
import inspect

class ObjectEncoder(json.JSONEncoder):
    def default(self, obj):
        if hasattr(obj, "to_json"):
            return self.default(obj.to_json())
        elif hasattr(obj, "__dict__"):
            d = dict(
                (key, value)
                for key, value in inspect.getmembers(obj)
                if not key.startswith("__")
                and not inspect.isabstract(value)
                and not inspect.isbuiltin(value)
                and not inspect.isfunction(value)
                and not inspect.isgenerator(value)
                and not inspect.isgeneratorfunction(value)
                and not inspect.ismethod(value)
                and not inspect.ismethoddescriptor(value)
                and not inspect.isroutine(value)
            )
            return self.default(d)
        return obj

Exemplu:

class C(object):
    c = "NO"
    def to_json(self):
        return {"c": "YES"}

class B(object):
    b = "B"
    i = "I"
    def __init__(self, y):
        self.y = y
        
    def f(self):
        print "f"

class A(B):
    a = "A"
    def __init__(self):
        self.b = [{"ab": B("y")}]
        self.c = C()

print json.dumps(A(), cls=ObjectEncoder, indent=2, sort_keys=True)

Rezultat:

{
  "a": "A", 
  "b": [
    {
      "ab": {
        "b": "B", 
        "i": "I", 
        "y": "y"
      }
    }
  ], 
  "c": {
    "c": "YES"
  }, 
  "i": "I"
}

Dacă utilizați Python3.5+, puteți utiliza jsons. (PyPi: https://pypi.org/project/jsons/) Acesta vă va converti obiectul (și toate atributele sale în mod recursiv) la un dict.

import jsons

a_dict = jsons.dump(your_object)

Sau dacă ai vrut un șir:

a_str = jsons.dumps(your_object)

Sau dacă clasa dvs. a implementat jsons.JsonSerializable:

a_dict = your_object.json

import simplejson

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

    def _asdict(self):
        return self.__dict__

print(simplejson.dumps(User('alice', '[email protected]')))

dacă utilizați json standard, trebuie să definiți o funcție default

import json
def default(o):
    return o._asdict()

print(json.dumps(User('alice', '[email protected]'), default=default))

json este limitat în ceea ce privește obiectele pe care le poate imprima, iar jsonpickle (poate avea nevoie de un pip install jsonpickle) este limitat în termeni în care nu poate indenta text. Dacă doriți să inspectați conținutul unui obiect a cărui clasă nu o puteți schimba, tot nu am putut găsi o modalitate mai dreaptă decât:

 import json
 import jsonpickle
 ...
 print  json.dumps(json.loads(jsonpickle.encode(object)), indent=2)

Notă: că încă nu pot imprima metodele obiectului.

Această clasă poate face truc, transformă obiectul în json standard.

import json


class Serializer(object):
    @staticmethod
    def serialize(object):
        return json.dumps(object, default=lambda o: o.__dict__.values()[0])

utilizare:

Serializer.serialize(my_object)

lucrează în python2.7 și python3.

Iată cei 3 cenți ai mei...
Acest lucru demonstrează serializarea json explicită pentru un obiect python asemănător arborelui.
Notă: dacă ați dorit de fapt un astfel de cod, puteți utiliza clasa FilePath răsucită.

import json, sys, os

class File:
    def __init__(self, path):
        self.path = path

    def isdir(self):
        return os.path.isdir(self.path)

    def isfile(self):
        return os.path.isfile(self.path)

    def children(self):        
        return [File(os.path.join(self.path, f)) 
                for f in os.listdir(self.path)]

    def getsize(self):        
        return os.path.getsize(self.path)

    def getModificationTime(self):
        return os.path.getmtime(self.path)

def _default(o):
    d = {}
    d['path'] = o.path
    d['isFile'] = o.isfile()
    d['isDir'] = o.isdir()
    d['mtime'] = int(o.getModificationTime())
    d['size'] = o.getsize() if o.isfile() else 0
    if o.isdir(): d['children'] = o.children()
    return d

folder = os.path.abspath('.')
json.dump(File(folder), sys.stdout, default=_default)

jaraco a dat un răspuns destul de clar. Trebuia să repar niște lucruri minore, dar funcționează:

Cod

# Your custom class
class MyCustom(object):
    def __json__(self):
        return {
            'a': self.a,
            'b': self.b,
            '__python__': 'mymodule.submodule:MyCustom.from_json',
        }

    to_json = __json__  # supported by simplejson

    @classmethod
    def from_json(cls, json):
        obj = cls()
        obj.a = json['a']
        obj.b = json['b']
        return obj

# Dumping and loading
import simplejson

obj = MyCustom()
obj.a = 3
obj.b = 4

json = simplejson.dumps(obj, for_json=True)

# Two-step loading
obj2_dict = simplejson.loads(json)
obj2 = MyCustom.from_json(obj2_dict)

# Make sure we have the correct thing
assert isinstance(obj2, MyCustom)
assert obj2.__dict__ == obj.__dict__

Rețineți că avem nevoie de doi pași pentru încărcare. Deocamdată, proprietatea __python__ nu este utilizată.

Cât de comun este asta?

Folosind metoda AlJohri, verific popularitatea abordărilor:

Serializare (Python -> JSON):

• to_json: 266.595 pe 2018-06-27
• toJSON: 96.307 pe 2018-06-27
• __json__: 8.504 pe 2018-06-27
• for_json: 6.937 pe 2018-06 -27

Deserializare (JSON -> Python):

• from_json: 226.101 pe 2018-06-27

Acest lucru a funcționat bine pentru mine:

class JsonSerializable(object):

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

    def __repr__(self):
        return self.serialize()

    @staticmethod
    def dumper(obj):
        if "serialize" in dir(obj):
            return obj.serialize()

        return obj.__dict__

și apoi

class FileItem(JsonSerializable):
    ...

și

log.debug(json.dumps(<my object>, default=JsonSerializable.dumper, indent=2))

Dacă nu vă deranjează să instalați un pachet pentru acesta, puteți utiliza json-tricks:

pip install json-tricks

După aceea, trebuie doar să importați dump(s) din json_tricks în loc de json și, de obicei, va funcționa:

from json_tricks import dumps
json_str = dumps(cls_instance, indent=4)

care va da

{
        "__instance_type__": [
                "module_name.test_class",
                "MyTestCls"
        ],
        "attributes": {
                "attr": "val",
                "dct_attr": {
                        "hello": 42
                }
        }
}

Și practic asta este!

Acest lucru va funcționa grozav în general. Există câteva excepții, de ex. dacă se întâmplă lucruri speciale în __new__, sau mai multă magie metaclasă se întâmplă.

Evident, funcționează și încărcarea (altfel ce rost are):

from json_tricks import loads
json_str = loads(json_str)

Aceasta presupune că module_name.test_class.MyTestCls poate fi importat și nu s-a schimbat în moduri necompatibile. Veți primi înapoi o instanță, nu un dicționar sau ceva de genul, și ar trebui să fie o copie identică cu cea pe care ați aruncat-o.

Dacă doriți să personalizați modul în care ceva este (de)serializat, puteți adăuga metode speciale la clasa dvs., cum ar fi:

class CustomEncodeCls:
        def __init__(self):
                self.relevant = 42
                self.irrelevant = 37

        def __json_encode__(self):
                # should return primitive, serializable types like dict, list, int, string, float...
                return {'relevant': self.relevant}

        def __json_decode__(self, **attrs):
                # should initialize all properties; note that __init__ is not called implicitly
                self.relevant = attrs['relevant']
                self.irrelevant = 12

care serializează doar o parte din parametrii atributelor, de exemplu.

Și ca bonus gratuit, obțineți (de)serializarea matricelor numpy, date și ore, hărți ordonate, precum și posibilitatea de a include comentarii în json.

Disclaimer: am creat json_tricks, deoarece am avut aceeași problemă ca și dvs.

Comentariul lui Kyle Delaney este corect așa că am încercat să folosesc răspunsul https://stackoverflow.com/a/15538391/1497139, precum și o versiune îmbunătățită a

pentru a crea un mixin JSONAble.

Deci, pentru a face o clasă JSON serializabilă, utilizați JSONAble ca o super clasă și fie apelați:

 instance.toJSON()

or

 instance.asJSON()

pentru cele două metode oferite. De asemenea, puteți extinde clasa JSONAble cu alte abordări oferite aici.

Exemplul de testare pentru testul unitar cu eșantionul de familie și persoană are ca rezultat:

toJSOn():

{
    "members": {
        "Flintstone,Fred": {
            "firstName": "Fred",
            "lastName": "Flintstone"
        },
        "Flintstone,Wilma": {
            "firstName": "Wilma",
            "lastName": "Flintstone"
        }
    },
    "name": "The Flintstones"
}

asJSOn():

{'name': 'The Flintstones', 'members': {'Flintstone,Fred': {'firstName': 'Fred', 'lastName': 'Flintstone'}, 'Flintstone,Wilma': {'firstName': 'Wilma', 'lastName': 'Flintstone'}}}

Test unitar cu eșantion de familie și persoană

def testJsonAble(self):
        family=Family("The Flintstones")
        family.add(Person("Fred","Flintstone")) 
        family.add(Person("Wilma","Flintstone"))
        json1=family.toJSON()
        json2=family.asJSON()
        print(json1)
        print(json2)

class Family(JSONAble):
    def __init__(self,name):
        self.name=name
        self.members={}
    
    def add(self,person):
        self.members[person.lastName+","+person.firstName]=person

class Person(JSONAble):
    def __init__(self,firstName,lastName):
        self.firstName=firstName;
        self.lastName=lastName;

jsonable.py care definește mixul JSONAble

 '''
Created on 2020-09-03

@author: wf
'''
import json

class JSONAble(object):
    '''
    mixin to allow classes to be JSON serializable see
    https://stackoverflow.com/questions/3768895/how-to-make-a-class-json-serializable
    '''

    def __init__(self):
        '''
        Constructor
        '''
    
    def toJSON(self):
        return json.dumps(self, default=lambda o: o.__dict__, 
            sort_keys=True, indent=4)
        
    def getValue(self,v):
        if (hasattr(v, "asJSON")):
            return v.asJSON()
        elif type(v) is dict:
            return self.reprDict(v)
        elif type(v) is list:
            vlist=[]
            for vitem in v:
                vlist.append(self.getValue(vitem))
            return vlist
        else:   
            return v
    
    def reprDict(self,srcDict):
        '''
        get my dict elements
        '''
        d = dict()
        for a, v in srcDict.items():
            d[a]=self.getValue(v)
        return d
    
    def asJSON(self):
        '''
        recursively return my dict elements
        '''
        return self.reprDict(self.__dict__)   

Veți găsi aceste abordări acum integrate în proiectul https://github.com/WolfgangFahl/pyLoDStorage care este disponibil la https://pypi.org/project/pylodstorage/

jsonweb pare a fi cea mai bună soluție pentru mine. Consultați http://www.jsonweb.info/en/latest/

from jsonweb.encode import to_object, dumper

@to_object()
class DataModel(object):
  def __init__(self, id, value):
   self.id = id
   self.value = value

>>> data = DataModel(5, "foo")
>>> dumper(data)
'{"__type__": "DataModel", "id": 5, "value": "foo"}'

Bazându-se pe Quinten Cabo răspuns:

def sterilize(obj):
    """Make an object more ameniable to dumping as json
    """
    if type(obj) in (str, float, int, bool, type(None)):
        return obj
    elif isinstance(obj, dict):
        return {k: sterilize(v) for k, v in obj.items()}
    list_ret = []
    dict_ret = {}
    for a in dir(obj):
        if a == '__iter__' and callable(obj.__iter__):
            list_ret.extend([sterilize(v) for v in obj])
        elif a == '__dict__':
            dict_ret.update({k: sterilize(v) for k, v in obj.__dict__.items() if k not in ['__module__', '__dict__', '__weakref__', '__doc__']})
        elif a not in ['__doc__', '__module__']:
            aval = getattr(obj, a)
            if type(aval) in (str, float, int, bool, type(None)):
                dict_ret[a] = aval
            elif a != '__class__' and a != '__objclass__' and isinstance(aval, type):
                dict_ret[a] = sterilize(aval)
    if len(list_ret) == 0:
        if len(dict_ret) == 0:
            return repr(obj)
        return dict_ret
    else:
        if len(dict_ret) == 0:
            return list_ret
    return (list_ret, dict_ret)

Diferentele sunt

1. Funcționează pentru orice iterabil în loc de doar list și tuple (funcționează pentru matrice NumPy etc.)
2. Funcționează pentru tipurile dinamice (cele care conțin un __dict__).
3. Include tipurile native float și None, astfel încât acestea să nu fie convertite în șir.
4. Clasele care au __dict__ și membri vor funcționa în mare parte (dacă numele __dict__ și membrii se ciocnesc, veți obține doar unul - probabil membrul)
5. Clasele care sunt liste și au membri vor arăta ca un tuplu al listei și un dicționar
6. Python3 (apelul isinstance() ar putea să fie singurul lucru care trebuie schimbat)

Cel mai mult mi-a plăcut metoda lui Lost Koder. Am întâmpinat probleme când am încercat să serializez obiecte mai complexe ale căror membri/metode nu sunt serializabile. Iată implementarea mea care funcționează pe mai multe obiecte:

class Serializer(object):
    @staticmethod
    def serialize(obj):
        def check(o):
            for k, v in o.__dict__.items():
                try:
                    _ = json.dumps(v)
                    o.__dict__[k] = v
                except TypeError:
                    o.__dict__[k] = str(v)
            return o
        return json.dumps(check(obj).__dict__, indent=2)

Am întâlnit această problemă când am încercat să stochez modelul lui Peewee în PostgreSQL JSONField.

După ce m-am chinuit o vreme, iată soluția generală.

Cheia soluției mele este să parcurg codul sursă al lui Python și să realizez că documentația codului (descrisă aici) explică deja cum să extindeți json.dumps existent pentru a accepta alte tipuri de date.

Să presupunem că aveți în prezent un model care conține unele câmpuri care nu sunt serializabile la JSON și modelul care conține câmpul JSON inițial arată astfel:

class SomeClass(Model):
    json_field = JSONField()

Doar definiți un JSONEncoder personalizat astfel:

class CustomJsonEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, SomeTypeUnsupportedByJsonDumps):
            return < whatever value you want >
        return json.JSONEncoder.default(self, obj)

    @staticmethod
    def json_dumper(obj):
        return json.dumps(obj, cls=CustomJsonEncoder)

Și apoi folosește-l în JSONField ca mai jos:

class SomeClass(Model):
    json_field = JSONField(dumps=CustomJsonEncoder.json_dumper)

Cheia este metoda default(self, obj) de mai sus. Pentru fiecare reclamație ... is not JSON serializable pe care o primiți de la Python, trebuie doar să adăugați cod pentru a gestiona tipul neserializat în JSON (cum ar fi Enum sau datetime)

De exemplu, iată cum accept o clasă care moștenește de la Enum:

class TransactionType(Enum):
   CURRENT = 1
   STACKED = 2

   def default(self, obj):
       if isinstance(obj, TransactionType):
           return obj.value
       return json.JSONEncoder.default(self, obj)

În cele din urmă, cu codul implementat ca mai sus, puteți converti orice model Peewee într-un obiect seriazabil JSON, ca mai jos:

peewee_model = WhateverPeeweeModel()
new_model = SomeClass()
new_model.json_field = model_to_dict(peewee_model)

Deși codul de mai sus a fost (oarecum) specific lui Peewee, dar cred că:

1. Este aplicabil altor ORM-uri (Django, etc) în general
2. De asemenea, dacă ați înțeles cum funcționează json.dumps, această soluție funcționează și cu Python (fără ORM) în general și

Orice întrebări, vă rugăm să postați în secțiunea de comentarii. Mulțumiri!

Mai întâi trebuie să facem obiectul nostru compatibil cu JSON, astfel încât să îl putem arunca folosind modulul JSON standard. Am facut asa:

def serialize(o):
    if isinstance(o, dict):
        return {k:serialize(v) for k,v in o.items()}
    if isinstance(o, list):
        return [serialize(e) for e in o]
    if isinstance(o, bytes):
        return o.decode("utf-8")
    return o

Această funcție folosește recursiunea pentru a itera fiecare parte a dicționarului și apoi apelează metodele repr() ale claselor care nu sunt tipuri încorporate.

def sterilize(obj):
    object_type = type(obj)
    if isinstance(obj, dict):
        return {k: sterilize(v) for k, v in obj.items()}
    elif object_type in (list, tuple):
        return [sterilize(v) for v in obj]
    elif object_type in (str, int, bool, float):
        return obj
    else:
        return obj.__repr__()

Am venit cu soluția mea. Utilizați această metodă, transmiteți orice document (dict,list, ObjectId etc) pentru a serializa.

def getSerializable(doc):
    # check if it's a list
    if isinstance(doc, list):
        for i, val in enumerate(doc):
            doc[i] = getSerializable(doc[i])
        return doc

    # check if it's a dict
    if isinstance(doc, dict):
        for key in doc.keys():
            doc[key] = getSerializable(doc[key])
        return doc

    # Process ObjectId
    if isinstance(doc, ObjectId):
        doc = str(doc)
        return doc

    # Use any other custom serializting stuff here...

    # For the rest of stuff
    return doc

Dacă puteți instala un pachet, vă recomand să încercați dill, care a funcționat foarte bine pentru proiectul meu. Un lucru frumos despre acest pachet este că are aceeași interfață ca pickle, așa că dacă ați folosit deja pickle în proiectul dvs., puteți pur și simplu să înlocuiți în dill și să vedeți dacă scriptul rulează, fără a schimba niciun cod. Deci este o soluție foarte ieftină de încercat!

(Anti-dezvăluire completă: nu sunt în niciun fel afiliat și nu am contribuit niciodată la proiectul Dill.)

Instalează pachetul:

pip install dill

Apoi editați codul pentru a importa dill în loc de pickle:

# import pickle
import dill as pickle

Rulați scriptul și vedeți dacă funcționează. (Dacă se întâmplă, poate doriți să curățați codul, astfel încât să nu mai umbriți numele modulului pickle!)

Câteva detalii despre tipurile de date pe care dill le pot și nu se serializa, de pe pagina proiectului:

dill poate mura următoarele tipuri standard:

niciunul, tip, bool, int, lung, float, complex, str, unicode, tuplu, listă, dict, fișier, buffer, încorporat, atât clase de stil vechi cât și noi, instanțe de clase de stil vechi și noi, set, frozenset, matrice , funcții, excepții

dill poate mura și tipuri standard mai „exotice”:

funcții cu randamente, funcții imbricate, lambdas, celulă, metodă, unboundmethod, modul, cod, methodwrapper, dictproxy, methoddescriptor, getsetdescriptor, memberdescriptor, wrapperdescriptor, xrange, slice, notimplemented, elipse, ieșire

dill nu poate încă mura aceste tipuri standard:

cadru, generator, traceback

Nu văd aici nicio mențiune despre versiunea în serie sau backcompat, așa că voi posta soluția mea pe care o folosesc de ceva vreme. Probabil că am mult mai multe de învățat, în special Java și Javascript sunt probabil mai maturi decât mine aici, dar aici merge

https://gist.github.com/andy-d/b7878d0044a4244a4244a42420cfea>98d50cfe4

Pentru a adăuga o altă opțiune: Puteți utiliza pachetul attrs și metoda asdict.

class ObjectEncoder(JSONEncoder):
    def default(self, o):
        return attr.asdict(o)

json.dumps(objects, cls=ObjectEncoder)

și pentru a converti înapoi

def from_json(o):
    if '_obj_name' in o:
        type_ = o['_obj_name']
        del o['_obj_name']
        return globals()[type_](**o)
    else:
        return o

data = JSONDecoder(object_hook=from_json).decode(data)

clasa arata asa

@attr.s
class Foo(object):
    x = attr.ib()
    _obj_name = attr.ib(init=False, default='Foo')

În plus față de răspunsul lui Onur, probabil doriți să vă ocupați de tipul de dată și oră ca mai jos.
(pentru a gestiona : obiectul „datetime.datetime” nu are excepția atributului „dict”.

def datetime_option(value):
    if isinstance(value, datetime.date):
        return value.timestamp()
    else:
        return value.__dict__

Utilizare:

def toJSON(self):
    return json.dumps(self, default=datetime_option, sort_keys=True, indent=4)

Aceasta este o bibliotecă mică care serializează un obiect cu toți copiii săi în JSON și, de asemenea, îl analizează înapoi:

https://github.com/tobiasholler/PyJSONSerialization/

Există multe abordări ale acestei probleme. „ObjDict” (pip install objdict) este altul. Se pune accent pe furnizarea de obiecte asemănătoare javascript care pot acționa și ca dicționare pentru a gestiona cel mai bine datele încărcate din JSON, dar există și alte caracteristici care pot fi utile. Aceasta oferă o altă soluție alternativă la problema inițială.

Am ales să folosesc decoratori pentru a rezolva problema serializării obiectelor datetime. Iată codul meu:

#myjson.py
#Author: jmooremcc 7/16/2017

import json
from datetime import datetime, date, time, timedelta
"""
This module uses decorators to serialize date objects using json
The filename is myjson.py
In another module you simply add the following import statement:
    from myjson import json

json.dumps and json.dump will then correctly serialize datetime and date 
objects
"""

def json_serial(obj):
    """JSON serializer for objects not serializable by default json code"""

    if isinstance(obj, (datetime, date)):
        serial = str(obj)
        return serial
    raise TypeError ("Type %s not serializable" % type(obj))


def FixDumps(fn):
    def hook(obj):
        return fn(obj, default=json_serial)

    return hook

def FixDump(fn):
    def hook(obj, fp):
        return fn(obj,fp, default=json_serial)

    return hook


json.dumps=FixDumps(json.dumps)
json.dump=FixDump(json.dump)


if __name__=="__main__":
    today=datetime.now()
    data={'atime':today, 'greet':'Hello'}
    str=json.dumps(data)
    print str

Prin importul modulului de mai sus, celelalte module ale mele folosesc json într-un mod normal (fără a specifica cuvântul cheie implicit) pentru a serializa datele care conțin obiecte date și oră. Codul de serializare datetime este apelat automat pentru json.dumps și json.dump.