Python JSON serializza un oggetto Decimale

Ho Decimal('3.9')come parte di un oggetto e desidero codificarlo in una stringa JSON che dovrebbe apparire come {'x': 3.9}. Non mi interessa la precisione sul lato client, quindi un galleggiante va bene.

C'è un buon modo per serializzare questo? JSONDecoder non accetta oggetti decimali e la conversione in float produce in anticipo un {'x': 3.8999999999999999}errore, e sarà un grande spreco di larghezza di banda.

Che ne dici di una sottoclasse 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)

Quindi usalo così:

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

Simplejson 2.1 e versioni successive hanno il supporto nativo per il tipo Decimale:

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

Si noti che use_decimalè Trueper impostazione predefinita:

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

Così:

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

Speriamo che questa funzione sia inclusa nella libreria standard.

Vorrei far sapere a tutti che ho provato la risposta di Michał Marczyk sul mio server Web che eseguiva Python 2.6.5 e che ha funzionato bene. Tuttavia, ho eseguito l'aggiornamento a Python 2.7 e ha smesso di funzionare. Ho provato a pensare a un modo per codificare gli oggetti decimali e questo è quello che mi è venuto in mente:

import decimal

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

Si spera che ciò possa aiutare chiunque abbia problemi con Python 2.7. L'ho provato e sembra funzionare bene. Se qualcuno nota qualche bug nella mia soluzione o trova un modo migliore, per favore fatemelo sapere.

Nella mia app Flask, che utilizza python 2.7.11, l'alchimia di flask (con tipi 'db.decimal') e Flask Marshmallow (per serializzatore e deserializzatore 'istantanei), ho riscontrato questo errore, ogni volta che ho fatto GET o POST . Il serializzatore e il deserializzatore non sono riusciti a convertire i tipi decimali in qualsiasi formato identificabile JSON.

Ho fatto un "pip install simplejson", quindi solo aggiungendo

import simplejson as json

il serializzatore e il deserializzatore iniziano a fare le fusa di nuovo. Non ho fatto nient'altro ... DEciamls viene visualizzato come formato float "234.00".

Ho provato a passare da simplejson a builtin json per GAE 2.7 e ho avuto problemi con il decimale. Se il valore predefinito restituiva str (o) c'erano delle virgolette (perché _iterencode chiama _iterencode sui risultati di default), e float (o) rimuoveva lo 0 finale.

Se il valore predefinito restituisce un oggetto di una classe che eredita da float (o tutto ciò che chiama repr senza ulteriore formattazione) e ha un metodo __repr__ personalizzato, sembra funzionare come voglio.

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

Manca l'opzione nativa, quindi la aggiungerò per il prossimo / a ragazzo che la cerca.

A partire da Django 1.7.x c'è un built-in DjangoJSONEncoderda cui puoi ottenerlo 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!

I miei $ 0,02!

Estendo un sacco di codificatore JSON dal momento che sto serializzando tonnellate di dati per il mio server web. Ecco un bel codice. Nota che è facilmente estendibile praticamente a qualsiasi formato di dati che ti piace e riprodurrà 3.9 come"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

Rende la mia vita molto più semplice ...

3.9non può essere rappresentato esattamente nei float IEEE, verrà sempre come 3.8999999999999999, ad esempio provare print repr(3.9), puoi leggere di più qui:

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

Quindi, se non vuoi float, l'unica opzione devi inviarlo come stringa e per consentire la conversione automatica degli oggetti decimali in JSON, fai qualcosa del genere:

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)

Per gli utenti di Django :

Di recente mi sono imbattuto TypeError: Decimal('2337.00') is not JSON serializable mentre la codifica JSON vale a direjson.dumps(data)

Soluzione :

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

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

Ma ora il valore Decimale sarà una stringa, ora possiamo impostare esplicitamente il parser del valore decimale / float durante la decodifica dei dati, usando l' parse_floatopzione in json.loads:

import decimal 

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

Dal documento standard JSON , come collegato in json.org :

JSON è agnostico sulla semantica dei numeri. In qualsiasi linguaggio di programmazione, ci possono essere una varietà di tipi numerici di varie capacità e complementi, fissi o mobili, binari o decimali. Ciò può rendere difficile l'interscambio tra diversi linguaggi di programmazione. JSON invece offre solo la rappresentazione di numeri che gli umani usano: una sequenza di cifre. Tutti i linguaggi di programmazione sanno dare un senso alle sequenze di cifre anche se non sono d'accordo sulle rappresentazioni interne. Questo è sufficiente per consentire l'interscambio.

Quindi in realtà è accurato rappresentare i decimali come numeri (anziché come stringhe) in JSON. Muggito sta una possibile soluzione al problema.

Definire un codificatore JSON personalizzato:

import json


class CustomJsonEncoder(json.JSONEncoder):

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

Quindi utilizzalo durante la serializzazione dei dati:

json.dumps(data, cls=CustomJsonEncoder)

Come notato dai commenti sulle altre risposte, le versioni precedenti di Python potrebbero rovinare la rappresentazione durante la conversione in float, ma non è più così.

Per recuperare il decimale in Python:

Decimal(str(value))

Questa soluzione è suggerita nella documentazione di Python 3.0 sui decimali :

Per creare un decimale da un float, prima convertirlo in una stringa.

Questo è quello che ho estratto dalla nostra 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)

Che passa unittest:

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)

È possibile creare un codificatore JSON personalizzato secondo le proprie esigenze.

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)

Il decodificatore può essere chiamato in questo modo,

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

e l'output sarà:

>>'{"x": 3.9}'

Per coloro che non vogliono usare una libreria di terze parti ... Un problema con la risposta di Elias Zamaria è che si converte in float, il che può incorrere in problemi. Per esempio:

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

Il JSONEncoder.encode()metodo consente di restituire il contenuto json letterale, a differenza di quello JSONEncoder.default()che restituisce un tipo compatibile json (come float) che viene quindi codificato in modo normale. Il problema encode()è che (normalmente) funziona solo al livello più alto. Ma è ancora utilizzabile, con un po 'di lavoro extra (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)

Che ti dà:

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

Sulla base della risposta stdOrgnlDave ho definito questo wrapper che può essere chiamato con tipi opzionali in modo che l'encoder funzionerà solo per determinati tipi all'interno dei tuoi progetti. Credo che il lavoro dovrebbe essere svolto all'interno del codice e non utilizzare questo codificatore "predefinito" poiché "è meglio esplicito che implicito", ma capisco che l'uso di questo ti farà risparmiare un po 'di tempo. :-)

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

Se vuoi passare un dizionario contenente decimali alla requestslibreria (usando l' jsonargomento keyword), devi semplicemente installare 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')})

Il motivo del problema è che requestsutilizza simplejsonsolo se è presente e ricade nell'integrato jsonse non è installato.

questo può essere fatto aggiungendo

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

dentro \Lib\json\encoder.py:JSONEncoder._iterencode, ma speravo in una soluzione migliore