Как сделать класс JSON сериализуемым

Как сделать класс Python сериализуемым?

Простой класс:

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

Что мне делать, чтобы получить вывод:

json.dumps()

Без ошибки (FileItem instance at ... is not JSON serializable)

542
задан Sergey 22 сент. '10 в 14:52
источник поделиться
22 ответов

Есть ли у вас представление о ожидаемом выходе? Напр. это будет?

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

В этом случае вы можете просто называть json.dumps(f.__dict__).

Если вам нужен более индивидуальный вывод, вам придется подклассы JSONEncoder и реализовать свою собственную сериализацию.

Для тривиального примера см. ниже.

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

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

Затем вы передаете этот класс в метод json.dumps() как cls kwarg:

json.dumps(cls=MyEncoder)

Если вы также хотите декодировать, вам нужно будет поставить пользовательский object_hook в класс JSONDecoder. Например,

>>> 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>
>>> 
408
ответ дан Manoj Govindan 22 сент. '10 в 15:02
источник поделиться

Вот простое решение для простой функции:

.toJSON() Метод

Вместо сериализуемого класса JSON реализуйте метод serializer:

import json

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

Итак, вы просто вызываете его для сериализации:

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

print(me.toJSON())

выведет:

{
    "age": 35,
    "dog": {
        "name": "Apollo"
    },
    "name": "Onur"
}
458
ответ дан Onur Yıldırım 21 марта '13 в 5:26
источник поделиться

Для более сложных классов вы можете рассмотреть инструмент jsonpickle:

jsonpickle - это библиотека Python для сериализации и десериализации сложных объектов Python в JSON и из него.

Стандартные библиотеки Python для кодирования Python в JSON, такие как stdlibs json, simplejson и demjson, могут обрабатывать только примитивы Python, которые имеют прямой эквивалент JSON (например, dicts, lists, string, ints и т.д.). jsonpickle строит поверх этих библиотек и позволяет сериализовать более сложные структуры данных в JSON. jsonpickle очень настраивается и расширяется, что позволяет пользователю выбирать бэкэнд JSON и добавлять дополнительные бэкэнды.

(jsonpickle на PyPi)

113
ответ дан gecco 23 дек. '11 в 12:11
источник поделиться

Большинство ответов связаны с изменением вызова на json.dumps(), что не всегда возможно или желательно (это может произойти, например, в компоненте framework).

Если вы хотите иметь возможность называть json.dumps(obj) как есть, то простое решение наследуется от dict:

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

Это работает, если ваш класс является просто базовым представлением данных, для более сложных вещей вы всегда можете явно устанавливать ключи.

47
ответ дан andyhasit 03 июля '15 в 16:22
источник поделиться

Другим вариантом является перенос JSON-демпинга в свой класс:

import json

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

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

Или, что еще лучше, подклассификация класса FileItem из класса JsonSerializable:

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

Тестирование:

>>> f = FileItem('/foo/bar')
>>> f.toJson()
'{"fname": "/foo/bar"}'
>>> f
'{"fname": "/foo/bar"}'
>>> str(f) # string coercion
'{"fname": "/foo/bar"}'
32
ответ дан Paulo Freitas 16 июня '12 в 13:30
источник поделиться

Мне нравится ответ Onur, но будет расширяться, чтобы включить необязательный метод toJSON() для объектов, которые сериализуются:

def dumper(obj):
    try:
        return obj.toJSON()
    except:
        return obj.__dict__
print json.dumps(some_big_object, default=dumper, indent=2)
27
ответ дан Jason S 27 янв. '15 в 19:04
источник поделиться

На днях я столкнулся с этой проблемой и реализовал более общую версию Encoder для объектов Python, которая может обрабатывать вложенные объекты и унаследованные поля:

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

Пример:

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)

Результат:

