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

问题描述：

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 编码。类似于的东西__str__。也许是一个__json__字段。python 中有类似的东西吗？

我想让我正在制作的模块的一个类对使用该包的每个人都可进行 JSON 序列化，而无需他们担心实现他们自己的[简单]自定义编码器。

解决方案 1：

正如我在对你的问题的评论中所说，在查看了json模块的源代码后，它似乎无法完成你想要的功能。但是，可以通过所谓的monkey-patching来实现目标
（请参阅问题什么是 monkey patch？）。这可以在包的__init__.py初始化脚本中完成，并且会影响所有后续json模块序列化，因为模块通常只加载一次，结果缓存在 中sys.modules。

该补丁改变了默认的 json 编码器的default方法——默认的default()。

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

模块：make_json_serializable.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\"}"

魔法就在这里

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

模块：make_json_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 — 例如扩展类型。但是，有一些方法可以通过 pickle 协议处理它们，即通过编写特殊方法 — 类似于您建议的和我之前描述的 — 但这样做可能在极少数情况下是必要的。

反序列化

无论如何，使用 pickle 协议还意味着，只要字典中有键，只要调用时使用传入的字典中的任何键，就可以相当轻松地重建原始 Python 对象，方法是提供自定义object_hook函数参数。例如：json.loads()`'_python_object'`

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)

当然，这也可以通过 monkey-patched 的方式将其放入json模块中，使该函数成为默认函数object_hook（而不是None）。

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

可移植到 Python 3

上面的代码在 Python 3 中不起作用，因为它json.dumps()返回了一个无法处理bytes的对象JSONEncoder。但是该方法仍然有效。解决该问题的一种简单方法是latin1“解码”返回的值pickle.dumps()，然后“编码”它，latin1然后再将其传递给pickle.loads()函数as_python_object()。这种方法之所以有效，是因为任意二进制字符串都是有效的latin1，它们总是可以解码为 Unicode，然后再编码回原始字符串（正如Sven Marnach在这个答案中指出的那样）。

（尽管下面的代码在 Python 2 中可以正常运行，但是latin1它所做的解码和编码是多余的。）

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

解决方案 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()

print(obj)将会打印类似这样的内容：

<__main__.MySerializableClass object at 0x1073525e8>

print(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>>"
}

解决方案 3：

我建议将 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 ]

解决方案 4：

覆盖的问题JSONEncoder().default在于您只能执行一次。如果您偶然发现任何不适用于该模式的特殊数据类型（例如，如果您使用奇怪的编码）。使用下面的模式，您始终可以使您的类 JSON 可序列化，前提是您要序列化的类字段本身是可序列化的（并且可以添加到 python 列表中，几乎什么都不能）。否则，您必须将相同的模式递归应用于您的 json 字段（或从中提取可序列化的数据）：

# base class that will make all derivatives JSON serializable:
class JSONSerializable(list): # need to derive from a serializable class.

  def __init__(self, value = None):
    self = [ value ]

  def setJSONSerializableValue(self, value):
    self = [ value ]

  def getJSONSerializableValue(self):
    return self[1] if len(self) else None


# derive  your classes from JSONSerializable:
class MyJSONSerializableObject(JSONSerializable):

  def __init__(self): # or any other function
    # .... 
    # suppose your__json__field is the class member to be serialized. 
    # it has to be serializable itself. 
    # Every time you want to set it, call this function:
    self.setJSONSerializableValue(your__json__field)
    # ... 
    # ... and when you need access to it,  get this way:
    do_something_with_your__json__field(self.getJSONSerializableValue())


# now you have a JSON default-serializable class:
a = MyJSONSerializableObject()
print json.dumps(a)

解决方案 5：

我不明白为什么你不能serialize为自己的类编写一个函数？你在类本身内部实现自定义编码器，并允许“人们”调用序列化函数，该函数实际上将返回self.__dict__被剥离的函数。

编辑：

这个问题同意我的观点，最简单的方法是编写自己的方法并返回所需的 json 序列化数据。他们还建议尝试 jsonpickle，但现在当正确的解决方案内置时，您需要添加额外的依赖项才能获得美观。

解决方案 6：

对于生产环境，最好使用您自己的自定义编码器来准备自己的模块json，以明确您覆盖了某些内容。不建议使用 Monkey-patch，但您可以在 testenv 中执行 monkey patch。

例如，

class JSONDatetimeAndPhonesEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, (datetime.date, datetime.datetime)):
            return obj.date().isoformat()
        elif isinstance(obj, basestring):
            try:
                number = phonenumbers.parse(obj)
            except phonenumbers.NumberParseException:
                return json.JSONEncoder.default(self, obj)
            else:
                return phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.NATIONAL)
        else:
            return json.JSONEncoder.default(self, obj)

你想要：

有效载荷= json.dumps（你的数据，cls = JSONDatetimeAndPhonesEncoder）

或者：

有效载荷=你的转储（你的数据）

或者：

有效载荷=your_json.dumps（你的数据）

但是在测试环境中，请继续：

@pytest.fixture(scope='session', autouse=True)
def testenv_monkey_patching():
    json._default_encoder = JSONDatetimeAndPhonesEncoder()

这会将您的编码器应用于所有json.dumps事件。