Python JSON serializa un objeto decimal

Tengo un Decimal('3.9')como parte de un objeto, y deseo codificar esto en una cadena JSON que debería verse así {'x': 3.9}. No me importa la precisión en el lado del cliente, por lo que un flotador está bien.

¿Hay una buena manera de serializar esto? JSONDecoder no acepta objetos decimales, y la conversión a un flotante de antemano produce lo {'x': 3.8999999999999999}que está mal, y será un gran desperdicio de ancho de banda.

¿Qué tal subclases 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)

Luego úsalo así:

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

Simplejson 2.1 y superior tiene soporte nativo para tipo Decimal:

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

Tenga en cuenta que use_decimales Truepor defecto:

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

Entonces:

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

Con suerte, esta característica se incluirá en la biblioteca estándar.

Me gustaría que todos sepan que probé la respuesta de Michał Marczyk en mi servidor web que ejecutaba Python 2.6.5 y funcionó bien. Sin embargo, actualicé a Python 2.7 y dejó de funcionar. Traté de pensar en algún tipo de forma de codificar objetos Decimal y esto es lo que se me ocurrió:

import decimal

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

Con suerte, esto debería ayudar a cualquiera que tenga problemas con Python 2.7. Lo probé y parece funcionar bien. Si alguien nota algún error en mi solución o encuentra una mejor manera, hágamelo saber.

En mi aplicación Flask, que usa python 2.7.11, matraz alquimia (con tipos 'db.decimal') y Flask Marshmallow (para serializador y deserializador 'instantáneo'), tuve este error, cada vez que hice un GET o POST . El serializador y el deserializador no pudieron convertir los tipos decimales en ningún formato identificable JSON.

Hice un "pip install simplejson", luego simplemente agregando

import simplejson as json

el serializador y el deserializador comienzan a ronronear nuevamente. No hice nada más ... DEciamls se muestran como formato flotante '234.00'.

Intenté cambiar de simplejson a json incorporado para GAE 2.7, y tuve problemas con el decimal. Si default devolvió str (o) había comillas (porque _iterencode llama a _iterencode en los resultados de default), y float (o) eliminaría el 0 final.

Si el valor predeterminado devuelve un objeto de una clase que hereda de float (o cualquier cosa que llame a repr sin formato adicional) y tenga un método __repr__ personalizado, parece funcionar como yo quiero.

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

Falta la opción nativa, así que la agregaré para la próxima persona que la busque.

A partir de Django 1.7.x hay una función integrada desde la DjangoJSONEncoderque puede obtenerla 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!

¡Mis $ .02!

Extiendo un montón del codificador JSON ya que estoy serializando toneladas de datos para mi servidor web. Aquí hay un buen código. Tenga en cuenta que es fácilmente extensible a casi cualquier formato de datos que desee y se reproducirá 3.9 como"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

Hace mi vida mucho más fácil ...

3.9no se puede representar exactamente en los flotadores IEEE, siempre vendrá como 3.8999999999999999, por ejemplo print repr(3.9), intente , puede leer más sobre esto aquí:

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

Entonces, si no desea la opción flotante, solo tiene que enviarla como una cadena y permitir la conversión automática de objetos decimales a JSON, haga algo como esto:

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)

Para usuarios de Django :

Recientemente me encontré con la TypeError: Decimal('2337.00') is not JSON serializable codificación JSON, es decirjson.dumps(data)

Solución :

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

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

Pero, ahora el valor decimal será una cadena, ahora podemos establecer explícitamente el analizador de valor decimal / flotante al decodificar datos, usando la parse_floatopción en json.loads:

import decimal 

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

Del documento estándar JSON , como se vincula en json.org :

JSON es agnóstico sobre la semántica de los números. En cualquier lenguaje de programación, puede haber una variedad de tipos de números de varias capacidades y complementos, fijos o flotantes, binarios o decimales. Eso puede dificultar el intercambio entre diferentes lenguajes de programación. En cambio, JSON ofrece solo la representación de números que usan los humanos: una secuencia de dígitos. Todos los lenguajes de programación saben cómo dar sentido a las secuencias de dígitos, incluso si no están de acuerdo con las representaciones internas. Eso es suficiente para permitir el intercambio.

Por lo tanto, en realidad es preciso representar los decimales como números (en lugar de cadenas) en JSON. A continuación se encuentra una posible solución al problema.

Defina un codificador JSON personalizado:

import json


class CustomJsonEncoder(json.JSONEncoder):

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

Luego úselo cuando serialice sus datos:

json.dumps(data, cls=CustomJsonEncoder)

Como se señaló en los comentarios sobre las otras respuestas, las versiones anteriores de python podrían estropear la representación al convertir a flotante, pero ese ya no es el caso.

Para recuperar el decimal en Python:

Decimal(str(value))

Esta solución se insinúa en la documentación de Python 3.0 sobre decimales :

Para crear un decimal a partir de un flotador, primero conviértalo en una cadena.

Esto es lo que tengo, extraído de nuestra clase

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)

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

Puede crear un codificador JSON personalizado según sus necesidades.

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)

El decodificador se puede llamar así,

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

y la salida será:

>>'{"x": 3.9}'

Para aquellos que no quieren usar una biblioteca de terceros ... Un problema con la respuesta de Elias Zamaria es que se convierte en flotante, lo que puede generar problemas. Por ejemplo:

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

El JSONEncoder.encode()método le permite devolver el contenido literal de json, a diferencia de lo JSONEncoder.default()que le permite devolver un tipo compatible con json (como flotante) que luego se codifica de la manera normal. El problema encode()es que (normalmente) solo funciona en el nivel superior. Pero aún es utilizable, con un poco de trabajo 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)

Lo que te da:

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

Basado en la respuesta de stdOrgnlDave , he definido este contenedor que se puede llamar con tipos opcionales para que el codificador funcione solo para ciertos tipos dentro de sus proyectos. Creo que el trabajo debe hacerse dentro de su código y no usar este codificador "predeterminado" ya que "es mejor explícito que implícito", pero entiendo que usar esto le ahorrará algo de tiempo. :-)

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 desea pasar un diccionario que contiene decimales a la requestsbiblioteca (utilizando el jsonargumento de la palabra clave), simplemente necesita instalar 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 razón del problema es que solo se requestsusa simplejsonsi está presente, y recurre al incorporado jsonsi no está instalado.

esto se puede hacer agregando

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

adentro \Lib\json\encoder.py:JSONEncoder._iterencode, pero esperaba una mejor solución