{
  "a": "A", 
  "b": [
    {
      "ab": {
        "b": "B", 
        "i": "I", 
        "y": "y"
      }
    }
  ], 
  "c": {
    "c": "YES"
  }, 
  "i": "I"
}
21
ответ дан tobigue 18 февр. '16 в 17:10
источник поделиться

Просто добавьте метод to_json в свой класс следующим образом:

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

И добавьте этот код (из этого ответа), где-то наверху всего:

from json import JSONEncoder

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

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

Это будет модуль monkey-patch json, когда он импортируется, поэтому JSONEncoder.default() автоматически проверяет специальный метод "to_json()" и использует его для кодирования объекта, если он найден.

Так же, как сказал Онур, но на этот раз вам не нужно обновлять каждый json.dumps() в вашем проекте.

16
ответ дан Fancy John 04 авг. '16 в 13:27
источник поделиться
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', 'alice@mail.com')))

если используется стандарт json, вам необходимо определить функцию default

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

print(json.dumps(User('alice', 'alice@mail.com'), default=default))
8
ответ дан tryer3000 17 июня '15 в 6:17
источник поделиться

json ограничен с точки зрения объектов, которые он может распечатать, а jsonpickle (возможно, вам нужен pip install jsonpickle) ограничен в терминах, что он не может отступать от текста. Если вы хотите проверить содержимое объекта, класс которого вы не можете изменить, я все еще не мог найти более строгий путь, чем:

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

Обратите внимание, что они все еще не могут печатать методы объекта.

5
ответ дан ribamar 04 апр. '16 в 16:41
источник поделиться

Этот класс может сделать трюк, он преобразует объект в стандартный json.

import json


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

использование:

Serializer.serialize(my_object)

работает в python2.7 и python3.

4
ответ дан Lost Koder 09 окт. '16 в 17:14
источник поделиться
import json

class Foo(object):
    def __init__(self):
        self.bar = 'baz'
        self._qux = 'flub'

    def somemethod(self):
        pass

def default(instance):
    return {k: v
            for k, v in vars(instance).items()
            if not str(k).startswith('_')}

json_foo = json.dumps(Foo(), default=default)
assert '{"bar": "baz"}' == json_foo

print(json_foo)
3
ответ дан rectangletangle 17 июля '15 в 9:20
источник поделиться

Джарако дал довольно аккуратный ответ. Мне нужно было исправить некоторые незначительные вещи, но это работает:

Код

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

Обратите внимание, что для загрузки требуется два шага. На данный __python__ свойство __python__ не используется.

Насколько распространено это?

Используя метод AlJohri, я проверяю популярность подходов:

Сериализация (Python → JSON):

Deserialization (JSON → Python):

2
ответ дан Martin Thoma 27 июня '18 в 8:24
источник поделиться

jsonweb кажется лучшим решением для меня. См. http://www.jsonweb.info/en/latest/

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"}'
2
ответ дан matthewlent 07 окт. '14 в 8:32
источник поделиться

Если вы не против установки пакета для него, вы можете использовать json-tricks:

pip install json-tricks

После этого вам просто нужно импортировать dump(s) из json_tricks вместо json, и он обычно работает:

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

который даст

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

И это в основном это!


Это будет отлично работать в целом. Существуют некоторые исключения, например. если в __new__ происходят особые вещи, или происходит большее количество метаклассической магии.

Очевидно, что загрузка также работает (в противном случае, что точка):

from json_tricks import loads
json_str = loads(json_str)

Это предполагает, что module_name.test_class.MyTestCls можно импортировать и не изменять несовместимыми способами. Вы вернете экземпляр, а не какой-либо словарь или что-то еще, и он должен быть идентичной копией того, который вы сбросили.

Если вы хотите настроить, как что-то получает (де) сериализован, вы можете добавить специальные методы в свой класс, например:

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

который в качестве примера выполняет сериализацию только части параметров атрибутов.

