将自定义的不可序列化对象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模块的源代码，并不适用于您想要做的事情。然而，通过所谓的monkey-patching可以实现目标（请参见问题什么是monkey patch？）。这可以在您包的__init__.py初始化脚本中完成，并将影响所有后续的json模块序列化，因为模块通常只被加载一次，结果会缓存到sys.modules中。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.
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）。pickle的想法，我认为他非常可信，也是官方来源（即Python核心开发人员）。json.dumps()返回一个bytes对象，而JSONEncoder无法处理。但是这种方法仍然有效。解决此问题的简单方法是对从pickle.dumps()返回的值进行latin1“解码”，然后从latin1“编码”再传递给pickle.loads()在as_python_object()函数中。这是有效的，因为任意二进制字符串都是有效的latin1，可以始终将其解码为Unicode，然后再次编码为原始字符串（如this answer和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
to_json() 方法返回的字符串是有效的 JSON 格式，它就可以被标准的 JSON 解析器加载，不管该补丁是否已导入。- @Juh_ - martineauJSONEncoder进行子类化以快速执行此操作：https://dev59.com/_WEh5IYBdhLWcg3w7XLt？ - BasjJSONEncoder来漂亮地打印JSON转储的方式并不可行，就像你问题中展示的那样。 - martineau您可以这样扩展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 ...，我记得在库代码中查看了 json.dumps 的实现。如果我没记错的话，它使用了本地实现 _json.so。如果无法使用，则会回退到 Python 实现（可能较慢）。 _json.so 如果底层 dict 中没有值，则不会序列化该类。因此，当我添加虚拟值时，它会调用 items() 或类似的方法。 - Aravindan Ve__repr__（或完全删除它），或者在序列化时检查嵌套值是否为 dict。就像我说的那样，我有点生疏，需要再看一下 json.dumps() 的工作方式。 - Aravindan Veimport 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 ]
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)
我不明白为什么你不能为自己的类编写一个serialize函数？你在类内部实现自定义编码器，并允许“人们”调用序列化函数，该函数将基本上返回剥离了函数的self.__dict__。
编辑：
这个问题支持我的观点，最简单的方法是编写自己的方法并返回所需的json序列化数据。他们还建议尝试jsonpickle，但现在你正在添加一个额外的依赖项来美化，而正确的解决方案已经内置了。
json.dumps() 方法（或 json.JSONEncoder）更聪明一些，它们中的一个自动查找特殊的对象方法，那么就不需要传递一个特殊的编码器了——这是不总是可能的。这就是 print 语句/函数的工作方式。它查找 __str__() 对象方法并在找到时使用它。这使得打印类的实例变得非常容易，即使它们在像 list 或 dict 这样的东西中。 - martineau对于生产环境，最好准备自己的json模块和自定义编码器，以明确你覆盖了什么内容。
不建议使用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)
你想要：
payload = json.dumps(your_data, cls=JSONDatetimeAndPhonesEncoder)
或者：
payload = your_dumps(your_data)
或者：
payload = your_json.dumps(your_data)
然而在测试环境中，可以继续前进：
@pytest.fixture(scope='session', autouse=True)
def testenv_monkey_patching():
json._default_encoder = JSONDatetimeAndPhonesEncoder()
这将会对所有的json.dumps出现进行编码器应用。
json.JSONEncoder工作。 - Sławomir Lenart
json模块的encoder.py文件中没有看到类似的内容。 - martineau__json__的东西还没有得到支持的人，可以参考以下讨论：cpython issue #79292，cpython issue #71549。 - undefined