JSON sinfini qanday qilib seriyali qilish mumkin

Kutilayotgan natija haqida fikringiz bormi? Masalan, bu amalga oshadimi?

>>> f  = FileItem("/foo/bar")
>>> magic(f)
'{"fname": "/foo/bar"}'

Bunday holda siz shunchaki json.dumps(f.__dict__) raqamiga qo'ng'iroq qilishingiz mumkin.

Agar siz ko'proq moslashtirilgan chiqishni istasangiz, unda siz JSONEncoder kichik sinfiga kirishingiz va amalga oshirishingiz kerak bo'ladi. o'zingizning shaxsiy serializatsiyangiz.

Arzimas misol uchun, pastga qarang.

>>> from json import JSONEncoder
>>> class MyEncoder(JSONEncoder):
        def default(self, o):
            return o.__dict__    

>>> MyEncoder().encode(f)
'{"fname": "/foo/bar"}'

Keyin siz ushbu sinfni json.dumps() usuliga cls kwarg sifatida o'tkazasiz:

json.dumps(cls=MyEncoder)

Agar siz ham dekodlashni istasangiz, JSONDecoder uchun maxsus object_hook ni taqdim etishingiz kerak bo‘ladi. sinf. Masalan:

>>> def from_json(json_object):
        if 'fname' in json_object:
            return FileItem(json_object['fname'])
>>> f = JSONDecoder(object_hook = from_json).decode('{"fname": "/foo/bar"}')
>>> f
<__main__.FileItem object at 0x9337fac>
>>> 

Mana oddiy xususiyat uchun oddiy yechim:

.toJSON() Usul

JSON seriyali sinf o'rniga serializator usulini qo'llang:

import json

class Object:
    def toJSON(self):
        return json.dumps(self, default=lambda o: o.__dict__, 
            sort_keys=True, indent=4)

Shunday qilib, siz uni seriyali qilish uchun chaqirasiz:

me = Object()
me.name = "Onur"
me.age = 35
me.dog = Object()
me.dog.name = "Apollo"

print(me.toJSON())

chiqadi:

{
    "age": 35,
    "dog": {
        "name": "Apollo"
    },
    "name": "Onur"
}

Murakkab sinflar uchun jsonpickle vositasini ko'rib chiqishingiz mumkin:

jsonpickle - bu JSON-ga va JSON-dan murakkab Python obyektlarini ketma-ketlashtirish va seriyadan chiqarish uchun Python kutubxonasi.

Python-ni JSON-ga kodlash uchun standart Python kutubxonalari, masalan, stdlib's json, simplejson va demjson, faqat to'g'ridan-to'g'ri JSON ekvivalentiga ega bo'lgan Python primitivlarini (masalan, dicts, lists, strings, ints, va hokazo) ishlay oladi. jsonpickle ushbu kutubxonalar ustiga quriladi va yanada murakkab ma'lumotlar tuzilmalarini JSONga seriyalashtirishga imkon beradi. jsonpickle juda sozlanishi va kengaytirilishi mumkin - bu foydalanuvchiga JSON backend-ni tanlash va qo'shimcha backendlarni qo'shish imkonini beradi.

(PyPi-da jsonpickle havolasi)

Ko'pgina javoblar qo'ng'iroqni json.dumps() ga o'zgartirishni o'z ichiga oladi, bu har doim ham mumkin emas yoki istalmagan (masalan, ramka komponentida sodir bo'lishi mumkin).

Agar siz json.dumps(obj) ni avvalgidek chaqirishni istasangiz, oddiy yechim dictdan meros qilib olinadi:

class FileItem(dict):
    def __init__(self, fname):
        dict.__init__(self, fname=fname)

f = FileItem('tasks.txt')
json.dumps(f)  #No need to change anything here

Bu sizning sinfingiz oddiy ma'lumotlarni taqdim etish bo'lsa ishlaydi, qiyinroq narsalar uchun kalitlarni har doim aniq belgilashingiz mumkin.

Menga Onurning javobi yoqadi, lekin ob'ektlarni ketma-ketlashtirish uchun ixtiyoriy toJSON() usulini qo'shish uchun kengaytiraman:

