Python JSON serialisiert ein Dezimalobjekt

Ich habe ein Decimal('3.9')als Teil eines Objekts und möchte dies in eine JSON-Zeichenfolge codieren, die aussehen sollte {'x': 3.9}. Präzision auf der Client-Seite ist mir egal, daher ist ein Float in Ordnung.

Gibt es eine gute Möglichkeit, dies zu serialisieren? JSONDecoder akzeptiert keine Dezimalobjekte, und die vorherige Konvertierung in einen Float ergibt {'x': 3.8999999999999999}eine falsche Leistung und ist eine große Verschwendung von Bandbreite.

Wie wäre es mit Unterklassen json.JSONEncoder?

class DecimalEncoder(json.JSONEncoder):
    def _iterencode(self, o, markers=None):
        if isinstance(o, decimal.Decimal):
            # wanted a simple yield str(o) in the next line,
            # but that would mean a yield on the line with super(...),
            # which wouldn't work (see my comment below), so...
            return (str(o) for o in [o])
        return super(DecimalEncoder, self)._iterencode(o, markers)

Dann benutze es so:

json.dumps({'x': decimal.Decimal('5.5')}, cls=DecimalEncoder)

Simplejson 2.1 und höher bietet native Unterstützung für den Dezimaltyp:

>>> json.dumps(Decimal('3.9'), use_decimal=True)
'3.9'

Beachten Sie, dass use_decimalist Truestandardmäßig:

def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
    allow_nan=True, cls=None, indent=None, separators=None,
    encoding='utf-8', default=None, use_decimal=True,
    namedtuple_as_object=True, tuple_as_array=True,
    bigint_as_string=False, sort_keys=False, item_sort_key=None,
    for_json=False, ignore_nan=False, **kw):

So:

>>> json.dumps(Decimal('3.9'))
'3.9'

Hoffentlich wird diese Funktion in der Standardbibliothek enthalten sein.

Ich möchte alle wissen lassen, dass ich Michał Marczyks Antwort auf meinem Webserver ausprobiert habe, auf dem Python 2.6.5 ausgeführt wurde, und dass es einwandfrei funktioniert hat. Ich habe jedoch ein Upgrade auf Python 2.7 durchgeführt und es funktioniert nicht mehr. Ich habe versucht, mir eine Möglichkeit zum Codieren von Dezimalobjekten auszudenken, und mir ist Folgendes eingefallen:

import decimal

class DecimalEncoder(json.JSONEncoder):
    def default(self, o):
        if isinstance(o, decimal.Decimal):
            return float(o)
        return super(DecimalEncoder, self).default(o)

Dies sollte hoffentlich jedem helfen, der Probleme mit Python 2.7 hat. Ich habe es getestet und es scheint gut zu funktionieren. Wenn jemand Fehler in meiner Lösung bemerkt oder einen besseren Weg findet, lassen Sie es mich bitte wissen.

In meiner Flask-App, die Python 2.7.11, Flask-Alchemie (mit 'db.decimal'-Typen) und Flask Marshmallow (für' Instant'-Serializer und -Deserializer) verwendet, trat dieser Fehler jedes Mal auf, wenn ich einen GET oder POST durchführte . Der Serializer und Deserializer konnte keine Dezimaltypen in ein JSON-identifizierbares Format konvertieren.

Ich habe eine "pip install simplejson" gemacht, dann einfach durch Hinzufügen

import simplejson as json

Der Serializer und Deserializer beginnt wieder zu schnurren. Ich habe nichts anderes getan ... DEciamls werden als Float-Format '234.00' angezeigt.

Ich habe versucht, für GAE 2.7 von simplejson auf integriertes json umzuschalten, und hatte Probleme mit der Dezimalstelle. Wenn default str (o) zurückgibt, gibt es Anführungszeichen (weil _iterencode _iterencode für die Ergebnisse von default aufruft), und float (o) würde die nachfolgende 0 entfernen.

Wenn default ein Objekt einer Klasse zurückgibt, die von float erbt (oder etwas, das repr ohne zusätzliche Formatierung aufruft) und eine benutzerdefinierte __repr__ -Methode hat, scheint es so zu funktionieren, wie ich es möchte.

