Objek serialisasi Python json

Tulis encoder dan decoder Anda sendiri, yang bisa sangat sederhana seperti return __dict__

misalnya di sini adalah pembuat enkode untuk membuang struktur pohon yang benar-benar rekursif, Anda dapat menyempurnakannya atau menggunakannya sebagaimana adanya untuk tujuan Anda sendiri

import json

class Tree(object):
    def __init__(self, name, childTrees=None):
        self.name = name
        if childTrees is None:
            childTrees = []
        self.childTrees = childTrees

class MyEncoder(json.JSONEncoder):
    def default(self, obj):
        if not isinstance(obj, Tree):
            return super(MyEncoder, self).default(obj)

        return obj.__dict__

c1 = Tree("c1")
c2 = Tree("c2") 
t = Tree("t",[c1,c2])

print json.dumps(t, cls=MyEncoder)

itu mencetak

{"childTrees": [{"childTrees": [], "name": "c1"}, {"childTrees": [], "name": "c2"}], "name": "t"}

Anda juga dapat menulis dekoder tetapi di sana Anda perlu mengidentifikasi apakah itu objek Anda atau bukan, jadi mungkin Anda dapat memasukkan tipenya juga jika diperlukan.

jsonpickle UNTUK MENANG!

(Baru saja mendapat pertanyaan yang sama... acar json menangani grafik objek rekursif/bersarang serta sirkuit pendek untuk grafik objek siklis).

Jawaban tidak langsung: daripada menggunakan JSON, Anda dapat menggunakan YAML, yang tidak memiliki masalah dalam melakukan apa yang Anda inginkan. (JSON pada dasarnya adalah bagian dari YAML.)

Contoh:

import yaml
o1 = gwebpage("url")
o2 = gpagelet(o1)
o1.gpagelets = [o2]
print yaml.dump(o1)

Faktanya, YAML menangani referensi siklik dengan baik untuk Anda.

Saya menerapkan metode todict yang sangat sederhana dengan bantuan https://stackoverflow.com/a/11637457/1766716

• Ulangi properti yang tidak dimulai dengan __
• Hilangkan metode
• Hilangkan beberapa properti secara manual yang tidak diperlukan (untuk kasus saya, berasal dari sqlalcemy)

Dan menggunakan getattr untuk membuat kamus.

class User(Base):
    id = Column(Integer, primary_key=True)
    firstname = Column(String(50))
    lastname = Column(String(50))
    password = Column(String(20))
    def props(self):
        return filter(
            lambda a:
            not a.startswith('__')
            and a not in ['_decl_class_registry', '_sa_instance_state', '_sa_class_manager', 'metadata']
            and not callable(getattr(self, a)),
            dir(self))
    def todict(self):
        return {k: self.__getattribute__(k) for k in self.props()}

Solusi saya untuk ini adalah memperluas kelas 'dict' dan melakukan pemeriksaan seputar atribut yang diperlukan/diizinkan dengan mengganti metode kelas init, update, dan set.

class StrictDict(dict):
    required=set()
    at_least_one_required=set()
    cannot_coexist=set()
    allowed=set()
    def __init__(self, iterable={}, **kwargs):
        super(StrictDict, self).__init__({})
        keys = set(iterable.keys()).union(set(kwargs.keys()))
        if not keys.issuperset(self.required):
            msg = str(self.__class__.__name__) + " requires: " + str([str(key) for key in self.required])
            raise AttributeError(msg)
        if len(list(self.at_least_one_required)) and len(list(keys.intersection(self.at_least_one_required))) < 1:
            msg = str(self.__class__.__name__) + " requires at least one: " + str([str(key) for key in self.at_least_one_required])
            raise AttributeError(msg)
        for key, val in iterable.iteritems():
            self.__setitem__(key, val)
        for key, val in kwargs.iteritems():
            self.__setitem__(key, val)

    def update(self, E=None, **F):
        for key, val in E.iteritems():
            self.__setitem__(key, val)
        for key, val in F.iteritems():
            self.__setitem__(key, val)
        super(StrictDict, self).update({})

    def __setitem__(self, key, value):
        all_allowed = self.allowed.union(self.required).union(self.at_least_one_required).union(self.cannot_coexist)
        if key not in list(all_allowed):
            msg = str(self.__class__.__name__) + " does not allow member '" + key + "'"
            raise AttributeError(msg)
        if key in list(self.cannot_coexist):
            for item in list(self.cannot_coexist):
                if key != item and item in self.keys():
                    msg = str(self.__class__.__name__) + "does not allow members '" + key + "' and '" + item + "' to coexist'"
                    raise AttributeError(msg)
        super(StrictDict, self).__setitem__(key, value)

Contoh penggunaan:

class JSONDoc(StrictDict):
    """
    Class corresponding to JSON API top-level document structure
    http://jsonapi.org/format/#document-top-level
    """
    at_least_one_required={'data', 'errors', 'meta'}
    allowed={"jsonapi", "links", "included"}
    cannot_coexist={"data", "errors"}
    def __setitem__(self, key, value):
        if key == "included" and "data" not in self.keys():
            msg = str(self.__class__.__name__) + " does not allow 'included' member if 'data' member is not present"
            raise AttributeError(msg)
        super(JSONDoc, self).__setitem__(key, value)

json_doc = JSONDoc(
    data={
        "id": 5,
        "type": "movies"
    },
    links={
        "self": "http://url.com"
    }
)