Python JSON, Ondalık bir nesne serileştiriyor

Decimal('3.9')Bir nesnenin bir parçası olarak var ve bu gibi olması gereken bir JSON dizesine kodlamak istiyoruz {'x': 3.9}. Müşteri tarafında hassasiyet umurumda değil, bu yüzden bir şamandıra iyi.

Bunu serileştirmenin iyi bir yolu var mı? JSONDecoder Ondalık nesneleri kabul etmez ve önceden bir kayan noktaya dönüştürmek {'x': 3.8999999999999999}yanlıştır ve büyük bir bant genişliği kaybı olur.

Alt sınıflamaya ne dersiniz 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)

Sonra şöyle kullanın:

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

Simplejson 2.1 ve üstü, Ondalık tip için yerel desteğe sahiptir:

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

Not use_decimalolduğu Truevarsayılan:

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

Yani:

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

Umarım, bu özellik standart kütüphaneye dahil edilecektir.

Python 2.6.5 çalıştıran web sunucumda Michał Marczyk'in yanıtını denediğimi herkese bildirmek istiyorum ve iyi çalıştı. Ancak, Python 2.7'ye geçtim ve çalışmayı durdurdu. Ondalık nesneleri kodlamak için bir tür düşünmeye çalıştım ve bu ile geldi:

import decimal

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

Bu, Python 2.7 ile sorun yaşayan herkese yardımcı olacaktır. Test ettim ve iyi çalışıyor gibi görünüyor. Birisi benim çözümümde herhangi bir hata fark ederse veya daha iyi bir yol bulursa, lütfen bana bildirin.

Python 2.7.11, Flask simya ('db.decimal' türleri ile) ve Flask Marshmallow ('anlık' serileştirici ve serileştirici için) kullanan Flask uygulamamda, her hata aldığımda bu hatayı aldım . Serileştirici ve serileştirici, Ondalık türleri herhangi bir JSON tanımlanabilir biçime dönüştüremedi.

Bir "pip install simplejson" yaptım, sonra sadece ekleyerek

import simplejson as json

serileştirici ve serileştirici yeniden akmaya başlar. Başka bir şey yapmadım ... DEciamls '234.00' şamandıra formatında gösterilir.

GAE 2.7 için simplejson'dan built json'a geçmeyi denedim ve ondalık sayıyla ilgili sorunlar yaşadım. Varsayılan str (o) döndürürse, tırnak işaretleri vardı (çünkü _iterencode varsayılan sonuçlarda _iterencode'u çağırır) ve float (o) izleyen 0'ı kaldıracaktır.

Varsayılan, float'tan (veya ek biçimlendirme olmadan repr'yi çağıran herhangi bir şeyden) ve özel __repr__ yöntemine sahip bir sınıfın nesnesini döndürürse, istediğim gibi çalışıyor gibi görünüyor.

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

Yerel seçeneği eksik, bu yüzden onu arayan bir sonraki adam / safra için ekleyeceğim.

Django 1.7.x sürümünden itibaren DjangoJSONEncoderbunu alabileceğiniz bir yerleşik var 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!

Benim $ 02!

Web sunucum için tonlarca veri serileştirdiğim için bir sürü JSON kodlayıcıyı genişletiyorum. İşte güzel bir kod. Hissettiğiniz herhangi bir veri formatına kolayca genişletilebilir ve 3.9"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

Hayatımı çok kolaylaştırıyor ...

3.9IEEE şamandıralarında tam olarak temsil edilemez, her zaman olduğu gibi gelecektir 3.8999999999999999, örneğin deneyin print repr(3.9), buradan daha fazla bilgi edinebilirsiniz:

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

Bu nedenle, kayan nokta istemiyorsanız, yalnızca dize olarak göndermeniz ve ondalık nesnelerin JSON'a otomatik olarak dönüştürülmesine izin vermeniz için aşağıdaki gibi bir şey yapın:

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)

Django kullanıcıları için :

Geçenlerde TypeError: Decimal('2337.00') is not JSON serializable JSON kodlama yanijson.dumps(data)

