使用常规编码器使对象JSON可序列化

Question

JSON序列化自定义不可序列化对象的常规方法是子类化json. JSONEncoder，然后将自定义编码器传递给json.dumps（）。

通常是这样的：

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

我想做的是，用默认编码器使某些东西可以序列化。我环顾四周，但什么也没找到。我的想法是，编码器会在某个字段中查看以确定json编码。类似于\uu str\uuuu的内容。可能是一个\uuujson\uuu字段。python中是否有类似的内容？

我想让我正在制作的模块的一个类对所有使用该包的人都可以进行JSON序列化，而不用担心实现自己的（琐碎的）自定义编码器。

Answer 1

我建议将hack放入类定义中。这样，一旦定义了类，它就支持JSON。示例：

import json

class MyClass( object ):

    def _jsonSupport( *args ):
        def default( self, xObject ):
            return { 'type': 'MyClass', 'name': xObject.name() }

        def objectHook( obj ):
            if 'type' not in obj:
                return obj
            if obj[ 'type' ] != 'MyClass':
                return obj
            return MyClass( obj[ 'name' ] )
        json.JSONEncoder.default = default
        json._default_decoder = json.JSONDecoder( object_hook = objectHook )

    _jsonSupport()

    def __init__( self, name ):
        self._name = name

    def name( self ):
        return self._name

    def __repr__( self ):
        return '<MyClass(name=%s)>' % self._name

myObject = MyClass( 'Magneto' )
jsonString = json.dumps( [ myObject, 'some', { 'other': 'objects' } ] )
print "json representation:", jsonString

decoded = json.loads( jsonString )
print "after decoding, our object is the first in the list", decoded[ 0 ]

Answer 2

匿名用户

您可以这样扩展dict类：

#!/usr/local/bin/python3
import json

class Serializable(dict):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # hack to fix _json.so make_encoder serialize properly
        self.__setitem__('dummy', 1)

    def _myattrs(self):
        return [
            (x, self._repr(getattr(self, x))) 
            for x in self.__dir__() 
            if x not in Serializable().__dir__()
        ]

    def _repr(self, value):
        if isinstance(value, (str, int, float, list, tuple, dict)):
            return value
        else:
            return repr(value)

    def __repr__(self):
        return '<%s.%s object at %s>' % (
            self.__class__.__module__,
            self.__class__.__name__,
            hex(id(self))
        )

    def keys(self):
        return iter([x[0] for x in self._myattrs()])

    def values(self):
        return iter([x[1] for x in self._myattrs()])

    def items(self):
        return iter(self._myattrs())

现在要使您的类可使用常规编码器序列化，请扩展“Serializable”：

class MySerializableClass(Serializable):

    attr_1 = 'first attribute'
    attr_2 = 23

    def my_function(self):
        print('do something here')


obj = MySerializableClass()

打印（obj）将打印如下内容：

<__main__.MySerializableClass object at 0x1073525e8>

打印（json.dumps（obj，indent=4））将打印如下内容：

{
    "attr_1": "first attribute",
    "attr_2": 23,
    "my_function": "<bound method MySerializableClass.my_function of <__main__.MySerializableClass object at 0x1073525e8>>"
}

Answer 3

正如我在对您的问题的评论中所说，在查看了json模块的源代码之后，它似乎不适合做您想要的事情。然而，这一目标可以通过所谓的猴子补丁来实现（参见问题什么是猴子补丁？）。这可以在程序包的\uu init\uuuuu中完成。py初始化脚本，并会影响所有后续的json模块序列化，因为模块通常只加载一次，结果缓存在sys中。模块 。

该补丁更改了默认json编码器的默认方法default（）。

为简单起见，这里有一个作为独立模块实现的示例：

模块：<代码>使\u json\u可序列化。py

""" Module that monkey-patches json module when it's imported so
JSONEncoder.default() automatically checks for a special "to_json()"
method and uses it to encode the object if found.
"""
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.

使用它很简单，因为补丁是通过简单地导入模块来应用的。

客户端脚本示例：

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

要保留对象类型信息，特殊方法还可以将其包含在返回的字符串中：

        return ('{"type": "%s", "name": "%s"}' %
                 (self.__class__.__name__, self.name))

它生成以下JSON，现在包含类名：

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

Magick躺在这里

比让替换的default（）寻找一个特别命名的方法更好的是，它能够自动序列化大多数Python对象，包括用户定义的类实例，而无需添加特殊的方法。在研究了许多替代方案后，以下内容——基于@Raymond Hettinger对另一个问题的回答——它使用了泡菜模块，对我来说似乎最接近理想：

模块：make\u json\u serializable2。py

""" Module that imports the json module and monkey-patches it so
JSONEncoder.default() automatically pickles any Python objects
encountered that aren't standard JSON data types.
"""
from json import JSONEncoder
import pickle

def _default(self, obj):
    return {'_python_object': pickle.dumps(obj)}

JSONEncoder.default = _default  # Replace with the above.

当然，所有东西都不能被腌制——例如扩展类型。然而，有一些方法可以通过编写特殊方法来定义通过泡菜协议来处理它们——类似于你和我之前描述的方法——但是对于数量少得多的情况来说，这样做可能是必要的。

反序列化

无论如何，使用pickle协议也意味着通过在任何json上提供自定义的object\u hook函数参数，可以相当容易地重构原始Python对象。loads（）调用，该调用使用传入词典中的任何'\u python\u对象键，只要它有一个键。类似于：

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)

如果必须在许多地方执行此操作，那么可以定义一个自动提供额外关键字参数的包装函数：

json_pkloads = functools.partial(json.loads, object_hook=as_python_object)

pyobj = json_pkloads(json_str)

当然，这也可以将其单调地修补到json模块中，使该函数成为默认的object_hook（而不是无）。

我从Raymond Hettinger对另一个JSON序列化问题的回答中得到了使用泡菜的想法，我认为他非常可信，也是官方来源（如Python核心开发人员）。

上面的代码没有如Python 3所示工作，因为json。dumps（）返回jsonecoder无法处理的字节对象。然而，这种方法仍然有效。解决此问题的一种简单方法是对pickle返回的值进行“解码”。转储（），然后从拉丁文1对其进行“编码”，然后将其传递到pickle。将（）加载到as\u python\u object（）函数中。这是因为任意二进制字符串都是有效的拉丁语，可以将其解码为Unicode，然后再次编码回原始字符串（正如Sven Marnach在回答中指出的那样）。

（虽然以下内容在Python 2中可以很好地工作，但它的拉丁语解码和编码是多余的。）

from decimal import Decimal

class PythonObjectEncoder(json.JSONEncoder):
    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


class Foo(object):  # Some user-defined class.
    def __init__(self, name):
        self.name = name

    def __eq__(self, other):
        if type(other) is type(self):  # Instances of same class?
            return self.name == other.name
        return NotImplemented

    __hash__ = None


data = [1,2,3, set(['knights', 'who', 'say', 'ni']), {'key':'value'},
        Foo('Bar'), Decimal('3.141592653589793238462643383279502884197169')]
j = json.dumps(data, cls=PythonObjectEncoder, indent=4)
data2 = json.loads(j, object_hook=as_python_object)
assert data == data2  # both should be same