Bagaimanakah saya boleh menjadikan objek tersuai JSON boleh bersiri tanpa subkelas `json.JSONEncoder`?

Menjadikan objek JSON boleh bersiri dengan pengekod biasa

Cara lalai untuk mensirikan objek tidak boleh bersiri tersuai kepada JSON ialah dengan mensubkelas json.JSONEncoder dan menghantar pengekod tersuai kepada json.dumps(). Ini biasanya kelihatan seperti berikut:

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

Walau bagaimanapun, bagaimana jika anda mahu menjadikan objek boleh bersiri dengan pengekod lalai? Selepas menyemak kod sumber modul json, nampaknya memanjangkan pengekod secara langsung tidak akan memenuhi keperluan ini.

Sebaliknya, anda boleh menggunakan teknik yang dipanggil "monkey-patching" dalam skrip permulaan __init__.py pakej anda. Ini memberi kesan kepada semua siri modul JSON yang berikutnya kerana modul biasanya dimuatkan sekali sahaja dan hasilnya dicache dalam sys.modules.

Tampalan akan mengubah suai kaedah lalai pengekod JSON lalai untuk menyemak kaedah "to_json" yang unik dan gunakannya untuk mengekod objek jika ditemui.

Berikut ialah contoh yang dilaksanakan sebagai modul kendiri untuk kesederhanaan:

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

Menggunakan tampung ini mudah: hanya import modul untuk menggunakan monyet -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>

Untuk mengekalkan maklumat jenis objek, kaedah to_json boleh memasukkannya dalam rentetan yang dikembalikan:

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

Ini menghasilkan JSON yang termasuk nama kelas:

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

Magick Berada Di Sini

Pendekatan yang lebih hebat ialah dengan menggunakan kaedah lalai penggantian mensiri kebanyakan objek Python secara automatik, termasuk contoh kelas yang ditentukan pengguna, tanpa memerlukan kaedah unik.

Setelah meneliti beberapa alternatif, pendekatan berikut berdasarkan jeruk kelihatan paling hampir dengan ideal ini:

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

Walaupun tidak semuanya boleh dijeruk (cth., jenis sambungan), jeruk menyediakan kaedah untuk mengendalikannya melalui protokol menggunakan kaedah yang unik. Walau bagaimanapun, pendekatan ini merangkumi lebih banyak kes.

Deserializing

Menggunakan protokol jeruk memudahkan pembinaan semula objek Python asal dengan menyediakan hujah fungsi object_hook tersuai kepada json.loads() apabila menemui "_python_object" kunci dalam kamus.

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

Ini boleh dipermudahkan kepada fungsi pembungkus:

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

pyobj = json_pkloads(json_str)</code>

Kod ini tidak berfungsi dalam Python 3 kerana json.dumps() mengembalikan objek bait yang JSONEncoder tidak boleh mengendalikan. Walau bagaimanapun, pendekatan ini kekal sah dengan pengubahsuaian berikut:

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

Atas ialah kandungan terperinci Bagaimanakah saya boleh menjadikan objek tersuai JSON boleh bersiri tanpa subkelas `json.JSONEncoder`?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!