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"}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.
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!
