Python JSON ทำให้เป็นวัตถุฐานสิบ

ฉันมีDecimal('3.9')เป็นส่วนหนึ่งของวัตถุและต้องการการเข้ารหัสนี้ให้สตริง JSON {'x': 3.9}ซึ่งควรมีลักษณะดังนี้ ฉันไม่สนใจเกี่ยวกับความแม่นยำในฝั่งไคลเอ็นต์ดังนั้นการลอยก็ดี

มีวิธีที่ดีในการทำให้เป็นอนุกรมนี้หรือไม่ JSONDecoder ไม่ยอมรับวัตถุทศนิยมและแปลงเป็นทศนิยมก่อนหน้าให้ผลตอบแทน{'x': 3.8999999999999999}ที่ผิดและจะเสียแบนด์วิดท์ขนาดใหญ่

วิธีการเกี่ยวกับ subclassing 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)

จากนั้นใช้งานเช่น:

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

Simplejson 2.1ขึ้นไปมีการรองรับเนทิฟสำหรับประเภททศนิยม:

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

ทราบว่าuse_decimalเป็นTrueค่าเริ่มต้น:

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

ดังนั้น:

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

หวังว่าคุณสมบัตินี้จะรวมอยู่ในห้องสมุดมาตรฐาน

ฉันต้องการให้ทุกคนรู้ว่าฉันได้ลองคำตอบของMichał Marczyk บนเว็บเซิร์ฟเวอร์ของฉันที่ใช้ Python 2.6.5 และมันใช้งานได้ดี อย่างไรก็ตามฉันอัพเกรดเป็น Python 2.7 และหยุดทำงาน ฉันพยายามคิดวิธีเข้ารหัสรหัสทศนิยมและนี่คือสิ่งที่ฉันคิด:

import decimal

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

หวังว่านี่จะช่วยทุกคนที่มีปัญหากับ Python 2.7 ฉันทดสอบแล้วและดูเหมือนว่าจะทำงานได้ดี หากใครพบข้อผิดพลาดใด ๆ ในโซลูชันของฉันหรือหาวิธีที่ดีกว่าโปรดแจ้งให้เราทราบ

ในแอพ Flask ของฉันซึ่งใช้ python 2.7.11, alchemy flask (ด้วยประเภท 'db.decimal') และ Flask Marshmallow (สำหรับ serializer และ deserializer 'ทันที') ฉันมีข้อผิดพลาดนี้ทุกครั้งที่ฉันได้ GET หรือ POST . serializer และ deserializer ไม่สามารถแปลงชนิดทศนิยมให้เป็นรูปแบบที่ระบุได้ของ JSON

ฉันได้ "pip install simplejson" จากนั้นเพียงแค่เพิ่ม

import simplejson as json

serializer และ deserializer เริ่มเสียงฟี้อย่างแมวอีกครั้ง ฉันไม่ทำอะไรเลย ... DEciamls แสดงเป็นรูปแบบลอยตัว '234.00'

ฉันลองเปลี่ยนจาก simplejson เป็น builtin json สำหรับ GAE 2.7 และมีปัญหากับทศนิยม หากค่าเริ่มต้นส่งคืน str (o) มีเครื่องหมายคำพูด (เพราะ _iterencode เรียก _iterencode บนผลลัพธ์ของค่าเริ่มต้น) และ float (o) จะลบ 0 ต่อท้าย

ถ้าค่าเริ่มต้นส่งคืนวัตถุของคลาสที่สืบทอดมาจาก float (หรืออะไรก็ตามที่เรียกว่า repr โดยไม่ต้องจัดรูปแบบเพิ่มเติม) และมีเมธอด __repr__ ที่กำหนดเองดูเหมือนว่าจะทำงานเหมือนที่ฉันต้องการ

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

ตัวเลือกเนทิฟหายไปดังนั้นฉันจะเพิ่มสำหรับผู้ชายคนถัดไปที่ค้นหา

เริ่มตั้งแต่วันที่ Django 1.7.x มีในตัวที่คุณจะได้รับจากDjangoJSONEncoderdjango.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)

โอมเพี้ยง!

$ .02 ของฉัน!

ฉันขยายโปรแกรมเข้ารหัสของ JSON เป็นจำนวนมากเนื่องจากฉันจัดลำดับข้อมูลเป็นตันสำหรับเว็บเซิร์ฟเวอร์ของฉัน นี่คือรหัสที่ดี โปรดทราบว่าสามารถขยายรูปแบบข้อมูลใด ๆ ที่คุณรู้สึกได้อย่างง่ายดายและจะสร้างเป็น 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

ทำให้ชีวิตของฉันง่ายขึ้นมาก ...

3.9ไม่สามารถแสดงได้อย่างแน่นอนใน IEEE ลอยตัวมันจะเกิดขึ้นเสมอ3.8999999999999999เช่นลอง print repr(3.9)คุณสามารถอ่านเพิ่มเติมได้ที่นี่:

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

ดังนั้นหากคุณไม่ต้องการโฟลตมีเพียงตัวเลือกเดียวเท่านั้นที่คุณต้องส่งเป็นสตริงและเพื่อให้สามารถแปลงวัตถุทศนิยมให้เป็น JSON โดยอัตโนมัติให้ทำดังนี้:

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 :

เพิ่งเจอกันTypeError: Decimal('2337.00') is not JSON serializable ในขณะที่การเข้ารหัส JSON เช่นjson.dumps(data)

