Формат плавает с помощью стандартного модуля JSON

Question

Я использую стандартный json модуль в Python 2.6 для сериализации списка чисел с плавающей запятой. Тем не менее, я получаю такие результаты:

>>> import json
>>> json.dumps([23.67, 23.97, 23.87])
'[23.670000000000002, 23.969999999999999, 23.870000000000001]'

Я хочу, чтобы числа с плавающей запятой форматировались только с двумя десятичными цифрами. Вывод должен выглядеть так:

>>> json.dumps([23.67, 23.97, 23.87])
'[23.67, 23.97, 23.87]'

Я попытался определить свой собственный класс JSON Encoder:

class MyEncoder(json.JSONEncoder):
    def encode(self, obj):
        if isinstance(obj, float):
            return format(obj, '.2f')
        return json.JSONEncoder.encode(self, obj)

Это работает для единственного объекта с плавающей точкой:

>>> json.dumps(23.67, cls=MyEncoder)
'23.67'

Но не работает для вложенных объектов:

>>> json.dumps([23.67, 23.97, 23.87])
'[23.670000000000002, 23.969999999999999, 23.870000000000001]'

Я не хочу иметь внешние зависимости, поэтому я предпочитаю придерживаться стандартного модуля json.

Как мне этого добиться?

Answer 1

К сожалению, я полагаю, что вы должны сделать это путем «мартышки» (что, на мой взгляд, указывает на дефект дизайна в стандартной библиотеке json пакета). Например, этот код:

import json
from json import encoder
encoder.FLOAT_REPR = lambda o: format(o, '.2f')

print json.dumps(23.67)
print json.dumps([23.67, 23.97, 23.87])

излучает:

23.67
[23.67, 23.97, 23.87]

