Python อ็อบเจ็กต์ที่ทำให้เป็นอนุกรมได้ json

เขียนตัวเข้ารหัสและตัวถอดรหัสของคุณเอง ซึ่งสามารถเรียบง่ายมากเช่น return __dict__

เช่น. นี่คือตัวเข้ารหัสเพื่อถ่ายโอนข้อมูลโครงสร้างต้นไม้แบบเรียกซ้ำทั้งหมด คุณสามารถปรับปรุงหรือใช้เพื่อวัตถุประสงค์ของคุณเองได้

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)

มันพิมพ์

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

คุณสามารถเขียนตัวถอดรหัสได้เช่นเดียวกัน แต่คุณจะต้องระบุว่าเป็นวัตถุของคุณหรือไม่ ดังนั้นคุณอาจใส่ประเภทได้เช่นกันหากจำเป็น

jsonpickle เพื่อชัยชนะ!

(เพิ่งมีคำถามเดียวกันนี้ ... json Pickle จัดการกราฟวัตถุแบบเรียกซ้ำ / ซ้อนตลอดจนการลัดวงจรสำหรับกราฟวัตถุแบบวนรอบ)

คำตอบทางอ้อม: แทนที่จะใช้ JSON คุณสามารถใช้ YAML ซึ่งไม่มีปัญหาในการทำสิ่งที่คุณต้องการ (โดยพื้นฐานแล้ว JSON เป็นส่วนย่อยของ YAML)

ตัวอย่าง:

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

อันที่จริง YAML จัดการการอ้างอิงแบบวนให้คุณเป็นอย่างดี

ฉันใช้วิธี todict ที่ง่ายมากด้วยความช่วยเหลือของ https://stackoverflow.com/a/11637457/1766716

• วนซ้ำคุณสมบัติที่ไม่ได้ขึ้นต้นด้วย __
• กำจัดวิธีการต่างๆ
• ลบคุณสมบัติบางอย่างด้วยตนเองซึ่งไม่จำเป็น (สำหรับกรณีของฉัน มาจาก sqlalcemy)

และใช้ getattr เพื่อสร้างพจนานุกรม

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()}

วิธีแก้ปัญหาของฉันสำหรับสิ่งนี้คือการขยายคลาส 'dict' และทำการตรวจสอบเกี่ยวกับแอตทริบิวต์ที่จำเป็น/อนุญาตโดยการแทนที่วิธีการ init อัปเดต และตั้งค่าคลาส

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)

ตัวอย่างการใช้งาน:

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"
    }
)