Çözüm :

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

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

Ama şimdi Ondalık değeri kullanarak, verileri deşifre zaman şimdi biz açıkça ondalık / şamandıra değeri ayrıştırıcı ayarlayabilirsiniz, bir dize olacaktır parse_floatseçeneği json.loads:

import decimal 

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

Gönderen JSON Standart Belgesi , bağlantılı olarak json.org :

JSON sayıların anlambilimi konusunda agnostiktir. Herhangi bir programlama dilinde, sabit veya değişken, ikili veya ondalık sayılarda çeşitli kapasitelerde ve tamamlayıcılarda çeşitli tipler olabilir. Bu, farklı programlama dilleri arasındaki değişimi zorlaştırabilir. Bunun yerine JSON yalnızca insanların kullandığı sayıların temsilini sunar: bir basamak dizisi. Tüm programlama dilleri, dahili gösterimlere katılmıyor olsalar bile, basamak dizilerinin nasıl anlamlandırılacağını bilir. Bu değiş tokuşa izin vermek için yeterlidir.

Dolayısıyla, ondalık sayıları JSON'da sayı (dize yerine) olarak göstermek doğrudur. Körük soruna olası bir çözümdür.

Özel bir JSON kodlayıcı tanımlayın:

import json


class CustomJsonEncoder(json.JSONEncoder):

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

Ardından verilerinizi serileştirirken kullanın:

json.dumps(data, cls=CustomJsonEncoder)

Diğer cevaplardaki yorumlardan da belirtildiği gibi, python'un eski sürümleri float'a dönüştürülürken temsili bozabilir, ancak artık durum böyle değil.

Python'da ondalığı geri almak için:

Decimal(str(value))

Bu çözüm ondalık sayılarla ilgili Python 3.0 belgelerinde belirtilmiştir :

Bir kayan noktadan bir Ondalık oluşturmak için önce onu bir dizeye dönüştürün.

Sınıfımdan çıkarılan şey bu

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)

Birim testi geçen:

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)

Gereksiniminize göre özel bir JSON kodlayıcı oluşturabilirsiniz.

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)

Dekoder bu şekilde çağrılabilir,

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

ve çıktı:

>>'{"x": 3.9}'

Üçüncü taraf bir kütüphane kullanmak istemeyenler için ... Elias Zamaria'nın cevabı ile ilgili bir sorun, şamandıraya dönüşmesi ve sorunlara yol açmasıdır. Örneğin:

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

JSONEncoder.encode()Yöntem aksine sen, edebi json içeriği döndüren sağlar JSONEncoder.default()Eğer (şamandıra gibi) bir json uyumlu türü iade ettiği, daha sonra normal şekilde kodlanmış alır söyledi. Sorun, encode()(normalde) yalnızca en üst düzeyde çalışmasıdır. Ama biraz daha fazla çalışma ile hala kullanılabilir (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)

Hangi size verir:

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

StdOrgnlDave cevabına dayanarak , kodlayıcı sadece projelerinizdeki belirli türler için çalışacak şekilde isteğe bağlı türlerle çağrılabilecek bu sarmalayıcıyı tanımladım. İşin kodunuzun içinde yapılması gerektiğine ve bu "varsayılan" kodlayıcıyı kullanmaması gerektiğine inanıyorum, çünkü "örtükten daha iyi açıktır", ancak bunu kullanarak zaman kazanacağınızı anlıyorum. :-)

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

Ondalık içeren bir sözlüğü requestskütüphaneye aktarmak istiyorsanız ( jsonanahtar kelime bağımsız değişkenini kullanarak ), yüklemeniz yeterlidir 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')})

Sorunun nedeni olmasıdır requestskullandığı simplejsonMevcut olması halinde, geri yerleşik düşüyor jsoneğer yüklü değil.

bu ekleyerek yapılabilir

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

içinde \Lib\json\encoder.py:JSONEncoder._iterencode, ama daha iyi bir çözüm için umuyordum