по вашему желанию. Очевидно, что должен быть запрограммированный способ переопределения FLOAT_REPR, чтобы КАЖДОЕ представление поплавка находилось под вашим контролем, если вы этого хотите; но, к сожалению, пакет json был разработан не так: - (.

Answer 2

import simplejson

class PrettyFloat(float):
    def __repr__(self):
        return '%.15g' % self

def pretty_floats(obj):
    if isinstance(obj, float):
        return PrettyFloat(obj)
    elif isinstance(obj, dict):
        return dict((k, pretty_floats(v)) for k, v in obj.items())
    elif isinstance(obj, (list, tuple)):
        return map(pretty_floats, obj)  # in Python3 do: list(map(pretty_floats, obj))
    return obj

print simplejson.dumps(pretty_floats([23.67, 23.97, 23.87]))

излучает

[23.67, 23.97, 23.87]

Обезьяны не нужны.

Answer 3

Если вы используете Python 2.7, простое решение состоит в том, чтобы просто просто округлить числа с плавающей точкой с желаемой точностью.

>>> sys.version
'2.7.1 (r271:86832, Nov 27 2010, 18:30:46) [MSC v.1500 32 bit (Intel)]'
>>> json.dumps(1.0/3.0)
'0.3333333333333333'
>>> json.dumps(round(1.0/3.0, 2))
'0.33'

Это работает, потому что Python 2.7 сделал округление с плавающей точкой более последовательным . К сожалению, это не работает в Python 2.6:

>>> sys.version
'2.6.6 (r266:84292, Dec 27 2010, 00:02:40) \n[GCC 4.4.5]'
>>> json.dumps(round(1.0/3.0, 2))
'0.33000000000000002'

Указанные выше решения являются обходными для 2.6, но ни одно из них не является полностью адекватным. Исправление обезьяны json.encoder.FLOAT_REPR не работает, если ваша среда выполнения Python использует C-версию модуля JSON. Класс PrettyFloat в ответе Тома Ваттке работает, но только если кодировка% g работает глобально для вашего приложения. % .15g немного волшебен, он работает, потому что точность с плавающей запятой составляет 17 значащих цифр, а% g не печатает конечные нули.

Я потратил некоторое время, пытаясь создать PrettyFloat, который позволял бы настраивать точность для каждого числа. Т.е. синтаксис вроде

>>> json.dumps(PrettyFloat(1.0 / 3.0, 4))
'0.3333'

Нелегко понять это правильно. Наследовать от поплавка неудобно. Наследование от Object и использование подкласса JSONEncoder со своим собственным методом default () должны работать, за исключением того, что модуль json предполагает, что все пользовательские типы должны быть сериализованы как строки. То есть: в результате вы получите строку Javascript «0.33», а не число 0.33. Возможно, еще есть способ сделать это, но это сложнее, чем кажется.

Answer 4

Очень жаль, что dumps не позволяет вам делать что-либо для поплавков. Однако loads делает. Поэтому, если вы не возражаете против дополнительной загрузки процессора, вы можете выбросить ее через кодировщик / декодер / кодировщик и получить правильный результат:

>>> json.dumps(json.loads(json.dumps([.333333333333, .432432]), parse_float=lambda x: round(float(x), 3)))
'[0.333, 0.432]'

Answer 5

Если вы застряли с Python 2.5 или более ранними версиями: трюк с monkey-patch не работает с оригинальным модулем simplejson, если установлены ускорения C:

$ python
Python 2.5.4 (r254:67916, Jan 20 2009, 11:06:13) 
[GCC 4.2.1 (SUSE Linux)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import simplejson
>>> simplejson.__version__
'2.0.9'
>>> simplejson._speedups
<module 'simplejson._speedups' from '/home/carlos/.python-eggs/simplejson-2.0.9-py2.5-linux-i686.egg-tmp/simplejson/_speedups.so'>
>>> simplejson.encoder.FLOAT_REPR = lambda f: ("%.2f" % f)
>>> simplejson.dumps([23.67, 23.97, 23.87])
'[23.670000000000002, 23.969999999999999, 23.870000000000001]'
>>> simplejson.encoder.c_make_encoder = None
>>> simplejson.dumps([23.67, 23.97, 23.87])
'[23.67, 23.97, 23.87]'
>>> 

Answer 6

Вы можете делать то, что вам нужно, но это не задокументировано:

>>> import json
>>> json.encoder.FLOAT_REPR = lambda f: ("%.2f" % f)
>>> json.dumps([23.67, 23.97, 23.87])
'[23.67, 23.97, 23.87]'

Answer 7

Вот решение, которое работало для меня в Python 3 и не требует внесения исправлений обезьяны:

import json

def round_floats(o):
    if isinstance(o, float): return round(o, 2)
    if isinstance(o, dict): return {k: round_floats(v) for k, v in o.items()}
    if isinstance(o, (list, tuple)): return [round_floats(x) for x in o]
    return o


json.dumps(round_floats([23.63437, 23.93437, 23.842347]))

Вывод:

[23.63, 23.93, 23.84]

Копирует данные, но с закругленными числами.

Answer 8

Решение Alex Martelli будет работать для однопоточных приложений, но может не работать для многопоточных приложений, которым необходимо контролировать количество десятичных разрядов в потоке. Вот решение, которое должно работать в многопоточных приложениях:

import threading
from json import encoder

def FLOAT_REPR(f):
    """
    Serialize a float to a string, with a given number of digits
    """
    decimal_places = getattr(encoder.thread_local, 'decimal_places', 0)
    format_str = '%%.%df' % decimal_places
    return format_str % f

encoder.thread_local = threading.local()
encoder.FLOAT_REPR = FLOAT_REPR     

#As an example, call like this:
import json

encoder.thread_local.decimal_places = 1
json.dumps([1.56, 1.54]) #Should result in '[1.6, 1.5]'

Вы можете просто установить encoder.thread_local.decimal_places на желаемое количество десятичных разрядов, и следующий вызов json.dumps () в этом потоке будет использовать это количество десятичных разрядов

Answer 9

Если вам нужно сделать это в Python 2.7 без переопределения глобального json.encoder.FLOAT_REPR, вот один из способов.

import json
import math

class MyEncoder(json.JSONEncoder):
    "JSON encoder that renders floats to two decimal places"

    FLOAT_FRMT = '{0:.2f}'

    def floatstr(self, obj):
        return self.FLOAT_FRMT.format(obj)

    def _iterencode(self, obj, markers=None):
        # stl JSON lame override #1
        new_obj = obj
        if isinstance(obj, float):
            if not math.isnan(obj) and not math.isinf(obj):
                new_obj = self.floatstr(obj)
        return super(MyEncoder, self)._iterencode(new_obj, markers=markers)

    def _iterencode_dict(self, dct, markers=None):
        # stl JSON lame override #2
        new_dct = {}
        for key, value in dct.iteritems():
            if isinstance(key, float):
                if not math.isnan(key) and not math.isinf(key):
                    key = self.floatstr(key)
            new_dct[key] = value
        return super(MyEncoder, self)._iterencode_dict(new_dct, markers=markers)

Затем в Python 2.7:

>>> from tmp import MyEncoder
>>> enc = MyEncoder()
>>> enc.encode([23.67, 23.98, 23.87])
'[23.67, 23.98, 23.87]'

В python 2.6 это не совсем работает, как указывает Мэтью Шинкель ниже:

>>> import MyEncoder
>>> enc = MyEncoder()  
>>> enc.encode([23.67, 23.97, 23.87])
'["23.67", "23.97", "23.87"]'

Answer 10

Я согласен с @Nelson в том, что наследование от float неудобно, но, возможно, решение, которое касается только функции __repr__, может быть простительным. В итоге я использовал пакет decimal для этого, чтобы при необходимости переформатировать поплавки. Плюс в том, что это работает во всех контекстах, где вызывается repr(), а также при простой печати списков в стандартный вывод. Кроме того, точность настраивается во время выполнения после создания данных. Недостатком, конечно, является то, что ваши данные должны быть преобразованы в этот специальный класс с плавающей точкой (поскольку, к сожалению, вы не можете показывать обезьяну патч float.__repr__). Для этого я предоставляю краткую функцию преобразования.

Код:

import decimal
C = decimal.getcontext()

class decimal_formatted_float(float):
   def __repr__(self):
       s = str(C.create_decimal_from_float(self))
       if '.' in s: s = s.rstrip('0')
       return s

def convert_to_dff(elem):
    try:
        return elem.__class__(map(convert_to_dff, elem))
    except:
        if isinstance(elem, float):
            return decimal_formatted_float(elem)
        else:
            return elem

Пример использования:

>>> import json
>>> li = [(1.2345,),(7.890123,4.567,890,890.)]
>>>
>>> decimal.getcontext().prec = 15
>>> dff_li = convert_to_dff(li)
>>> dff_li
[(1.2345,), (7.890123, 4.567, 890, 890)]
>>> json.dumps(dff_li)
'[[1.2345], [7.890123, 4.567, 890, 890]]'
>>>
>>> decimal.getcontext().prec = 3
>>> dff_li = convert_to_dff(li)
>>> dff_li
[(1.23,), (7.89, 4.57, 890, 890)]
>>> json.dumps(dff_li)
'[[1.23], [7.89, 4.57, 890, 890]]'