JSON Python serializa um objeto decimal

Eu tenho um Decimal('3.9')como parte de um objeto, e gostaria de codificar isso para uma string JSON que deve se parecer {'x': 3.9}. Eu não me importo com precisão no lado do cliente, então um float é bom.

Existe uma boa maneira de serializar isso? JSONDecoder não aceita objetos decimais, e a conversão para um float anteriormente gera o {'x': 3.8999999999999999}que está errado e será um grande desperdício de largura de banda.

Que tal subclassificar 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)

Em seguida, use-o assim:

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

O Simplejson 2.1 e superior tem suporte nativo para o tipo Decimal:

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

Observe que isso use_decimalé Truepor padrão:

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

Assim:

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

Felizmente, esse recurso será incluído na biblioteca padrão.

Gostaria de informar a todos que tentei a resposta de Michał Marczyk no meu servidor Web que estava executando o Python 2.6.5 e funcionou bem. No entanto, atualizei para o Python 2.7 e ele parou de funcionar. Eu tentei pensar em algum tipo de maneira de codificar objetos decimais e é isso que eu criei:

import decimal

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

Espero que isso ajude quem está tendo problemas com o Python 2.7. Eu testei e parece funcionar bem. Se alguém perceber algum erro na minha solução ou apresentar uma maneira melhor, informe-me.

No meu aplicativo Flask, que usa python 2.7.11, alquimia de frascos (com tipos 'db.decimal') e Flask Marshmallow (para serializador e desserializador 'instantâneos'), eu tinha esse erro sempre que fazia um GET ou POST . O serializador e o desserializador falharam ao converter tipos decimais em qualquer formato identificável JSON.

Eu fiz um "pip install simplejson" e, em seguida, apenas adicionando

import simplejson as json

o serializador e o desserializador começam a ronronar novamente. Eu não fiz mais nada ... DEciamls são exibidos como formato flutuante '234.00'.

Tentei mudar do simplejson para o json embutido no GAE 2.7 e tive problemas com o decimal. Se o padrão retornasse str (o), havia aspas (porque _iterencode chama _iterencode nos resultados do padrão) e float (o) removeria o zero final.

Se o padrão retornar um objeto de uma classe que herda de float (ou qualquer coisa que chame repr sem formatação adicional) e tenha um método __repr__ personalizado, ele parece funcionar como eu quero.

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

A opção nativa está faltando, então eu a adicionarei para o próximo cara / galha que a procurar.

A partir do Django 1.7.x, há um built-in do DjangoJSONEncoderqual você pode obtê-lo 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!

Meu $ .02!

Eu estendo um monte de codificador JSON desde que estou serializando toneladas de dados para o meu servidor web. Aqui está um bom código. Observe que é facilmente extensível a praticamente qualquer formato de dados que você desejar e reproduz 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

Torna minha vida muito mais fácil ...

3.9não pode ser representado exatamente nos carros alegóricos IEEE, sempre virá como 3.8999999999999999, por exemplo print repr(3.9), tente , você pode ler mais sobre isso aqui:

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

Portanto, se você não quiser flutuar, apenas a opção deve ser enviada como string e para permitir a conversão automática de objetos decimais em JSON, faça algo assim:

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 usuários do Django :

Recentemente, deparei com a TypeError: Decimal('2337.00') is not JSON serializable codificação JSON, ou seja,json.dumps(data)

Solução :

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

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

Mas agora o valor decimal será uma string, agora podemos definir explicitamente o analisador de valor decimal / flutuante ao decodificar dados, usando a parse_floatopção em json.loads:

import decimal 

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

No documento padrão JSON , conforme vinculado em json.org :

JSON é independente da semântica dos números. Em qualquer linguagem de programação, pode haver vários tipos de números de várias capacidades e complementos, fixos ou flutuantes, binários ou decimais. Isso pode dificultar o intercâmbio entre diferentes linguagens de programação. Em vez disso, o JSON oferece apenas a representação dos números que os humanos usam: uma sequência de dígitos. Todas as linguagens de programação sabem como entender seqüências de dígitos, mesmo que discordem das representações internas. Isso é suficiente para permitir o intercâmbio.

Portanto, é realmente preciso representar decimais como números (em vez de cadeias) em JSON. Abaixo está uma possível solução para o problema.

Defina um codificador JSON customizado:

import json


class CustomJsonEncoder(json.JSONEncoder):

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

Em seguida, use-o ao serializar seus dados:

json.dumps(data, cls=CustomJsonEncoder)

Conforme observado nos comentários sobre as outras respostas, as versões mais antigas do python podem atrapalhar a representação ao converter para float, mas esse não é mais o caso.

Para recuperar o decimal em Python:

Decimal(str(value))

Esta solução é sugerida na documentação do Python 3.0 em decimais :

Para criar um decimal de um flutuador, primeiro converta-o em uma string.

Isto é o que eu tenho, extraído da nossa 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)

Que passa mais 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)

Você pode criar um codificador JSON customizado conforme sua exigência.

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)

O decodificador pode ser chamado assim,

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

e a saída será:

>>'{"x": 3.9}'

Para aqueles que não querem usar uma biblioteca de terceiros ... Um problema com a resposta de Elias Zamaria é que ele se converte em flutuante, o que pode gerar problemas. Por exemplo:

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

O JSONEncoder.encode()método permite retornar o conteúdo literal do json, ao contrário do JSONEncoder.default()que você devolve um tipo compatível com o json (como float) que é codificado da maneira normal. O problema encode()é que (normalmente) funciona apenas no nível superior. Mas ainda é utilizável, com um pouco de trabalho 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)

O que lhe dá:

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

Com base na resposta stdOrgnlDave , defini este wrapper que pode ser chamado com tipos opcionais, para que o codificador funcione apenas para certos tipos dentro de seus projetos. Eu acredito que o trabalho deve ser feito dentro do seu código e não para usar esse codificador "padrão", pois "é melhor explícito do que implícito", mas eu entendo que isso poupará seu 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 você deseja passar um dicionário contendo casas decimais para a requestsbiblioteca (usando o jsonargumento de palavra - chave), basta 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')})

O motivo do problema é que ele é requestsusado simplejsonapenas se estiver presente e volta ao incorporado jsonse não estiver instalado.

isso pode ser feito adicionando

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

no \Lib\json\encoder.py:JSONEncoder._iterencode, mas eu estava esperando por uma solução melhor