import json
from decimal import Decimal

class fakefloat(float):
    def __init__(self, value):
        self._value = value
    def __repr__(self):
        return str(self._value)

def defaultencode(o):
    if isinstance(o, Decimal):
        # Subclass float with custom repr?
        return fakefloat(o)
    raise TypeError(repr(o) + " is not JSON serializable")

json.dumps([10.20, "10.20", Decimal('10.20')], default=defaultencode)
'[10.2, "10.20", 10.20]'

Die native Option fehlt, also füge ich sie für den nächsten Kerl / die nächste Galle hinzu, die danach sucht.

Ab Django 1.7.x gibt es eine integrierte Funktion DjangoJSONEncoder, von der Sie sie erhalten können django.core.serializers.json.

import json
from django.core.serializers.json import DjangoJSONEncoder
from django.forms.models import model_to_dict

model_instance = YourModel.object.first()
model_dict = model_to_dict(model_instance)

json.dumps(model_dict, cls=DjangoJSONEncoder)

Presto!

Meine $ .02!

Ich erweitere eine Reihe von JSON-Encodern, da ich Tonnen von Daten für meinen Webserver serialisiere. Hier ist ein netter Code. Beachten Sie, dass es leicht auf so ziemlich jedes Datenformat erweiterbar ist, das Sie möchten, und 3.9 als reproduziert"thing": 3.9

JSONEncoder_olddefault = json.JSONEncoder.default
def JSONEncoder_newdefault(self, o):
    if isinstance(o, UUID): return str(o)
    if isinstance(o, datetime): return str(o)
    if isinstance(o, time.struct_time): return datetime.fromtimestamp(time.mktime(o))
    if isinstance(o, decimal.Decimal): return str(o)
    return JSONEncoder_olddefault(self, o)
json.JSONEncoder.default = JSONEncoder_newdefault

Macht mein Leben so viel einfacher ...

3.9kann nicht genau in IEEE-Floats dargestellt werden, es wird immer so kommen 3.8999999999999999, zB versuchen print repr(3.9)Sie hier mehr darüber zu lesen:

http://en.wikipedia.org/wiki/Floating_point
http://docs.sun.com/source/806-3568/ncg_goldberg.html

Wenn Sie also kein Float möchten, müssen Sie es nur als Zeichenfolge senden und die automatische Konvertierung von Dezimalobjekten in JSON ermöglichen. Gehen Sie folgendermaßen vor:

import decimal
from django.utils import simplejson

def json_encode_decimal(obj):
    if isinstance(obj, decimal.Decimal):
        return str(obj)
    raise TypeError(repr(obj) + " is not JSON serializable")

d = decimal.Decimal('3.5')
print simplejson.dumps([d], default=json_encode_decimal)

Für Django-Benutzer :

Vor kurzem kam TypeError: Decimal('2337.00') is not JSON serializable während JSON-Codierung dhjson.dumps(data)

Lösung :

# converts Decimal, Datetime, UUIDs to str for Encoding
from django.core.serializers.json import DjangoJSONEncoder  

json.dumps(response.data, cls=DjangoJSONEncoder)

Aber jetzt ist der Dezimalwert eine Zeichenfolge. Jetzt können wir den Dezimal- / Gleitkomma-Parser beim Dekodieren von Daten explizit festlegen, indem wir die parse_floatOption in verwenden json.loads:

import decimal 

data = json.loads(data, parse_float=decimal.Decimal) # default is float(num_str)

Aus dem JSON-Standarddokument , wie in json.org verlinkt :

JSON ist agnostisch in Bezug auf die Semantik von Zahlen. In jeder Programmiersprache kann es eine Vielzahl von Zahlentypen mit unterschiedlichen Kapazitäten und Ergänzungen geben, fest oder schwebend, binär oder dezimal. Dies kann den Austausch zwischen verschiedenen Programmiersprachen erschweren. JSON bietet stattdessen nur die Darstellung von Zahlen, die Menschen verwenden: eine Folge von Ziffern. Alle Programmiersprachen wissen, wie man Ziffernfolgen versteht, auch wenn sie in internen Darstellungen nicht übereinstimmen. Das reicht aus, um den Austausch zu ermöglichen.

