使用常规编码器使对象 JSON 可序列化
Posted
技术标签:
【中文标题】使用常规编码器使对象 JSON 可序列化【英文标题】：Making object JSON serializable with regular encoder 【发布时间】：2013-08-30 23:01:12 【问题描述】：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 可序列化给使用该包的每个人，而不用担心实现他们自己的 [琐碎] 自定义编码器。
【问题讨论】：
我在json 模块的encoder.py 文件的源代码中没有看到类似的内容。
【参考方案1】：
正如我在对您的问题的评论中所说，在查看 json 模块的源代码后，它似乎不适合做您想做的事情。然而，这个目标可以通过所谓的monkey-patching 来实现
（见问题What is a 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 对另一个问题的answer——使用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 协议还意味着通过在任何使用传入字典中的任何 '_python_object' 键的 json.loads() 调用上提供自定义 object_hook 函数参数来重建原始 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)
如果这必须在很多地方完成，那么定义一个自动提供额外关键字参数的包装函数可能是值得的：
json_pkloads = functools.partial(json.loads, object_hook=as_python_object)
pyobj = json_pkloads(json_str)
当然，这也可以被猴子修补到json 模块中，使该函数成为默认的object_hook（而不是None）。
我从Raymond Hettinger 的answer 到另一个JSON 序列化问题中得到了使用pickle 的想法，我认为这个问题非常可信并且是官方来源（如在Python 核心开发人员中）。
对 Python 3 的可移植性
上面的代码在 Python 3 中不起作用，因为 json.dumps() 返回一个 bytes 对象，JSONEncoder 无法处理该对象。但是，该方法仍然有效。解决此问题的一种简单方法是latin1“解码”从pickle.dumps() 返回的值，然后从latin1“编码”它，然后在as_python_object() 函数中将其传递给pickle.loads()。这是有效的，因为任意二进制字符串都是有效的latin1，它总是可以解码为 Unicode，然后再次编码回原始字符串（正如Sven Marnach 在this answer 中指出的那样）。
（虽然以下在 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
【讨论】：
这显然是一个很好的（？）解决方案。但它引入了一个（不可避免的）限制：应该导入这个补丁来加载这样的序列化数据。那么要遵循什么规则才能使返回的内容仍然可以通过标准 json 加载（不完全清楚，但不会失败）？ @Juh_：只要to_json()方法返回的字符串是合法的JSON，就可以被标准的json解析器加载，不管补丁本身是否被导入。
感谢@martineau 提供此代码。顺便说一句，你认为有可能将JSONEncoder 子类化以很快做到这一点：***.com/questions/21866774/pretty-print-json-dumps 吗？
@Basj：不，我认为将JSONEncoder 子类化为您问题中显示的漂亮打印 JSON 转储是不可行的。
感谢您的精彩回答。【参考方案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>>"
【讨论】：
# hack to fix _json.so make_encoder serialize properly repr() 值而不是其字典
@inetknght 抱歉，刚刚看到这个。我很久以前写过这篇文章，而且我已经很久没有使用 python 了。至于# hack ...，我记得看过库代码中的json.dumps 实现。如果我没记错的话，它使用的是原生实现_json.so。如果不能使用，它将回退到 python 实现（可能更慢）。如果基础dict 中没有值，_json.so 将不会序列化该类。因此，当我添加虚拟值时，它会调用 items() 或任何类似的名称。
关于您的第二个问题，您可能需要使用__repr__（或完全删除它）或检查嵌套值是否为dict 序列化。就像我说的，我有点生疏了，我需要看看json.dumps() 是如何工作的【参考方案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 ]
【讨论】：
这种方法的一个显着限制是，正如目前所写的那样，它不能很好地与其他人一起使用，因为一次使用这种方法无法让多个类因为否则他们会踩到对方的 JSON 支持代码。即使它确实在这种情况下工作，也需要复制类似的支持代码并将其放置在每个类中。不过，这两个问题都有可能解决。【参考方案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__ 并去除函数。
编辑：
This question 同意我的观点，最简单的方法是编写自己的方法并返回您想要的 json 序列化数据。他们还建议尝试使用 jsonpickle，但现在当内置正确的解决方案时，您将添加额外的美感依赖项。
【讨论】：
我怀疑原因是因为如果股票json.dumps() 方法（或json.JSONEncoder）更聪明，其中一个会自动寻找一个特殊的对象方法，那么就没有必要通过它了一个特殊的编码器——这并不总是可能的。这就是print 语句/函数的工作方式。它查找__str__() 对象方法，如果找到就使用它。这使得打印类的实例变得非常容易，即使它们位于 list 或 dict 之类的其他东西中。
@martineau 他可能必须为标准库中的 json 模块提交更改才能按照他想要的方式进行操作。查看 json 的源代码，它只是不存在。【参考方案6】：
对于生产环境，使用您自己的自定义编码器准备相当自己的json 模块，以明确您覆盖了某些内容。
不建议使用 Monkey-patch，但您可以在 testenv 中进行猴子补丁。
例如，
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)
你想要的：
payload = json.dumps(your_data, cls=JSONDatetimeAndPhonesEncoder)
或：
有效负载 = your_dumps(your_data)
或：
有效负载 = your_json.dumps(your_data)
不过在测试环境中，先试试吧：
@pytest.fixture(scope='session', autouse=True)
def testenv_monkey_patching():
json._default_encoder = JSONDatetimeAndPhonesEncoder()
这会将您的编码器应用于所有出现的json.dumps。
【讨论】：
不幸的是，这种方法不适用于某些标准类，如 str、dict、tuple 等。从文档中不容易理解：json.JSONEncoder [skip] Supports the following objects and types by default. [skip] To extend this to recognize **other** objects, subclass and implement a default() method。多么令人失望..
@NikO'Lai：例如，我添加了 2 种类型的自定义识别。任何其他类型都将以默认方式和默认编码器工作，即json.JSONEncoder以上是关于使用常规编码器使对象 JSON 可序列化的主要内容，如果未能解决你的问题，请参考以下文章