python - 有没有办法覆盖 python 的 json 处理程序？

Question

我在 json 中编码无穷大时遇到问题。

json.dumps会将其转换为"Infinity"，但我希望它确实将其转换为null或我选择的其他值。

不幸的是，设置default参数似乎仅在转储尚未理解对象时才有效，否则默认处理程序似乎被绕过。

有没有办法可以预编码对象，更改类型/类的默认编码方式，或者在正常编码之前将某个类型/类转换为不同的对象？

Answer 1

看这里的源代码：http: //hg.python.org/cpython/file/7ec9255d4189/Lib/json/encoder.py

如果您继承 JSONEncoder，您可以只覆盖该iterencode(self, o, _one_shot=False)方法，该方法具有 Infinity 的显式特殊大小写（在内部函数内部）。

为了使其可重用，您还需要更改__init__以采用一些新选项，并将它们存储在类中。

或者，您可以从 pypi 中选择一个具有您正在寻找的适当可扩展性的 json 库：https ://pypi.python.org/pypi?%3Aaction=search&term=json&submit=search

这是一个例子：

import json

class FloatEncoder(json.JSONEncoder):

    def __init__(self, nan_str = "null", **kwargs):
        super(FloatEncoder,self).__init__(**kwargs)
    self.nan_str = nan_str

    # uses code from official python json.encoder module.
    # Same licence applies.
    def iterencode(self, o, _one_shot=False):
        """Encode the given object and yield each string
        representation as available.

        For example::

            for chunk in JSONEncoder().iterencode(bigobject):
                mysocket.write(chunk)
        """
        if self.check_circular:
            markers = {}
        else:
            markers = None
        if self.ensure_ascii:
            _encoder = json.encoder.encode_basestring_ascii
        else:
            _encoder = json.encoder.encode_basestring
        if self.encoding != 'utf-8':
            def _encoder(o, _orig_encoder=_encoder,
                         _encoding=self.encoding):
                if isinstance(o, str):
                    o = o.decode(_encoding)
                return _orig_encoder(o)

        def floatstr(o, allow_nan=self.allow_nan,
                     _repr=json.encoder.FLOAT_REPR,
                     _inf=json.encoder.INFINITY,
                     _neginf=-json.encoder.INFINITY,
                     nan_str = self.nan_str):
            # Check for specials. Note that this type of test is 
            # processor and/or platform-specific, so do tests which
            # don't depend on the internals.

            if o != o:
                text = nan_str
            elif o == _inf:
                text = 'Infinity'
            elif o == _neginf:
                text = '-Infinity'
            else:
                return _repr(o)

            if not allow_nan:
                raise ValueError(
                    "Out of range float values are not JSON compliant: " +
                    repr(o))

            return text

        _iterencode = json.encoder._make_iterencode(
                markers, self.default, _encoder, self.indent, floatstr,
                self.key_separator, self.item_separator, self.sort_keys,
                self.skipkeys, _one_shot)
        return _iterencode(o, 0)


example_obj = {
    'name': 'example',
    'body': [
        1.1,
        {"3.3": 5, "1.1": float('Nan')},
        [float('inf'), 2.2]
    ]}

print json.dumps(example_obj, cls=FloatEncoder)

ideone：http: //ideone.com/dFWaNj

Answer 2

No, there is no simple way to achieve this. In fact, NaN and Infinity floating point values shouldn't be serialized with json at all, according to the standard. Python uses an extension of the standard. You can make the python encoding standard-compliant passing the allow_nan=False parameter to dumps, but this will raise a ValueError for infinity/nans even if you provide a default function.

You have two ways of doing what you want:

1. Subclass JSONEncoder and change how these values are encoded. Note that you will have to take into account cases where a sequence can contain an infinity value etc. AFAIK there is no API to redefine how objects of a specific class are encoded.

2. Make a copy of the object to encode and replace any occurrence of infinity/nan with None or some other object that is encoded as you want.

A less robust, yet much simpler solution, is to modify the encoded data, for example replacing all Infinity substrings with null:

>>> import re
>>> infty_regex = re.compile(r'\bInfinity\b')
>>> def replace_infinities(encoded):
...     regex = re.compile(r'\bInfinity\b')
...     return regex.sub('null', encoded)
... 
>>> import json
>>> replace_infinities(json.dumps([1, 2, 3, float('inf'), 4]))
'[1, 2, 3, null, 4]'

Obviously you should take into account the text Infinity inside strings etc., so even here a robust solution is not immediate, nor elegant.

Answer 3

语境

我遇到了这个问题，不想为了处理这种情况而在项目中引入额外的依赖。此外，我的项目支持 Python 2.6、2.7、3.3 和 3.4 以及用户的simplejson. 不幸的是，这些版本之间存在三种不同的实现iterencode，因此对特定版本进行硬编码是不可取的。

希望这会帮助其他有类似要求的人！

预选赛

如果与项目的其他组件相比，围绕调用的编码时间/处理能力较小，则可以利用kwargjson.dumps对 JSON 进行取消编码/重新编码以获得所需的结果。parse_constant

好处

• 最终用户是否拥有 Python 2.x json、Python 3.xjson或正在使用simplejson（例如，import simplejson as json）并不重要
• 它只使用json不太可能改变的公共接口。

注意事项

• 这将需要大约 3 倍的时间来编码
• 此实现不处理 object_pairs_hook 因为它不适用于 python 2.6
• 无效的分隔符将失败

代码

class StrictJSONEncoder(json.JSONEncoder):

    def default(self, o):
        """Make sure we don't instantly fail"""
        return o

    def coerce_to_strict(self, const):
        """
        This is used to ultimately *encode* into strict JSON, see `encode`

        """
        # before python 2.7, 'true', 'false', 'null', were include here.
        if const in ('Infinity', '-Infinity', 'NaN'):
            return None
        else:
            return const

    def encode(self, o):
        """
        Load and then dump the result using parse_constant kwarg

        Note that setting invalid separators will cause a failure at this step.

        """

        # this will raise errors in a normal-expected way
        encoded_o = super(StrictJSONEncoder, self).encode(o)

        # now:
        #    1. `loads` to switch Infinity, -Infinity, NaN to None
        #    2. `dumps` again so you get 'null' instead of extended JSON
        try:
            new_o = json.loads(encoded_o, parse_constant=self.coerce_to_strict)
        except ValueError:

            # invalid separators will fail here. raise a helpful exception
            raise ValueError(
                "Encoding into strict JSON failed. Did you set the separators "
                "valid JSON separators?"
            )
        else:
            return json.dumps(new_o, sort_keys=self.sort_keys,
                              indent=self.indent,
                              separators=(self.item_separator,
                                          self.key_separator))

Answer 4

您可以按照以下方式做一些事情：

import json
import math

target=[1.1,1,2.2,float('inf'),float('nan'),'a string',int(2)]

def ffloat(f):
    if not isinstance(f,float):
        return f
    if math.isnan(f):
        return 'custom NaN'
    if math.isinf(f):
        return 'custom inf'
    return f

print 'regular json:',json.dumps(target)      
print 'customized:',json.dumps(map(ffloat,target))     

印刷：

regular json: [1.1, 1, 2.2, Infinity, NaN, "a string", 2]
customized: [1.1, 1, 2.2, "custom inf", "custom NaN", "a string", 2]

如果你想处理嵌套数据结构，这也不是那么难：

import json
import math
from collections import Mapping, Sequence

def nested_json(o):
    if isinstance(o, float):
        if math.isnan(o):
            return 'custom NaN'
        if math.isinf(o):
            return 'custom inf'
        return o
    elif isinstance(o, basestring):
        return o
    elif isinstance(o, Sequence):
        return [nested_json(item) for item in o]
    elif isinstance(o, Mapping):
        return dict((key, nested_json(value)) for key, value in o.iteritems())
    else:
        return o    

nested_tgt=[1.1,{1.1:float('inf'),3.3:5},(float('inf'),2.2),]

print 'regular json:',json.dumps(nested_tgt)      
print 'nested json',json.dumps(nested_json(nested_tgt))

印刷：

regular json: [1.1, {"3.3": 5, "1.1": Infinity}, [Infinity, 2.2]]
nested json [1.1, {"3.3": 5, "1.1": "custom inf"}, ["custom inf", 2.2]]