web-dev-qa-db-ja.com

標準のJSONモジュールで浮動小数点をフォーマットする

標準の jsonモジュール in python 2.6を使用して、フロートのリストをシリアル化します。ただし、次のような結果が得られます。

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

Floatを2桁の10進数のみでフォーマットする必要があります。出力は次のようになります。

>>> 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)

これは唯一のfloatオブジェクトに対して機能します：

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

ただし、ネストされたオブジェクトでは失敗します。

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

外部の依存関係を持ちたくないので、標準のjsonモジュールに固執します。

どうすればこれを達成できますか？

pythonjsonformattingfloating-point
83
Manuel Ceron

残念ながら、あなたはこれを猿のパッチでやらなければならないと思います（私の意見では、これは標準ライブラリ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パッケージの設計方法ではありません:-(。

72
Alex Martelli
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]

モンキーパッチは必要ありません。

56
Tom Wuttke

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ランタイムがJSONモジュールのCバージョンを使用している場合は機能しません。TomWuttkeの回答のPrettyFloatクラスは機能しますが、 ％.15gはちょっとした魔法ですが、float精度が17桁の有効数字であり、％gが末尾のゼロを出力しないため機能します。

私は、各数値の精度をカスタマイズできるPrettyFloatを作成しようといくつかの時間を費やしました。すなわち、次のような構文

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

これを正しくするのは簡単ではありません。フロートからの継承は厄介です。 Objectから継承し、独自のdefault（）メソッドでJSONEncoderサブクラスを使用すると動作しますが、jsonモジュールはすべてのカスタム型を文字列としてシリアル化することを前提としているようです。つまり、出力には、数値0.33ではなくJavascript文字列「0.33」が含まれます。この作業を行う方法はまだあるかもしれませんが、見た目よりも難しいです。

26
Nelson

dumpsがfloatに対して何もできないことは本当に残念です。ただし、loadsはそうします。したがって、余分なCPU負荷を気にしない場合は、エンコーダー/デコーダー/エンコーダーを介してスローし、正しい結果を得ることができます。

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

Python 2.5以前のバージョン：Cスピードアップがインストールされている場合、monkey-patchトリックは元のsimplejsonモジュールでは動作しないようです：

$ 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]'
>>>
9
Carlos Valiente

必要なことはできますが、文書化されていません。

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

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]

データをコピーしますが、フロートは丸められます。

4
jcoffland

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（）を次に呼び出すと、その小数点以下の桁数が使用されます。

2
Anton I. Sipos

グローバルjson.encoder.FLOAT_REPRをオーバーライドせずにpython 2.7でこれを行う必要がある場合は、1つの方法があります。

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では、Matthew Schinckelが以下で指摘しているように、それはまったく機能しません。

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

標準jsonモジュールをインポートする場合、デフォルトのエンコーダーFLOAT_REPRを変更するだけで十分です。 Encoderインスタンスをインポートまたは作成する必要はありません。

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

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

Jsonとして最適な表現pythonはstrで推測できます。これにより、有効数字が無視されないようになります。

import json
json.dumps([23.67, 23.9779, 23.87489])
# output is'[23.670000000000002, 23.977900000000002, 23.874890000000001]'

json.encoder.FLOAT_REPR = str
json.dumps([23.67, 23.9779, 23.87489])
# output is '[23.67, 23.9779, 23.87489]'
1
F Pereira

私は、floatからの継承が厄介であることに@Nelsonに同意しますが、おそらく___repr___関数のみに触れるソリューションは許されるかもしれません。必要に応じてdecimalパッケージを使用してフロートを再フォーマットしました。利点は、これがrepr()が呼び出されているすべてのコンテキストで機能することです。したがって、たとえばリストを標準出力に単純に出力する場合も同様です。また、データが作成された後、精度はランタイムで構成可能です。もちろん、データをこの特別なfloatクラスに変換する必要があるという欠点があります（残念ながら、_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]]'
_
1
user1556435

長所：

  • 任意のJSONエンコーダー、またはpythonのreprでも動作します。
  • 短い（のような）、動作するようです。

短所：

  • かろうじてテストされたUい正規表現ハック。

  • 二次の複雑さ。

    def fix_floats(json, decimals=2, quote='"'):
    pattern = r'^((?:(?:"(?:\\.|[^\\"])*?")|[^"])*?)(-?\d+\.\d{'+str(decimals)+'}\d+)'
    pattern = re.sub('"', quote, pattern) 
    fmt = "%%.%df" % decimals
    n = 1
    while n:
        json, n = re.subn(pattern, lambda m: m.group(1)+(fmt % float(m.group(2)).rstrip('0')), json)
    return json
1
Sam Watkins