Es ist also tatsächlich korrekt, Dezimalstellen in JSON als Zahlen (anstatt als Zeichenfolgen) darzustellen. Unten liegt eine mögliche Lösung für das Problem.

Definieren Sie einen benutzerdefinierten JSON-Encoder:

import json


class CustomJsonEncoder(json.JSONEncoder):

    def default(self, obj):
        if isinstance(obj, Decimal):
            return float(obj)
        return super(CustomJsonEncoder, self).default(obj)

Verwenden Sie es dann beim Serialisieren Ihrer Daten:

json.dumps(data, cls=CustomJsonEncoder)

Wie aus den Kommentaren zu den anderen Antworten hervorgeht, können ältere Versionen von Python die Darstellung beim Konvertieren in Float durcheinander bringen, aber das ist nicht mehr der Fall.

So erhalten Sie die Dezimalstelle in Python zurück:

Decimal(str(value))

Diese Lösung wird in der Python 3.0-Dokumentation zu Dezimalstellen angedeutet :

Um eine Dezimalstelle aus einem Gleitkommawert zu erstellen, konvertieren Sie sie zunächst in eine Zeichenfolge.

Das habe ich aus unserer Klasse extrahiert

class CommonJSONEncoder(json.JSONEncoder):

    """
    Common JSON Encoder
    json.dumps(myString, cls=CommonJSONEncoder)
    """

    def default(self, obj):

        if isinstance(obj, decimal.Decimal):
            return {'type{decimal}': str(obj)}

class CommonJSONDecoder(json.JSONDecoder):

    """
    Common JSON Encoder
    json.loads(myString, cls=CommonJSONEncoder)
    """

    @classmethod
    def object_hook(cls, obj):
        for key in obj:
            if isinstance(key, six.string_types):
                if 'type{decimal}' == key:
                    try:
                        return decimal.Decimal(obj[key])
                    except:
                        pass

    def __init__(self, **kwargs):
        kwargs['object_hook'] = self.object_hook
        super(CommonJSONDecoder, self).__init__(**kwargs)

Was unittest vergeht:

def test_encode_and_decode_decimal(self):
    obj = Decimal('1.11')
    result = json.dumps(obj, cls=CommonJSONEncoder)
    self.assertTrue('type{decimal}' in result)
    new_obj = json.loads(result, cls=CommonJSONDecoder)
    self.assertEqual(new_obj, obj)

    obj = {'test': Decimal('1.11')}
    result = json.dumps(obj, cls=CommonJSONEncoder)
    self.assertTrue('type{decimal}' in result)
    new_obj = json.loads(result, cls=CommonJSONDecoder)
    self.assertEqual(new_obj, obj)

    obj = {'test': {'abc': Decimal('1.11')}}
    result = json.dumps(obj, cls=CommonJSONEncoder)
    self.assertTrue('type{decimal}' in result)
    new_obj = json.loads(result, cls=CommonJSONDecoder)
    self.assertEqual(new_obj, obj)

Sie können einen benutzerdefinierten JSON-Encoder gemäß Ihren Anforderungen erstellen.

import json
from datetime import datetime, date
from time import time, struct_time, mktime
import decimal

class CustomJSONEncoder(json.JSONEncoder):
    def default(self, o):
        if isinstance(o, datetime):
            return str(o)
        if isinstance(o, date):
            return str(o)
        if isinstance(o, decimal.Decimal):
            return float(o)
        if isinstance(o, struct_time):
            return datetime.fromtimestamp(mktime(o))
        # Any other serializer if needed
        return super(CustomJSONEncoder, self).default(o)

Der Decoder kann so aufgerufen werden,

import json
from decimal import Decimal
json.dumps({'x': Decimal('3.9')}, cls=CustomJSONEncoder)

und die Ausgabe wird sein:

>>'{"x": 3.9}'

Für diejenigen, die keine Bibliothek eines Drittanbieters verwenden möchten ... Ein Problem mit der Antwort von Elias Zamaria ist, dass sie in Float konvertiert wird, was zu Problemen führen kann. Beispielsweise:

>>> json.dumps({'x': Decimal('0.0000001')}, cls=DecimalEncoder)
'{"x": 1e-07}'
>>> json.dumps({'x': Decimal('100000000000.01734')}, cls=DecimalEncoder)
'{"x": 100000000000.01733}'

