Python JSON sérialiser un objet Decimal

J'ai un Decimal('3.9')dans le cadre d'un objet, et souhaite encoder cela en une chaîne JSON qui devrait ressembler à{'x': 3.9} . Je ne me soucie pas de la précision du côté client, donc un flotteur est très bien.

Existe-t-il un bon moyen de sérialiser cela? JSONDecoder n'accepte pas les objets Decimal, et la conversion en un flottant au préalable donne {'x': 3.8999999999999999}ce qui est faux, et sera un gros gaspillage de bande passante.

Qu'en est-il du sous json.JSONEncoder- classement ?

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)

Ensuite, utilisez-le comme ceci:

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

Simplejson 2.1 et supérieur a un support natif pour le type décimal:

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

Notez que use_decimalc'est Truepar 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):

Alors:

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

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

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 mis à niveau vers Python 2.7 et il a cessé de fonctionner. J'ai essayé de penser à une sorte de moyen d'encoder des 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 float(o)
        return super(DecimalEncoder, self).default(o)

J'espère que cela devrait aider toute personne ayant des problèmes avec Python 2.7. Je l'ai testé et cela semble bien fonctionner. Si quelqu'un remarque des bogues dans ma solution ou propose une meilleure solution, faites-le moi savoir.

Dans mon application Flask, qui utilise python 2.7.11, l'alchimie des flacons (avec les types 'db.decimal') et Flask Marshmallow (pour le sérialiseur et désérialiseur 'instantané'), j'ai eu cette erreur, chaque fois que j'ai fait un GET ou un POST . Le sérialiseur et le désérialiseur n'ont pas réussi à convertir les types décimaux en n'importe quel format identifiable JSON.

J'ai fait un "pip install simplejson", puis juste en ajoutant

import simplejson as json

le sérialiseur et le désérialiseur recommencent à ronronner. Je n'ai rien fait d'autre ... Les DEciamls sont affichés au format flottant '234.00'.

J'ai essayé de passer de simplejson à json intégré pour GAE 2.7 et j'ai eu des problèmes avec la décimale. Si la valeur par défaut renvoyait str (o), il y avait des guillemets (car _iterencode appelle _iterencode sur les résultats de la valeur par défaut), et float (o) supprimerait le 0 à la fin.

Si par défaut renvoie un objet d'une classe qui hérite de float (ou de tout ce 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]'

L'option native est manquante, je vais donc l'ajouter pour le prochain gars / gall qui le recherche.

À partir de Django 1.7.x, il existe un module intégré à partir duquel DjangoJSONEncodervous pouvez l'obtenir 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!

Mon 0,02 $!

J'étends un tas de l'encodeur JSON depuis que je sérialise des tonnes de données pour mon serveur web. Voici un bon code. Notez qu'il est facilement extensible à pratiquement tous les formats de données que vous souhaitez et reproduira 3.9 comme"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

Rend ma vie tellement plus facile ...

3.9ne peut pas être représenté exactement dans les flotteurs IEEE, cela viendra toujours car 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 float, seule option vous devez l'envoyer sous forme de 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)

Pour les utilisateurs de Django :

Récemment rencontré TypeError: Decimal('2337.00') is not JSON serializable lors de l'encodage JSON iejson.dumps(data)

Solution :

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

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

Mais, maintenant la valeur Decimal sera une chaîne, maintenant nous pouvons explicitement définir l'analyseur de valeur décimal / flottant lors du décodage des données, en utilisant l' parse_floatoption dans json.loads:

import decimal 

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

Du document standard JSON , comme lié dans json.org :

JSON est agnostique sur la sémantique des nombres. Dans tout langage de programmation, il peut y avoir une variété de types de nombres de capacités et de compléments divers, fixes ou flottants, binaires ou décimaux. Cela peut rendre difficile l'échange entre différents langages de programmation. JSON n'offre à la place que la représentation des nombres que les humains utilisent: une séquence de chiffres. Tous les langages de programmation savent comment comprendre les séquences de chiffres même s'ils ne sont pas d'accord sur les représentations internes. Cela suffit pour permettre l'échange.

Il est donc exact de représenter les décimales sous forme de nombres (plutôt que de chaînes) dans JSON. Ci-dessous se trouve une solution possible au problème.

Définissez un encodeur JSON personnalisé:

import json


class CustomJsonEncoder(json.JSONEncoder):

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

Ensuite, utilisez-le lors de la sérialisation de vos données:

json.dumps(data, cls=CustomJsonEncoder)

Comme indiqué dans les commentaires sur les autres réponses, les anciennes versions de python peuvent perturber la représentation lors de la conversion en float, mais ce n'est plus le cas.

Pour récupérer la décimale en Python:

Decimal(str(value))

Cette solution est suggérée dans la documentation Python 3.0 sur les décimales :

Pour créer un Decimal à partir d'un flottant, convertissez-le d'abord en chaîne.

Voici ce que j'ai, extrait de notre classe

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)

Qui passe le moins:

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)

Vous pouvez créer un encodeur JSON personnalisé selon vos besoins.

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)

Le décodeur peut être appelé comme ceci,

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

et la sortie sera:

>>'{"x": 3.9}'

Pour ceux qui ne veulent pas utiliser une bibliothèque tierce ... Un problème avec la réponse d'Elias Zamaria est qu'elle se transforme en float, ce qui peut entraîner des problèmes. Par exemple:

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

La JSONEncoder.encode()méthode vous permet de retourner le contenu json littéral, contrairement à JSONEncoder.default()ce qui vous oblige à retourner un type compatible json (comme float) qui est ensuite encodé de la manière normale. Le problème encode()est qu'il ne fonctionne (normalement) qu'au niveau supérieur. Mais c'est toujours utilisable, avec un peu de travail supplémentaire (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)

Ce qui vous donne:

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

Sur la base de la réponse stdOrgnlDave, j'ai défini ce wrapper qu'il peut être appelé avec des types facultatifs afin que l'encodeur ne fonctionne que pour certains types à l'intérieur de vos projets. Je crois que le travail doit être fait à l'intérieur de votre code et ne pas utiliser cet encodeur "par défaut" car "il vaut mieux explicite qu'implicite", mais je comprends que son utilisation vous fera gagner du temps. :-)

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

Si vous souhaitez passer un dictionnaire contenant des décimales à la requestsbibliothèque (en utilisant l' jsonargument mot - clé), il vous suffit d'installer 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')})

La raison du problème est qu'il requestsn'utilise simplejsonque s'il est présent, et retombe sur le intégré jsons'il n'est pas installé.

cela peut être fait en ajoutant

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

dans \Lib\json\encoder.py:JSONEncoder._iterencode, mais j'espérais une meilleure solution