И в качестве бесплатного бонуса вы получаете (де) сериализацию массивов numpy, дату и время, упорядоченные карты, а также возможность включать комментарии в json.

Отказ от ответственности: я создал json_tricks, потому что у меня была такая же проблема, как и вы.

1
ответ дан Mark 10 нояб. '16 в 15:53
источник поделиться

Я столкнулся с этой проблемой, когда попытался сохранить модель Peewee в PostgreSQL JSONField.

Потерпев некоторое время, вот общее решение.

Ключ к моему решению проходит через исходный код Python и понимает, что документация по коду (описанная здесь) уже объясняет, как расширить существующие json.dumps для поддержки других типов данных.

Предположим, что у вас в настоящее время есть модель, которая содержит некоторые поля, которые не могут быть сериализованы для JSON, и модель, которая содержит поле JSON, первоначально выглядит следующим образом:

class SomeClass(Model):
    json_field = JSONField()

Просто определите пользовательский JSONEncoder следующим образом:

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)

А затем просто используйте его в своем JSONField как JSONField ниже:

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

Ключ - это метод по default(self, obj) выше. Для каждого ... is not JSON serializable жалоба, которую вы получаете от Python, просто добавьте код для обработки типа unserializable-to-JSON (например, Enum или datetime)

Например, здесь, как я поддерживаю класс, наследующий от Enum:

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

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

Наконец, с реализованным кодом, как и выше, вы можете просто преобразовать любые модели Peewee в объект JSON-seriazable, как показано ниже:

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

Хотя приведенный выше код был (несколько) специфичен для Peewee, но я думаю:

  1. Он применим к другим ORM (Django и т.д.) В целом
  2. Кроме того, если вы понимаете, как работает json.dumps, это решение также работает с Python (без ORM) вообще

Любые вопросы, пожалуйста, напишите в разделе комментариев. Благодарю!

1
ответ дан sivabudh 30 июля '18 в 18:04
источник поделиться

Вот мои 3 цента...
Это демонстрирует явную сериализацию json для древовидного объекта python.
Примечание. Если вам действительно нужен такой код, вы можете использовать скрученный FilePath.

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)
1
ответ дан Dan Brough 10 июля '13 в 20:59
источник поделиться

Я придумал свое решение. Используйте этот метод, передайте любой документ (dict, list, ObjectId и т.д.) Для сериализации.

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

    # check if it 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
0
ответ дан Dewsworld 21 мая '15 в 8:06
источник поделиться

Мне понравился метод Lost Koder. Я столкнулся с проблемами при попытке сериализации более сложных объектов, чьи члены/методы не сериализуемы. Здесь моя реализация, которая работает с большим количеством объектов:

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)
0
ответ дан Will Charlton 11 нояб. '17 в 8:35
источник поделиться

Я решил использовать декораторы для решения проблемы сериализации объекта datetime. Вот мой код:

#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

Импортируя вышеуказанный модуль, мои другие модули используют json обычным способом (без указания ключевого слова по умолчанию) для сериализации данных, содержащих объекты времени даты. Кодировщик даты и времени автоматически вызывается для json.dumps и json.dump.

0
ответ дан John Moore 16 июля '17 в 20:28
источник поделиться

Это небольшая библиотека, которая сериализует объект со всеми его дочерними элементами в JSON, а также анализирует его обратно:

https://github.com/Toubs/PyJSONSerialization/

0
ответ дан Tobi 17 июля '14 в 12:44
источник поделиться

Существует много подходов к этой проблеме. "ObjDict" (pip install objdict) - это другое. Существует акцент на предоставлении javascript-подобных объектов, которые также могут действовать как словари, чтобы лучше обрабатывать данные, загруженные из JSON, но есть и другие функции, которые могут быть полезны. Это дает другое альтернативное решение исходной проблемы.

-1
ответ дан innov8 02 окт. '16 в 7:29
источник поделиться

Другие вопросы по меткам или Задайте вопрос