Mit dieser JSONEncoder.encode()Methode können Sie den wörtlichen json-Inhalt zurückgeben, im Gegensatz dazu JSONEncoder.default(), dass Sie einen json-kompatiblen Typ (wie float) zurückgeben, der dann auf normale Weise codiert wird. Das Problem dabei encode()ist, dass es (normalerweise) nur auf der obersten Ebene funktioniert. Aber es ist immer noch verwendbar, mit ein wenig zusätzlicher Arbeit (Python 3.x):

import json
from collections.abc import Mapping, Iterable
from decimal import Decimal

class DecimalEncoder(json.JSONEncoder):
    def encode(self, obj):
        if isinstance(obj, Mapping):
            return '{' + ', '.join(f'{self.encode(k)}: {self.encode(v)}' for (k, v) in obj.items()) + '}'
        if isinstance(obj, Iterable) and (not isinstance(obj, str)):
            return '[' + ', '.join(map(self.encode, obj)) + ']'
        if isinstance(obj, Decimal):
            return f'{obj.normalize():f}'  # using normalize() gets rid of trailing 0s, using ':f' prevents scientific notation
        return super().encode(obj)

Welches gibt Ihnen:

>>> json.dumps({'x': Decimal('0.0000001')}, cls=DecimalEncoder)
'{"x": 0.0000001}'
>>> json.dumps({'x': Decimal('100000000000.01734')}, cls=DecimalEncoder)
'{"x": 100000000000.01734}'

Basierend auf der Antwort von stdOrgnlDave habe ich diesen Wrapper so definiert, dass er mit optionalen Arten aufgerufen werden kann, sodass der Encoder nur für bestimmte Arten in Ihren Projekten funktioniert. Ich glaube, die Arbeit sollte in Ihrem Code erledigt werden und nicht diesen "Standard" -Codierer zu verwenden, da "es besser explizit als implizit ist", aber ich verstehe, dass die Verwendung dieses Encoders einen Teil Ihrer Zeit spart. :-)

import time
import json
import decimal
from uuid import UUID
from datetime import datetime

def JSONEncoder_newdefault(kind=['uuid', 'datetime', 'time', 'decimal']):
    '''
    JSON Encoder newdfeault is a wrapper capable of encoding several kinds
    Use it anywhere on your code to make the full system to work with this defaults:
        JSONEncoder_newdefault()  # for everything
        JSONEncoder_newdefault(['decimal'])  # only for Decimal
    '''
    JSONEncoder_olddefault = json.JSONEncoder.default

    def JSONEncoder_wrapped(self, o):
        '''
        json.JSONEncoder.default = JSONEncoder_newdefault
        '''
        if ('uuid' in kind) and isinstance(o, uuid.UUID):
            return str(o)
        if ('datetime' in kind) and isinstance(o, datetime):
            return str(o)
        if ('time' in kind) and isinstance(o, time.struct_time):
            return datetime.fromtimestamp(time.mktime(o))
        if ('decimal' in kind) and isinstance(o, decimal.Decimal):
            return str(o)
        return JSONEncoder_olddefault(self, o)
    json.JSONEncoder.default = JSONEncoder_wrapped

# Example
if __name__ == '__main__':
    JSONEncoder_newdefault()

Wenn Sie ein Wörterbuch mit Dezimalstellen an die requestsBibliothek übergeben möchten (mithilfe des jsonSchlüsselwortarguments), müssen Sie lediglich Folgendes installieren simplejson:

$ pip3 install simplejson    
$ python3
>>> import requests
>>> from decimal import Decimal
>>> # This won't error out:
>>> requests.post('https://www.google.com', json={'foo': Decimal('1.23')})

Der Grund für das Problem ist, dass es nur requestsverwendet wird, simplejsonwenn es vorhanden ist, und auf das integrierte System zurückgreift, jsonwenn es nicht installiert ist.

Dies kann durch Hinzufügen erfolgen

    elif isinstance(o, decimal.Decimal):
        yield str(o)

in \Lib\json\encoder.py:JSONEncoder._iterencode, aber ich hoffte auf eine bessere Lösung