def dumper(obj):
    try:
        return obj.toJSON()
    except:
        return obj.__dict__
print json.dumps(some_big_object, default=dumper, indent=2)

Shunchaki sinfingizga to_json usulini qo'shing:

def to_json(self):
  return self.message # or how you want it to be serialized

Va ushbu kodni (ushbu javobdan), hamma narsaning yuqori qismidagi biror joyga qo'shing:

from json import JSONEncoder

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

_default.default = JSONEncoder().default
JSONEncoder.default = _default

Bu import qilinganida json moduliga maymun-patch qo'yadi, shuning uchun JSONEncoder.default() avtomatik ravishda maxsus "to_json()" usulini tekshiradi va agar topilsa, undan ob'ektni kodlash uchun foydalanadi.

Xuddi Onur aytganidek, lekin bu safar loyihangizdagi har json.dumps() ni yangilashingiz shart emas.

Yana bir variant - JSON dampingini o'z sinfiga o'rash:

import json

class FileItem:
    def __init__(self, fname):
        self.fname = fname

    def __repr__(self):
        return json.dumps(self.__dict__)

Yoki undan ham yaxshisi, JsonSerializable sinfidagi FileItem sinfining pastki sinfini:

import json

class JsonSerializable(object):
    def toJson(self):
        return json.dumps(self.__dict__)

    def __repr__(self):
        return self.toJson()


class FileItem(JsonSerializable):
    def __init__(self, fname):
        self.fname = fname

Sinov:

>>> f = FileItem('/foo/bar')
>>> f.toJson()
'{"fname": "/foo/bar"}'
>>> f
'{"fname": "/foo/bar"}'
>>> str(f) # string coercion
'{"fname": "/foo/bar"}'

Boshqa ko'plab javoblarda aytib o'tilganidek, sukut bo'yicha qo'llab-quvvatlanadigan turlardan biri bo'lmagan ob'ektlarni qo'llab-quvvatlanadigan turga aylantirish uchun funksiyani json.dumps ga o'tkazishingiz mumkin. Ajablanarlisi shundaki, ularning hech birida eng oddiy holat, ya'ni o'rnatilgan funksiyasidan foydalanish haqida aytilmagan. vars ob'ektlarni barcha atributlarini o'z ichiga olgan dictga aylantirish uchun:

json.dumps(obj, default=vars)