วิธีแก้ปัญหา :

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

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

แต่ตอนนี้ค่าทศนิยมจะเป็นสตริงตอนนี้เราสามารถตั้งค่าตัวแยกวิเคราะห์ทศนิยม / ทศนิยมอย่างชัดเจนเมื่อถอดรหัสข้อมูลโดยใช้parse_floatตัวเลือกในjson.loads:

import decimal 

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

จากเอกสารมาตรฐาน JSONดังที่ลิงก์ในjson.org :

JSON ไม่เชื่อเรื่องพระเจ้าเกี่ยวกับความหมายของตัวเลข ในภาษาการเขียนโปรแกรมใด ๆ อาจมีหลากหลายประเภทของความสามารถและความหลากหลายที่หลากหลายคงที่หรือลอยตัวไบนารีหรือทศนิยม ที่สามารถทำการแลกเปลี่ยนระหว่างภาษาการเขียนโปรแกรมที่แตกต่างกันได้ยาก JSON จะเสนอเฉพาะตัวเลขที่มนุษย์ใช้แทน: ลำดับของตัวเลข ภาษาการเขียนโปรแกรมทั้งหมดรู้วิธีทำให้ความรู้สึกของลำดับเลขแม้ว่าพวกเขาไม่เห็นด้วยกับการเป็นตัวแทนภายใน นั่นก็เพียงพอแล้วที่จะยอมให้มีการแลกเปลี่ยน

ดังนั้นจึงเป็นความจริงที่ถูกต้องในการแสดงทศนิยมเป็นตัวเลข (แทนที่จะเป็นสตริง) ใน JSON ซอลเบลโลว์คือคำตอบของปัญหาที่เป็นไปได้

กำหนดตัวเข้ารหัส JSON ที่กำหนดเอง:

import json


class CustomJsonEncoder(json.JSONEncoder):

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

จากนั้นใช้เมื่อทำการซีเรียลข้อมูลของคุณ:

json.dumps(data, cls=CustomJsonEncoder)

ตามที่ระบุไว้จากความคิดเห็นเกี่ยวกับคำตอบอื่น ๆ ไพ ธ อนรุ่นเก่าอาจเลอะการเป็นตัวแทนเมื่อแปลงเป็นลอย แต่นั่นไม่ใช่กรณีอีกต่อไป

เพื่อให้ได้ทศนิยมใน Python:

Decimal(str(value))

วิธีการแก้ปัญหานี้มีการพูดถึงในเอกสาร Python 3.0 เกี่ยวกับทศนิยม :

ในการสร้างทศนิยมจากทศนิยมก่อนอื่นให้แปลงเป็นสตริง

นี่คือสิ่งที่ฉันมีสกัดจากชั้นเรียนของเรา

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)

ซึ่งผ่านไปไม่ได้:

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)

คุณสามารถสร้างตัวเข้ารหัส JSON ที่กำหนดเองตามความต้องการของคุณ

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)

ตัวถอดรหัสสามารถถูกเรียกเช่นนี้

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

และผลลัพธ์จะเป็น:

>>'{"x": 3.9}'

สำหรับผู้ที่ไม่ต้องการใช้ห้องสมุดบุคคลที่สาม ... ปัญหาของคำตอบของอีเลียสซามาเรียก็คือมันแปลงเป็นแบบลอยซึ่งสามารถพบปัญหาได้ ตัวอย่างเช่น:

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

JSONEncoder.encode()วิธีช่วยให้คุณกลับเนื้อหา JSON ที่แท้จริงแตกต่างจากJSONEncoder.default()ที่ได้คุณกลับ JSON ชนิดเข้ากันได้ (เช่น float) ที่แล้วได้รับการเข้ารหัสในวิธีปกติ ปัญหาที่เกิดขึ้นกับencode()มันคือ (ปกติ) จะทำงานที่ระดับบนสุดเท่านั้น แต่ก็ยังใช้งานได้โดยมีงานพิเศษเล็กน้อย (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)

ซึ่งให้คุณ:

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

จากคำตอบstdOrgnlDaveฉันได้กำหนด wrapper นี้ว่ามันสามารถเรียกได้ด้วยชนิดที่เป็นทางเลือกดังนั้นตัวเข้ารหัสจะทำงานกับบางชนิดภายในโครงการของคุณเท่านั้น ฉันเชื่อว่างานควรทำภายในรหัสของคุณและไม่ควรใช้ตัวเข้ารหัส "ค่าเริ่มต้น" เนื่องจากดีกว่าชัดเจนกว่า "แต่ฉันเข้าใจว่าการใช้สิ่งนี้จะช่วยประหยัดเวลาของคุณได้ :-)

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

หากคุณต้องการส่งพจนานุกรมที่มีทศนิยมให้กับrequestsห้องสมุด (ใช้jsonอาร์กิวเมนต์คำหลัก) คุณเพียงแค่ต้องติดตั้ง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')})

สาเหตุของปัญหาคือการrequestsใช้simplejsonเฉพาะถ้ามันมีอยู่และกลับไปที่ในตัวjsonหากไม่ได้ติดตั้ง

สิ่งนี้สามารถทำได้โดยการเพิ่ม

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

ใน\Lib\json\encoder.py:JSONEncoder._iterencodeแต่ฉันหวังว่าจะได้ทางออกที่ดีกว่า