Python JSON sérialise un objet Decimal

Question

J'ai un Decimal('3.9') en tant que partie d'un objet, et je souhaite l'encoder en une chaîne JSON qui devrait ressembler à ceci {'x': 3.9} . Je ne me soucie pas de la précision du côté client, donc une valeur flottante convient parfaitement.

Existe-t-il un bon moyen de sérialiser ceci ? Le décodeur JSOND n'accepte pas les objets décimaux, et la conversion préalable en flottant donne les résultats suivants {'x': 3.8999999999999999} ce qui est faux, et sera un grand gaspillage de bande passante.

Answer 1

Simplejson 2.1 et plus ont un support natif pour le type Decimal :

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

Notez que use_decimal es True par défaut :

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

Donc :

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

Espérons que cette fonctionnalité sera incluse dans la bibliothèque standard.

Answer 2

Je voudrais faire savoir à tout le monde que j'ai essayé la réponse de Michał Marczyk sur mon serveur Web qui exécutait Python 2.6.5 et cela a bien fonctionné. Cependant, j'ai effectué une mise à niveau vers Python 2.7 et cela a cessé de fonctionner. J'ai essayé de penser à une sorte de moyen d'encoder les objets décimaux et voici ce que j'ai trouvé :

import decimal

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

Notez que cela convertira la décimale en sa représentation sous forme de chaîne de caractères (par exemple ; "1.2300" ) pour a. ne pas perdre de chiffres significatifs et b. éviter les erreurs d'arrondi.

Ceci devrait aider tous ceux qui ont des problèmes avec Python 2.7. Je l'ai testé et il semble fonctionner correctement. Si quelqu'un remarque des bogues dans ma solution ou trouve une meilleure façon de procéder, veuillez me le faire savoir.

Exemple d'utilisation :

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

Answer 3

Et si vous sous-classiez json.JSONEncoder ?

class DecimalEncoder(json.JSONEncoder):
    def default(self, o):
        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).default(o)

Ensuite, utilisez-le comme suit :

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

Answer 4

J'ai essayé de passer de simplejson à builtin json pour GAE 2.7, et j'ai eu des problèmes avec la décimale. Si default retournait str(o), il y avait des guillemets (parce que _iterencode appelle _iterencode sur les résultats de default), et float(o) enlevait le 0 de fin de ligne.

Si default renvoie un objet d'une classe qui hérite de float (ou de toute autre classe qui appelle repr sans formatage supplémentaire) et possède une méthode __repr__ personnalisée, cela semble fonctionner comme je le souhaite.

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]'

Answer 5

3.9 ne peut pas être représentée exactement en flottants IEEE, elle sera toujours exprimée en tant que 3.8999999999999999 par exemple, essayez print repr(3.9) Vous pouvez en savoir plus à ce sujet ici :

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

Donc si vous ne voulez pas de flottant, la seule option que vous avez est de l'envoyer en tant que chaîne, et pour permettre la conversion automatique des objets décimaux en JSON, faites quelque chose comme ceci :

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)