E'tibor bering, bu faqat asosiy holatlarni qamrab oladi, agar sizga ma'lum turlar uchun (masalan, ma'lum atributlar bundan mustasno yoki __dict__ atributiga ega bo'lmagan ob'ektlar uchun) aniqroq ketma-ketlashtirish kerak bo'lsa, boshqa javoblarda aytilganidek, maxsus funksiya yoki JSONEncoder dan foydalanishingiz kerak. .

Men boshqa kuni bu muammoga duch keldim va Python ob'ektlari uchun kodlovchining umumiy versiyasini joriy qildim, u ichiga o'rnatilgan ob'ektlar va meroslangan maydonlarni boshqarishi mumkin:

import json
import inspect

class ObjectEncoder(json.JSONEncoder):
    def default(self, obj):
        if hasattr(obj, "to_json"):
            return self.default(obj.to_json())
        elif hasattr(obj, "__dict__"):
            d = dict(
                (key, value)
                for key, value in inspect.getmembers(obj)
                if not key.startswith("__")
                and not inspect.isabstract(value)
                and not inspect.isbuiltin(value)
                and not inspect.isfunction(value)
                and not inspect.isgenerator(value)
                and not inspect.isgeneratorfunction(value)
                and not inspect.ismethod(value)
                and not inspect.ismethoddescriptor(value)
                and not inspect.isroutine(value)
            )
            return self.default(d)
        return obj

Misol:

class C(object):
    c = "NO"
    def to_json(self):
        return {"c": "YES"}

class B(object):
    b = "B"
    i = "I"
    def __init__(self, y):
        self.y = y
        
    def f(self):
        print "f"

class A(B):
    a = "A"
    def __init__(self):
        self.b = [{"ab": B("y")}]
        self.c = C()

print json.dumps(A(), cls=ObjectEncoder, indent=2, sort_keys=True)

Natija:

{
  "a": "A", 
  "b": [
    {
      "ab": {
        "b": "B", 
        "i": "I", 
        "y": "y"
      }
    }
  ], 
  "c": {
    "c": "YES"
  }, 
  "i": "I"
}

Agar siz Python3.5+ dan foydalansangiz, jsons dan foydalanishingiz mumkin. (PyPi: https://pypi.org/project/jsons/) U ob'ektingizni aylantiradi. (va uning barcha atributlari rekursiv) dictga.

import jsons

a_dict = jsons.dump(your_object)

Yoki qatorni xohlasangiz:

a_str = jsons.dumps(your_object)

Yoki sizning sinfingiz jsons.JsonSerializable ni amalga oshirgan bo'lsa:

a_dict = your_object.json

import simplejson

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

    def _asdict(self):
        return self.__dict__

print(simplejson.dumps(User('alice', '[email protected]')))

standart json dan foydalansangiz, default funksiyasini belgilashingiz kerak

import json
def default(o):
    return o._asdict()

print(json.dumps(User('alice', '[email protected]'), default=default))

json chop etishi mumkin bo'lgan ob'ektlar nuqtai nazaridan cheklangan va jsonpickle (sizga pip install jsonpickle kerak bo'lishi mumkin) matnni cheklamasligi bilan cheklangan. Agar siz sinfini o'zgartira olmaydigan ob'ektning mazmunini tekshirmoqchi bo'lsangiz, men hali ham to'g'riroq yo'l topa olmadim:

 import json
 import jsonpickle
 ...
 print  json.dumps(json.loads(jsonpickle.encode(object)), indent=2)

Eslatma: ular hali ham ob'ekt usullarini chop eta olmaydilar.

Bu sinf hiyla qila oladi, ob'ektni standart json ga o'zgartiradi.

import json


class Serializer(object):
    @staticmethod
    def serialize(object):
        return json.dumps(object, default=lambda o: o.__dict__.values()[0])

foydalanish:

Serializer.serialize(my_object)

python2.7 va python3 da ishlash.

Mana mening 3 sentim...
Bu daraxtga o'xshash python ob'ekti uchun aniq json serializatsiyasini ko'rsatadi.
Eslatma: Agar siz haqiqatan ham shunday kodni xohlasangiz, twisted FilePath sinfi.

import json, sys, os

class File:
    def __init__(self, path):
        self.path = path

    def isdir(self):
        return os.path.isdir(self.path)

    def isfile(self):
        return os.path.isfile(self.path)

    def children(self):        
        return [File(os.path.join(self.path, f)) 
                for f in os.listdir(self.path)]

    def getsize(self):        
        return os.path.getsize(self.path)

    def getModificationTime(self):
        return os.path.getmtime(self.path)

def _default(o):
    d = {}
    d['path'] = o.path
    d['isFile'] = o.isfile()
    d['isDir'] = o.isdir()
    d['mtime'] = int(o.getModificationTime())
    d['size'] = o.getsize() if o.isfile() else 0
    if o.isdir(): d['children'] = o.children()
    return d

folder = os.path.abspath('.')
json.dump(File(folder), sys.stdout, default=_default)

jaraco juda aniq javob berdi. Men ba'zi kichik narsalarni tuzatishim kerak edi, lekin bu ishlaydi:

Kod

# Your custom class
class MyCustom(object):
    def __json__(self):
        return {
            'a': self.a,
            'b': self.b,
            '__python__': 'mymodule.submodule:MyCustom.from_json',
        }

    to_json = __json__  # supported by simplejson

    @classmethod
    def from_json(cls, json):
        obj = cls()
        obj.a = json['a']
        obj.b = json['b']
        return obj

# Dumping and loading
import simplejson

obj = MyCustom()
obj.a = 3
obj.b = 4

json = simplejson.dumps(obj, for_json=True)

# Two-step loading
obj2_dict = simplejson.loads(json)
obj2 = MyCustom.from_json(obj2_dict)

# Make sure we have the correct thing
assert isinstance(obj2, MyCustom)
assert obj2.__dict__ == obj.__dict__

E'tibor bering, yuklash uchun bizga ikkita qadam kerak. Hozircha __python__ xususiyati ishlatilmaydi.

Bu qanchalik keng tarqalgan?

AlJohri usulidan foydalanib, yondashuvlarning mashhurligini tekshiraman:

Seriyalashtirish (Python -> JSON):

• to_json: 266 595, 27.06.2018
• toJSON: 2018-06-27 da 96 307
• __json__: 2018-06-27 da 8504
• for_json: 2018-06-yilda 6 937 -27

Deserializatsiya (JSON -> Python):

• from_json: 226,101, 27-06-2018

Bu men uchun yaxshi ishladi:

class JsonSerializable(object):

    def serialize(self):
        return json.dumps(self.__dict__)

    def __repr__(self):
        return self.serialize()

    @staticmethod
    def dumper(obj):
        if "serialize" in dir(obj):
            return obj.serialize()

        return obj.__dict__

undan keyin

class FileItem(JsonSerializable):
    ...

va

log.debug(json.dumps(<my object>, default=JsonSerializable.dumper, indent=2))

Agar paketni oʻrnatishga qarshi boʻlmasangiz, json-tricks:

pip install json-tricks

Shundan so'ng siz json o'rniga json_tricks dan dump(s) ni import qilishingiz kerak va u odatda ishlaydi:

from json_tricks import dumps
json_str = dumps(cls_instance, indent=4)

qaysi beradi

{
        "__instance_type__": [
                "module_name.test_class",
                "MyTestCls"
        ],
        "attributes": {
                "attr": "val",
                "dct_attr": {
                        "hello": 42
                }
        }
}

Va bu, asosan, shunday!

Bu umuman olganda ajoyib ishlaydi. Ba'zi istisnolar mavjud, masalan. agar __new__ da maxsus narsalar sodir bo'lsa yoki ko'proq metaklass sehrlari davom etsa.

Shubhasiz, yuklash ham ishlaydi (aks holda nima bo'ladi):

from json_tricks import loads
json_str = loads(json_str)

Bu module_name.test_class.MyTestCls import qilinishi mumkinligini va mos kelmaydigan usullarda o'zgarmasligini nazarda tutadi. Siz lug'at yoki boshqa narsalarni emas, balki namunani qaytarasiz va u siz tashlagan nusxaning bir xil nusxasi bo'lishi kerak.

Agar biror narsaning seriyali bo'lishini sozlashni istasangiz, sinfingizga maxsus usullarni qo'shishingiz mumkin, masalan:

class CustomEncodeCls:
        def __init__(self):
                self.relevant = 42
                self.irrelevant = 37

        def __json_encode__(self):
                # should return primitive, serializable types like dict, list, int, string, float...
                return {'relevant': self.relevant}

        def __json_decode__(self, **attrs):
                # should initialize all properties; note that __init__ is not called implicitly
                self.relevant = attrs['relevant']
                self.irrelevant = 12

misol sifatida atributlar parametrlarining faqat bir qismini ketma-ketlashtiradi.

Va bepul bonus sifatida siz numpy massivlarni, sana va vaqtlarni, buyurtma qilingan xaritalarni seriyalashtirishni, shuningdek json-ga sharhlarni kiritish imkoniyatini olasiz.

Rad etish: Men json_tricks ni yaratdim, chunki menda siz bilan bir xil muammo bor edi.

Kyle Delaneyning izohi to‘g‘ri shuning uchun men https://stackoverflow.com, shuningdek https://stackoverflow.com/a/10254820/1497139takomillashtirilganversiyasi.

JSONAble mixini yaratish uchun.

Shunday qilib, JSON sinfini seriyali qilish uchun super sinf sifatida JSONAble dan foydalaning va qo'ng'iroq qiling:

 instance.toJSON()

or

 instance.asJSON()

taklif qilingan ikkita usul uchun. JSONAble sinfini bu yerda taklif qilingan boshqa yondashuvlar bilan ham kengaytirishingiz mumkin.

Oila va shaxs bilan birlik testi namunasi uchun test namunasi quyidagi natijalarni beradi:

toJSON():

{
    "members": {
        "Flintstone,Fred": {
            "firstName": "Fred",
            "lastName": "Flintstone"
        },
        "Flintstone,Wilma": {
            "firstName": "Wilma",
            "lastName": "Flintstone"
        }
    },
    "name": "The Flintstones"
}

asJSON():

{'name': 'The Flintstones', 'members': {'Flintstone,Fred': {'firstName': 'Fred', 'lastName': 'Flintstone'}, 'Flintstone,Wilma': {'firstName': 'Wilma', 'lastName': 'Flintstone'}}}

Oila va shaxs bilan birlik testi namunasi

def testJsonAble(self):
        family=Family("The Flintstones")
        family.add(Person("Fred","Flintstone")) 
        family.add(Person("Wilma","Flintstone"))
        json1=family.toJSON()
        json2=family.asJSON()
        print(json1)
        print(json2)

class Family(JSONAble):
    def __init__(self,name):
        self.name=name
        self.members={}
    
    def add(self,person):
        self.members[person.lastName+","+person.firstName]=person

class Person(JSONAble):
    def __init__(self,firstName,lastName):
        self.firstName=firstName;
        self.lastName=lastName;

jsonable.py JSONAble aralashmasini aniqlaydi

 '''
Created on 2020-09-03

@author: wf
'''
import json

class JSONAble(object):
    '''
    mixin to allow classes to be JSON serializable see
    https://stackoverflow.com/questions/3768895/how-to-make-a-class-json-serializable
    '''

    def __init__(self):
        '''
        Constructor
        '''
    
    def toJSON(self):
        return json.dumps(self, default=lambda o: o.__dict__, 
            sort_keys=True, indent=4)
        
    def getValue(self,v):
        if (hasattr(v, "asJSON")):
            return v.asJSON()
        elif type(v) is dict:
            return self.reprDict(v)
        elif type(v) is list:
            vlist=[]
            for vitem in v:
                vlist.append(self.getValue(vitem))
            return vlist
        else:   
            return v
    
    def reprDict(self,srcDict):
        '''
        get my dict elements
        '''
        d = dict()
        for a, v in srcDict.items():
            d[a]=self.getValue(v)
        return d
    
    def asJSON(self):
        '''
        recursively return my dict elements
        '''
        return self.reprDict(self.__dict__)   

Ushbu yondashuvlarni endi https://github.com/WolfgangFahl/pyLoDStorage loyihasida integratsiyalashgan holda topasiz. Bu https://pypi.org/project/pylodstorage/ sahifasida mavjud

jsonweb men uchun eng yaxshi yechim kabi ko'rinadi. http://www.jsonweb.info/en/latest/ ga qarang.

from jsonweb.encode import to_object, dumper

@to_object()
class DataModel(object):
  def __init__(self, id, value):
   self.id = id
   self.value = value

>>> data = DataModel(5, "foo")
>>> dumper(data)
'{"__type__": "DataModel", "id": 5, "value": "foo"}'

Quinten Cabo asosida qurish javob:

def sterilize(obj):
    """Make an object more ameniable to dumping as json
    """
    if type(obj) in (str, float, int, bool, type(None)):
        return obj
    elif isinstance(obj, dict):
        return {k: sterilize(v) for k, v in obj.items()}
    list_ret = []
    dict_ret = {}
    for a in dir(obj):
        if a == '__iter__' and callable(obj.__iter__):
            list_ret.extend([sterilize(v) for v in obj])
        elif a == '__dict__':
            dict_ret.update({k: sterilize(v) for k, v in obj.__dict__.items() if k not in ['__module__', '__dict__', '__weakref__', '__doc__']})
        elif a not in ['__doc__', '__module__']:
            aval = getattr(obj, a)
            if type(aval) in (str, float, int, bool, type(None)):
                dict_ret[a] = aval
            elif a != '__class__' and a != '__objclass__' and isinstance(aval, type):
                dict_ret[a] = sterilize(aval)
    if len(list_ret) == 0:
        if len(dict_ret) == 0:
            return repr(obj)
        return dict_ret
    else:
        if len(dict_ret) == 0:
            return list_ret
    return (list_ret, dict_ret)

Farqlar

1. Faqat list va tuple o'rniga har qanday iteratsiya uchun ishlaydi (u NumPy massivlari va boshqalar uchun ishlaydi).
2. Dinamik turlar uchun ishlaydi (__dict__ ni o'z ichiga olganlar).
3. float va None mahalliy turlarini o'z ichiga oladi, shuning uchun ular stringga aylantirilmaydi.
4. __dict__ va aʼzolar boʻlgan sinflar asosan ishlaydi (agar __dict__ va aʼzo nomlari toʻqnash kelsa, siz faqat bittasini olasiz – ehtimol aʼzo)
5. Roʻyxat boʻlgan va aʼzolari boʻlgan sinflar roʻyxat va lugʻat toʻplamiga oʻxshaydi
6. Python3 (bu isinstance() qo'ng'irog'i o'zgartirilishi kerak bo'lgan yagona narsa bo'lishi mumkin)

Menga Lost Koderning usuli eng yoqdi. A'zolari/usullari seriyali bo'lmagan murakkabroq ob'ektlarni ketma-ketlashtirishga urinayotganda muammolarga duch keldim. Ko'proq ob'ektlarda ishlaydigan mening ilovam:

class Serializer(object):
    @staticmethod
    def serialize(obj):
        def check(o):
            for k, v in o.__dict__.items():
                try:
                    _ = json.dumps(v)
                    o.__dict__[k] = v
                except TypeError:
                    o.__dict__[k] = str(v)
            return o
        return json.dumps(check(obj).__dict__, indent=2)

Peewee modelini PostgreSQL JSONField da saqlashga harakat qilganimda bu muammoga duch keldim.

Biroz kurashgandan so'ng, umumiy yechim.

Mening yechimimning kaliti Python-ning manba kodidan o'tish va kod hujjatlari (ta'riflangan bu yerda) boshqa ma'lumotlar turlarini qo'llab-quvvatlash uchun mavjud json.dumps ni qanday kengaytirishni allaqachon tushuntirib beradi.

Aytaylik, sizda JSON uchun ketma-ketlashtirib bo'lmaydigan ba'zi maydonlarni o'z ichiga olgan model mavjud va JSON maydonini o'z ichiga olgan model dastlab shunday ko'rinadi:

class SomeClass(Model):
    json_field = JSONField()

Shunchaki maxsus JSONEncoder belgilang:

class CustomJsonEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, SomeTypeUnsupportedByJsonDumps):
            return < whatever value you want >
        return json.JSONEncoder.default(self, obj)

    @staticmethod
    def json_dumper(obj):
        return json.dumps(obj, cls=CustomJsonEncoder)

Va keyin uni quyidagi kabi JSONField da foydalaning:

class SomeClass(Model):
    json_field = JSONField(dumps=CustomJsonEncoder.json_dumper)

Kalit yuqoridagi default(self, obj) usulidir. Python’dan kelgan har bir ... is not JSON serializable shikoyat uchun seriyali bo‘lmagan JSON turiga (masalan, Enum yoki datetime) ishlov berish uchun kod qo‘shing.

Misol uchun, men Enum dan meros bo'lgan sinfni qanday qo'llab-quvvatlayman:

class TransactionType(Enum):
   CURRENT = 1
   STACKED = 2

   def default(self, obj):
       if isinstance(obj, TransactionType):
           return obj.value
       return json.JSONEncoder.default(self, obj)

Nihoyat, yuqoridagi kabi amalga oshirilgan kod bilan siz har qanday Peewee modellarini quyidagi kabi JSON-seriyali ob'ektga aylantirishingiz mumkin:

peewee_model = WhateverPeeweeModel()
new_model = SomeClass()
new_model.json_field = model_to_dict(peewee_model)

Yuqoridagi kod (bir oz) Peewee-ga xos bo'lsa-da, lekin menimcha:

1. Bu umuman boshqa ORM (Django va boshqalar) uchun amal qiladi
2. Bundan tashqari, agar siz json.dumps qanday ishlashini tushunsangiz, bu yechim umuman Python (sans ORM) bilan ham ishlaydi.

Har qanday savol, iltimos, sharhlar bo'limiga yozing. Rahmat!

Avval biz ob'ektimizni JSONga moslashimiz kerak, shuning uchun uni standart JSON moduli yordamida o'chirib tashlashimiz mumkin. Men buni shunday qildim:

def serialize(o):
    if isinstance(o, dict):
        return {k:serialize(v) for k,v in o.items()}
    if isinstance(o, list):
        return [serialize(e) for e in o]
    if isinstance(o, bytes):
        return o.decode("utf-8")
    return o

Bu funktsiya lug'atning har bir qismini takrorlash uchun rekursiyadan foydalanadi va keyin o'rnatilgan turdagi bo'lmagan sinflarning repr() usullarini chaqiradi.

def sterilize(obj):
    object_type = type(obj)
    if isinstance(obj, dict):
        return {k: sterilize(v) for k, v in obj.items()}
    elif object_type in (list, tuple):
        return [sterilize(v) for v in obj]
    elif object_type in (str, int, bool, float):
        return obj
    else:
        return obj.__repr__()

Men o'zimning yechimim bilan keldim. Ushbu usuldan foydalaning, ketma-ketlashtirish uchun istalgan hujjatni (dict,list, ObjectId va hokazo) o'tkazing.

def getSerializable(doc):
    # check if it's a list
    if isinstance(doc, list):
        for i, val in enumerate(doc):
            doc[i] = getSerializable(doc[i])
        return doc

    # check if it's a dict
    if isinstance(doc, dict):
        for key in doc.keys():
            doc[key] = getSerializable(doc[key])
        return doc

    # Process ObjectId
    if isinstance(doc, ObjectId):
        doc = str(doc)
        return doc

    # Use any other custom serializting stuff here...

    # For the rest of stuff
    return doc

Agar siz paketni o'rnatish imkoniga ega bo'lsangiz, dereotuni sinab ko'rishni tavsiya qilaman, bu juda yaxshi ishladi. mening loyiham. Ushbu paketning yoqimli tomoni shundaki, u pickle bilan bir xil interfeysga ega, shuning uchun agar siz allaqachon loyihangizda pickle dan foydalanayotgan bo'lsangiz, shunchaki dill ni almashtirib, hech qanday kodni o'zgartirmasdan skript ishlayotganligini ko'rishingiz mumkin. Shunday qilib, sinash uchun juda arzon echim!

(To'liq oshkor etilishiga qarshi: men hech qanday tarzda arpabodiyon loyihasiga aloqador emasman va hech qachon hissa qo'shganim yo'q.)

Paketni o'rnating:

pip install dill

Keyin pickle oʻrniga dill import qilish uchun kodingizni tahrirlang:

# import pickle
import dill as pickle

Skriptingizni ishga tushiring va u ishlayotganligini tekshiring. (Agar shunday bo'lsa, pickle modul nomini soya qilmaslik uchun kodingizni tozalashni xohlashingiz mumkin!)

loyiha sahifasidan dill seriyalashtira oladigan va seriyalashtira olmaydigan ma'lumotlar turlariga oid ba'zi xususiyatlar:

dill quyidagi standart turlarni tuzlashi mumkin:

none, type, bool, int, long, float, kompleks, str, unicode, kortej, roʻyxat, dict, fayl, bufer, oʻrnatilgan, eski va yangi uslub sinflari, eski va yangi uslublar sinflari, toʻsiq, frozenset, massiv , funksiyalar, istisnolar

dill ko'proq "ekzotik" standart turlarni ham tanlashi mumkin:

unumli funksiyalar, ichki funksiyalar, lambdalar, katakchalar, usul, unboundmethod, modul, code, methodwrapper, dictproxy, methoddescriptor, getsetdescriptor, memberdescriptor, wrapperdescriptor, xrange, slice, notimplemented, ellipsis, quit

dill hali bu standart turlarni tanlay olmaydi:

ramka, generator, orqaga qaytish

Men bu erda ketma-ket versiya yoki orqa kompat haqida hech qanday eslatma ko'rmayapman, shuning uchun men birozdan beri foydalanayotgan yechimimni e'lon qilaman. Ehtimol, menda ko'p narsalarni o'rganishim mumkin, xususan, Java va Javascript bu erda mendan ko'ra etukroqdir, lekin bu erda

https://gist.github.com/andy-d/b7878d0044a4280d

Boshqa variantni qo'shish uchun: attrs paketi va asdict usulidan foydalanishingiz mumkin.

class ObjectEncoder(JSONEncoder):
    def default(self, o):
        return attr.asdict(o)

json.dumps(objects, cls=ObjectEncoder)

va orqaga aylantirish uchun

def from_json(o):
    if '_obj_name' in o:
        type_ = o['_obj_name']
        del o['_obj_name']
        return globals()[type_](**o)
    else:
        return o

data = JSONDecoder(object_hook=from_json).decode(data)

sinf shunday ko'rinadi

@attr.s
class Foo(object):
    x = attr.ib()
    _obj_name = attr.ib(init=False, default='Foo')

Onurning javobiga qo'shimcha ravishda, siz quyida bo'lgani kabi datetime turi bilan shug'ullanishni xohlashingiz mumkin.
(ishlash uchun). : 'datetime.datetime' ob'ektida "dict" atributi istisnolari yo'q.)

def datetime_option(value):
    if isinstance(value, datetime.date):
        return value.timestamp()
    else:
        return value.__dict__

Foydalanish:

def toJSON(self):
    return json.dumps(self, default=datetime_option, sort_keys=True, indent=4)

Bu kichik kutubxona bo'lib, u ob'ektni barcha bolalari bilan JSONga seriyalashtiradi va uni qayta tahlil qiladi:

https://github.com/tobiasholler/PyJSONSerialization/

Ushbu muammoga ko'plab yondashuvlar mavjud. "ObjDict" (pip o'rnatish objdict) boshqa. JSON-dan yuklangan ma'lumotlarni eng yaxshi tarzda qayta ishlash uchun lug'atlar kabi ishlashi mumkin bo'lgan ob'ektlar kabi JavaScript-ni taqdim etishga e'tibor qaratilgan, ammo foydali bo'lishi mumkin bo'lgan boshqa xususiyatlar ham mavjud. Bu asl muammoning boshqa muqobil yechimini taqdim etadi.

Datetime ob'ektini ketma-ketlashtirish muammosini hal qilish uchun dekoratorlardan foydalanishni tanladim. Mana mening kodim:

#myjson.py
#Author: jmooremcc 7/16/2017

import json
from datetime import datetime, date, time, timedelta
"""
This module uses decorators to serialize date objects using json
The filename is myjson.py
In another module you simply add the following import statement:
    from myjson import json

json.dumps and json.dump will then correctly serialize datetime and date 
objects
"""

def json_serial(obj):
    """JSON serializer for objects not serializable by default json code"""

    if isinstance(obj, (datetime, date)):
        serial = str(obj)
        return serial
    raise TypeError ("Type %s not serializable" % type(obj))


def FixDumps(fn):
    def hook(obj):
        return fn(obj, default=json_serial)

    return hook

def FixDump(fn):
    def hook(obj, fp):
        return fn(obj,fp, default=json_serial)

    return hook


json.dumps=FixDumps(json.dumps)
json.dump=FixDump(json.dump)


if __name__=="__main__":
    today=datetime.now()
    data={'atime':today, 'greet':'Hello'}
    str=json.dumps(data)
    print str

Yuqoridagi modulni import qilish orqali, mening boshqa modullarim json-dan an'anaviy tarzda (standart kalit so'zni ko'rsatmasdan) sana-vaqt ob'ektlarini o'z ichiga olgan ma'lumotlarni ketma-ketlashtirish uchun foydalanadi. Datetime serializer kodi avtomatik ravishda json.dumps va json.dump uchun chaqiriladi.