Einfachster Weg ein einfaches Klassenobjekt mit simplejson zu serialisieren?

Ich habe diese Strategie in der Vergangenheit und war ziemlich glücklich mit ihm: - Codierung benutzerdefinierter Objekte als JSON-Objekt-Literale (wie Python dicts) mit der folgenden Struktur:

{ '__ClassName__': { ... } }

Die im wesentlichen ein eins-Element dict dessen einzelne Taste ist eine spezielle Zeichenfolge, die angibt, welche Art von Objekt kodiert ist, und dessen Wert ist ein dict von der Instanz Attribute. Wenn das Sinn macht.

Eine sehr einfache Umsetzung von einem encoder und einem decoder (vereinfacht code habe ich tatsächlich verwendet) ist etwa so:

TYPES = { 'ParentClass': ParentClass,
          'ChildClass': ChildClass }


class CustomTypeEncoder(json.JSONEncoder):
    """A custom JSONEncoder class that knows how to encode core custom
    objects.

    Custom objects are encoded as JSON object literals (ie, dicts) with
    one key, '__TypeName__' where 'TypeName' is the actual name of the
    type to which the object belongs.  That single key maps to another
    object literal which is just the __dict__ of the object encoded."""

    def default(self, obj):
        if isinstance(obj, TYPES.values()):
            key = '__%s__' % obj.__class__.__name__
            return { key: obj.__dict__ }
        return json.JSONEncoder.default(self, obj)


def CustomTypeDecoder(dct):
    if len(dct) == 1:
        type_name, value = dct.items()[0]
        type_name = type_name.strip('_')
        if type_name in TYPES:
            return TYPES[type_name].from_dict(value)
    return dct

In dieser Implementierung wird davon ausgegangen, dass die Objekte, die Sie kodierende haben from_dict() Methode der Klasse, die weiß, wie man erstellen Sie eine Instanz von einem dict decodiert von JSON.

Es ist einfach zu erweitern die encoder-und decoder-Unterstützung von benutzerdefinierten Typen (z.B. datetime Objekte).

BEARBEITENbeantworten Ihre edit: Die nette Sache über eine Umsetzung wie diese ist, dass es automatisch Kodieren und Dekodieren von Instanzen eines beliebigen Objekts gefunden in der TYPES mapping. Das bedeutet, dass es automatisch Griff eine ChildClass etwa so:

class ChildClass(object):
    def __init__(self):
        self.foo = 'foo'
        self.bar = 1.1
        self.parent = ParentClass(1)

Sollte das Ergebnis im JSON-so etwas wie die folgenden:

{ '__ChildClass__': {
    'bar': 1.1,
    'foo': 'foo',
    'parent': {
        '__ParentClass__': {
            'foo': 1}
        }
    }
}

InformationsquelleAutor der Antwort Will McCutchen

Wenn Sie mit Django, es kann leicht getan werden, die über Django ' s serialisierungsprogramme Modul. Mehr info finden Sie hier: https://docs.djangoproject.com/en/dev/topics/serialization/

InformationsquelleAutor der Antwort Ozgur Akcali

Ich habe ein ähnliches problem, aber die json.dump Funktion wird nicht aufgerufen von mir.
Also, um MyClass JSON serialisierbar ohne Angabe einer benutzerdefinierten encoder json.dump Sie haben zu Monkey patch der json-encoder.

Erstellen Sie zuerst Ihre encoder in Ihrem Modul my_module:

import json

class JSONEncoder(json.JSONEncoder):
    """To make MyClass JSON serializable you have to Monkey patch the json
    encoder with the following code:
    >>> import json
    >>> import my_module
    >>> json.JSONEncoder.default = my_module.JSONEncoder.default
    """
    def default(self, o):
        """For JSON serialization."""
        if isinstance(o, MyClass):
            return o.__repr__()
        else:
            return super(self,o)

class MyClass:
    def __repr__(self):
        return "my class representation"

Dann, wie es beschrieben wird in den Kommentar, monkey patch der json-encoder:

import json
import my_module
json.JSONEncoder.default = my_module.JSONEncoder.default

Nun auch ein call of json.dump in einer externen Bibliothek (wo Sie nicht ändern, die cls parameter) für Ihre my_module.MyClass Objekte.

InformationsquelleAutor der Antwort mickours

Ich fühle mich ein bisschen albern, über meine möglichen 2 Lösungen Wiederlesen es jetzt,
natürlich, wenn Sie verwenden, django-rest-Rahmen, diese Rahmen haben einige hervorragende Eigenschaften Objekt für das oben erwähnte problem.

sehen das model-view-Beispiel auf Ihrer website

Wenn Sie nicht mit dem django-rest-framework, das kann trotzdem helfen:

Fand ich 2 nützliche Lösungen für dieses problem auf dieser Seite: (ich mag die zweite am meisten!)

Mögliche Lösung 1 (oder Weg):
David-Kammern-Design, eine schöne Lösung

Ich hoffe, dass David nicht daran, dass ich copy paste seine Lösung hier den code:

Definieren eine Serialisierungs-Methode auf der Instanz-Modell:

def toJSON(self):
import simplejson
return simplejson.dumps(dict([(attr, getattr(self, attr)) for attr in [f.name for f in self._meta.fields]]))

ist und er sogar extrahiert die oben beschriebene Methode, so ist es besser lesbar:

def toJSON(self):
fields = []
for field in self._meta.fields:
    fields.append(field.name)

d = {}
for attr in fields:
    d[attr] = getattr(self, attr)

import simplejson
return simplejson.dumps(d)

Bitte beachtet, es ist nicht meine Lösung, alle Gutschriften geht an den link enthalten. Dachte nur das sollte auf stack overflow.

Dies könnte umgesetzt werden in den Antworten auch.

Lösung 2:

Meine bevorzugt Lösung auf dieser Seite gefunden:

http://www.traddicts.org/webdevelopment/flexible-and-simple-json-serialization-for-django/

Übrigens, ich habe den Autor der zweite und beste Lösung: auf stackoverflow:

Selaux

Ich hoffe, er sieht es, und wir sprechen ab, zu implementieren und zu verbessern, seinen code in einem offenen Lösung?

InformationsquelleAutor der Antwort michel.iamit