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模块的源代码之后，它似乎不适合做您想做的事情。然而，这个目标可以通过所谓的猴子补丁来实现
（参见问题什么是猴子补丁？）。这可以在您的包的__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 协议还意味着通过在使用传入字典中的任何键的任何调用object_hook上提供自定义函数参数（只要它有一个），就可以相当容易地重建原始 Python 对象。就像是：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)
自然地，这也可以被猴子修补到json模块中，使函数成为默认值object_hook（而不是None）。
我从Raymond Hettingerpickle对另一个 JSON 序列化问题的回答中得到了使用的想法，我认为这个问题非常可信并且是官方来源（如 Python 核心开发人员）。
上面的代码在 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
您可以像这样扩展 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。例子：
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 ]
覆盖的问题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使用您自己的自定义编码器准备相当自己的模块，以明确您覆盖了某些内容。不建议使用 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)
你要：
有效载荷 = 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事件。