如何在不子类化`json.JSONEncoder`的情况下使自定义对象JSON可序列化？

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

将自定义不可序列化对象序列化为 JSON 的默认方法是子类化 json.JSONEncoder 并将自定义编码器传递给json.dumps()。这通常如下所示：

<code class="python">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))</code>

但是，如果您想使用默认编码器使对象可序列化怎么办？查看 json 模块的源代码后，似乎直接扩展编码器无法满足此要求。

相反，您可以在包的 __init__.py 初始化脚本中使用一种称为“monkey-patching”的技术。这会影响所有后续的 JSON 模块序列化，因为模块通常只加载一次，结果缓存在 sys.modules 中。

该补丁将修改默认 JSON 编码器的默认方法以检查唯一的“to_json”方法并利用它对找到的对象进行编码。

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

<code class="python"># Module: make_json_serializable.py

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.</code>

使用此补丁很简单：只需导入模块即可应用猴子-patch.

<code class="python"># Sample client script

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"}'</code>

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

<code class="python">def to_json(self):
    """Convert to JSON format string representation."""
    return '{"type": "%s", "name": "%s"}' % (self.__class__.__name__, self.name)</code>

这会生成包含类名称的 JSON：

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

魔法就在这里

更强大的方法是让替换默认方法自动序列化大多数 Python 对象，包括用户定义的类实例，而不需要唯一的方法。

在研究了几种替代方案之后，以下基于 pickle 的方法似乎最接近这个理想：

<code class="python"># Module: make_json_serializable2.py

from json import JSONEncoder
import pickle

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

JSONEncoder.default = _default  # Replace with the above.</code>

虽然并非所有内容都可以进行 pickle（例如扩展类型），但 pickle 提供了通过协议处理它们的方法使用独特的方法。但是，这种方法涵盖了更多情况。

反序列化

使用 pickle 协议通过在遇到“_python_object”时向 json.loads() 提供自定义 object_hook 函数参数来简化重建原始 Python 对象字典中的 key。

<code class="python">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)</code>

这可以简化为包装函数：

<code class="python">json_pkloads = functools.partial(json.loads, object_hook=as_python_object)

pyobj = json_pkloads(json_str)</code>

此代码在 Python 3 中不起作用，因为 json.dumps() 返回一个 bytes 对象JSONEncoder 无法处理。但是，该方法经过以下修改后仍然有效：

<code class="python">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</code>

以上是如何在不子类化`json.JSONEncoder`的情况下使自定义对象JSON可序列化？的详细内容。更多信息请关注PHP中文网其他相关文章！