Wie kann ich benutzerdefinierte JSON-Objekte serialisierbar machen, ohne „json.JSONEncoder“ in eine Unterklasse zu unterteilen?

Objekte JSON-serialisierbar machen mit dem regulären Encoder

Die Standardmethode zum Serialisieren benutzerdefinierter nicht serialisierbarer Objekte in JSON besteht darin, json.JSONEncoder in eine Unterklasse zu unterteilen und einen benutzerdefinierten Encoder an zu übergeben json.dumps(). Dies sieht normalerweise wie folgt aus:

<code class="python">class CustomEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, Foo):
            return obj.to_json()

        return json.JSONEncoder.default(self, obj)

print(json.dumps(obj, cls=CustomEncoder))</code>

Was aber, wenn Sie ein Objekt mit dem Standard-Encoder serialisierbar machen möchten? Nach Überprüfung des Quellcodes des JSON-Moduls scheint es, dass eine direkte Erweiterung des Encoders diese Anforderung nicht erfüllt.

Stattdessen können Sie eine Technik namens „Monkey-Patching“ im __init__.py-Initialisierungsskript Ihres Pakets verwenden. Dies betrifft alle nachfolgenden Serialisierungen von JSON-Modulen, da Module im Allgemeinen nur einmal geladen werden und das Ergebnis in sys.modules zwischengespeichert wird.

Der Patch würde die Standardmethode des Standard-JSON-Encoders ändern, um nach einer eindeutigen „to_json“-Methode zu suchen und verwenden Sie es, um das Objekt zu kodieren, wenn es gefunden wird.

Hier ist ein Beispiel, das der Einfachheit halber als eigenständiges Modul implementiert wurde:

<code class="python"># Module: make_json_serializable.py

from json import JSONEncoder

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

_default.default = JSONEncoder.default  # Save unmodified default.
JSONEncoder.default = _default  # Replace it.</code>

Die Verwendung dieses Patches ist einfach: Importieren Sie einfach das Modul, um den Affen anzuwenden -patch.

<code class="python"># Sample client script

import json
import make_json_serializable  # apply monkey-patch

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

    def to_json(self):  # New special method.
        """Convert to JSON format string representation."""
        return '{"name": "%s"}' % self.name

foo = Foo('sazpaz')
print(json.dumps(foo))  # -> '{"name": "sazpaz"}'</code>

Um Objekttypinformationen beizubehalten, kann die to_json-Methode diese in die zurückgegebene Zeichenfolge einschließen:

<code class="python">def to_json(self):
    """Convert to JSON format string representation."""
    return '{"type": "%s", "name": "%s"}' % (self.__class__.__name__, self.name)</code>

Dies erzeugt JSON, das den Klassennamen enthält:

{"type": "Foo", "name": "sazpaz"}

Hier liegt die Magie

Ein noch leistungsfähigerer Ansatz besteht darin, dass die Ersatz-Standardmethode die meisten Python-Objekte, einschließlich benutzerdefinierter Klasseninstanzen, automatisch serialisiert, ohne dass eine eindeutige Methode erforderlich ist.

Nach der Untersuchung mehrerer Alternativen scheint der folgende auf Pickle basierende Ansatz diesem Ideal am nächsten zu kommen:

<code class="python"># Module: make_json_serializable2.py

from json import JSONEncoder
import pickle

def _default(self, obj):
    return {"_python_object": pickle.dumps(obj)}

JSONEncoder.default = _default  # Replace with the above.</code>

Während nicht alles eingelegt werden kann (z. B. Erweiterungstypen), bietet Pickle Methoden, um diese über ein Protokoll zu handhaben mit einzigartigen Methoden. Dieser Ansatz deckt jedoch mehr Fälle ab.

Deserialisieren

Die Verwendung des Pickle-Protokolls vereinfacht die Rekonstruktion des ursprünglichen Python-Objekts, indem ein benutzerdefiniertes object_hook-Funktionsargument für json.loads() bereitgestellt wird, wenn auf ein „_python_object“ gestoßen wird. Geben Sie den Schlüssel im Wörterbuch ein.

<code class="python">def as_python_object(dct):
    try:
        return pickle.loads(str(dct['_python_object']))
    except KeyError:
        return dct

pyobj = json.loads(json_str, object_hook=as_python_object)</code>

Dies kann zu einer Wrapper-Funktion vereinfacht werden:

<code class="python">json_pkloads = functools.partial(json.loads, object_hook=as_python_object)

pyobj = json_pkloads(json_str)</code>

Dieser Code funktioniert in Python 3 nicht, da json.dumps() ein Byte-Objekt zurückgibt das JSONEncoder nicht verarbeiten kann. Der Ansatz bleibt jedoch mit der folgenden Änderung gültig:

<code class="python">def _default(self, obj):
    return {"_python_object": pickle.dumps(obj).decode('latin1')}

def as_python_object(dct):
    try:
        return pickle.loads(dct['_python_object'].encode('latin1'))
    except KeyError:
        return dct</code>

Das obige ist der detaillierte Inhalt vonWie kann ich benutzerdefinierte JSON-Objekte serialisierbar machen, ohne „json.JSONEncoder“ in eine Unterklasse zu unterteilen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!