Format de flotteurs avec la norme module json

Je suis en utilisant le standard module json en python 2.6 pour sérialiser une liste de chars. Cependant, je suis à l'obtention de résultats comme ceci:

>>> import json
>>> json.dumps([23.67, 23.97, 23.87])
'[23.670000000000002, 23.969999999999999, 23.870000000000001]'

Je veux la flotte à être formaté avec seulement deux chiffres après la virgule. La sortie devrait ressembler à ceci:

>>> json.dumps([23.67, 23.97, 23.87])
'[23.67, 23.97, 23.87]'

J'ai essayé de définir ma propre JSON Codeur classe:

class MyEncoder(json.JSONEncoder):
    def encode(self, obj):
        if isinstance(obj, float):
            return format(obj, '.2f')
        return json.JSONEncoder.encode(self, obj)

Cela fonctionne pour un seul objet float:

>>> json.dumps(23.67, cls=MyEncoder)
'23.67'

Mais ne parvient pas pour les objets imbriqués:

>>> json.dumps([23.67, 23.97, 23.87])
'[23.670000000000002, 23.969999999999999, 23.870000000000001]'

Je ne veux pas avoir de dépendances externes, donc je préfère m'en tenir à la norme json module.

Comment puis-je y parvenir?

OriginalL'auteur Manuel Ceron | 2009-09-19

70

Malheureusement, je crois que vous avez à faire ce singe de correction (qui, à mon avis, indique un défaut de conception dans la bibliothèque standard json package). E. g., ce code:
```
import json
from json import encoder
encoder.FLOAT_REPR = lambda o: format(o, '.2f')

print json.dumps(23.67)
print json.dumps([23.67, 23.97, 23.87])
```
émet:
```
23.67
[23.67, 23.97, 23.87]
```
que vous le désirez. Évidemment, il ne devrait être conçue de manière à remplacer FLOAT_REPR de sorte que TOUTE représentation d'un flotteur est sous votre contrôle si vous le souhaitez; mais, malheureusement, ce n'est pas la façon dont le json paquet a été conçu:-(.

Cette solution ne fonctionne pas dans Python 2.7 à l'aide de Python est la version C du JSON de l'encodeur.
Cependant vous le faites, utilisez quelque chose comme %.15g ou %.12g au lieu de %.3f .
J'ai trouvé cet extrait de code dans un programmeur junior du code. Cela aurait créé un très grave mais bug subtil si elle n'avait pas été pris. Pouvez vous s'il vous plaît placer une alerte sur ce code d'expliquer les implications globales de ce monkey patching.
C'est une bonne hygiène de régler lorsque vous avez terminé: original_float_repr = encoder.FLOAT_REPR encoder.FLOAT_REPR = lambda o: format(o, '.2f') print json.dumps(1.0001) encoder.FLOAT_REPR = original_float_repr
en python 3, cela ne fonctionne plus

OriginalL'auteur Alex Martelli
56
```
import simplejson

class PrettyFloat(float):
    def __repr__(self):
        return '%.15g' % self

def pretty_floats(obj):
    if isinstance(obj, float):
        return PrettyFloat(obj)
    elif isinstance(obj, dict):
        return dict((k, pretty_floats(v)) for k, v in obj.items())
    elif isinstance(obj, (list, tuple)):
        return map(pretty_floats, obj)  # in Python3 do: list(map(pretty_floats, obj))
    return obj

print simplejson.dumps(pretty_floats([23.67, 23.97, 23.87]))
```
émet
```
[23.67, 23.97, 23.87]
```
Pas monkeypatching nécessaire.

J'aime cette solution; une meilleure intégration, et travaille avec 2.7. Parce que je suis bâtiment de données moi-même de toute façon, j'ai éliminé le pretty_floats fonction et simplement intégré dans mon code.
En Python3 il donne "la Carte de l'objet n'est pas JSON serializable" erreur, mais vous pouvez résoudre la conversion de la carte() pour une liste avec list( map(pretty_floats, obj) )
c'est parce que dans Python 3 map retourne un itérateur, pas un list
Ne fonctionne pas pour moi (Python 3.5.2, simplejson 3.16.0). Essayé avec de l' %.6g et [23.671234556, 23.971234556, 23.871234556], elle affiche toujours le nombre entier.

OriginalL'auteur Tom Wuttke
25

Si vous êtes à l'aide de Python 2.7, une solution simple est de simplement faire le tour de votre flotte explicitement à la précision souhaitée.
```
>>> sys.version
'2.7.1 (r271:86832, Nov 27 2010, 18:30:46) [MSC v.1500 32 bit (Intel)]'
>>> json.dumps(1.0/3.0)
'0.3333333333333333'
>>> json.dumps(round(1.0/3.0, 2))
'0.33'
```
Cela fonctionne parce que Python 2.7 fait flotteur arrondissement plus cohérente. Malheureusement, cela ne fonctionne pas dans la version 2.6 de Python:
```
>>> sys.version
'2.6.6 (r266:84292, Dec 27 2010, 00:02:40) \n[GCC 4.4.5]'
>>> json.dumps(round(1.0/3.0, 2))
'0.33000000000000002'
```
Les solutions mentionnées ci-dessus sont des solutions de contournement pour 2.6, mais aucun n'est tout à fait suffisante. Monkey patching json.codeur.FLOAT_REPR ne fonctionne pas si votre exécution Python utilise une version C du module JSON. Le PrettyFloat classe en la personne de Tom Wuttke la réponse de travaux, mais seulement si %g encodage fonctionne à l'échelle mondiale pour votre application. L' %.15g est un peu magique, ça marche parce que la précision est de 17 chiffres significatifs et %g ne pas imprimer des zéros à la fin.

J'ai passé du temps à essayer de faire un PrettyFloat qui a permis de personnalisation de précision pour chaque numéro. C'est à dire, une syntaxe comme
```
>>> json.dumps(PrettyFloat(1.0 / 3.0, 4))
'0.3333'
```
Il n'est pas facile à obtenir ce droit. Héritant de flotteur est maladroit. Héritant de l'Objet et à l'aide d'un JSONEncoder sous-classe avec son propre défaut() la méthode devrait fonctionner, sauf le module json semble assumer tous les types personnalisés devrait être sérialisé comme des chaînes de caractères. C'est à dire: vous vous retrouvez avec le Javascript chaîne "0.33" dans la sortie, pas le nombre de 0,33. Il y a peut être un moyen pour le moment de faire ce travail, mais il est plus difficile qu'il n'y paraît.

Une autre approche pour la version 2.6 de Python à l'aide de JSONEncoder.iterencode et le filtrage peut être vu dans le github.com/migurski/LilJSON/blob/master/liljson.py
Espérons que cela fait passer autour de votre flotte plus léger - j'aime la façon dont nous pouvons éviter de jouer avec le JSON classes qui peut sucer.

OriginalL'auteur Nelson
12

Vraiment regrettable que dumps ne vous autorise pas à faire n'importe quoi à flotteurs. Cependant loads. Donc, si vous n'avez pas l'esprit de l'extra charge CPU, vous pouvez le jeter à travers le codeur/décodeur/encodeur et obtenir le bon résultat:
```
>>> json.dumps(json.loads(json.dumps([.333333333333, .432432]), parse_float=lambda x: round(float(x), 3)))
'[0.333, 0.432]'
```
Merci, c'est vraiment utile. Je ne savais pas à propos de la parse_float kwarg!
Le plus simple suggestion ici qui travaille également en 3.6.
Note l'expression "ne pas l'esprit de la CPU en plus de la charge". Certainement ne pas utiliser cette solution si vous avez beaucoup de données à sérialiser. Pour moi, l'ajout de ce seul fait un programme en faisant un non-trivial de calcul prendre 3X plus longtemps.

OriginalL'auteur Claude

Si vous êtes coincé avec Python 2.5 ou des versions antérieures: Le singe-patch astuce ne semble pas fonctionner avec l'original simplejson module si le C accélérations sont installés:

$ python
Python 2.5.4 (r254:67916, Jan 20 2009, 11:06:13) 
[GCC 4.2.1 (SUSE Linux)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import simplejson
>>> simplejson.__version__
'2.0.9'
>>> simplejson._speedups
<module 'simplejson._speedups' from '/home/carlos/.python-eggs/simplejson-2.0.9-py2.5-linux-i686.egg-tmp/simplejson/_speedups.so'>
>>> simplejson.encoder.FLOAT_REPR = lambda f: ("%.2f" % f)
>>> simplejson.dumps([23.67, 23.97, 23.87])
'[23.670000000000002, 23.969999999999999, 23.870000000000001]'
>>> simplejson.encoder.c_make_encoder = None
>>> simplejson.dumps([23.67, 23.97, 23.87])
'[23.67, 23.97, 23.87]'
>>>

OriginalL'auteur Carlos Valiente

7

Vous pouvez faire ce que vous devez faire, mais il n'est pas documenté:
```
>>> import json
>>> json.encoder.FLOAT_REPR = lambda f: ("%.2f" % f)
>>> json.dumps([23.67, 23.97, 23.87])
'[23.67, 23.97, 23.87]'
```
L'air soigné, mais semble ne pas fonctionner sur Python 3.6. En particulier, je n'ai pas vu un FLOAT_REPR constante dans le json.encoder module.

OriginalL'auteur Ned Batchelder

Voici une solution qui a fonctionné pour moi en Python 3 et ne nécessite pas de monkey patching:

import json

def round_floats(o):
    if isinstance(o, float): return round(o, 2)
    if isinstance(o, dict): return {k: round_floats(v) for k, v in o.items()}
    if isinstance(o, (list, tuple)): return [round_floats(x) for x in o]
    return o


json.dumps(round_floats([23.63437, 23.93437, 23.842347]))

De sortie est:

[23.63, 23.93, 23.84]

Il copie les données, mais avec des arrondis de flotteurs.

OriginalL'auteur jcoffland

Alex Martelli est la solution pour les mono-thread applications, mais peut ne pas fonctionner pour le multi-thread applications qui ont besoin de contrôler le nombre de décimales par thread. Voici une solution qui devrait fonctionner en multi threaded apps:

import threading
from json import encoder

def FLOAT_REPR(f):
    """
    Serialize a float to a string, with a given number of digits
    """
    decimal_places = getattr(encoder.thread_local, 'decimal_places', 0)
    format_str = '%%.%df' % decimal_places
    return format_str % f

encoder.thread_local = threading.local()
encoder.FLOAT_REPR = FLOAT_REPR     

#As an example, call like this:
import json

encoder.thread_local.decimal_places = 1
json.dumps([1.56, 1.54]) #Should result in '[1.6, 1.5]'

Vous pouvez simplement définir l'encodeur.thread_local.decimal_places pour le nombre de décimales que vous souhaitez, et le prochain appel à json.décharges() dans ce thread va utiliser que le nombre de décimales

OriginalL'auteur Anton I. Sipos

Si vous avez besoin de le faire en python 2.7 sans écraser le mondial json.codeur.FLOAT_REPR, voici un moyen.

import json
import math

class MyEncoder(json.JSONEncoder):
    "JSON encoder that renders floats to two decimal places"

    FLOAT_FRMT = '{0:.2f}'

    def floatstr(self, obj):
        return self.FLOAT_FRMT.format(obj)

    def _iterencode(self, obj, markers=None):
        # stl JSON lame override #1
        new_obj = obj
        if isinstance(obj, float):
            if not math.isnan(obj) and not math.isinf(obj):
                new_obj = self.floatstr(obj)
        return super(MyEncoder, self)._iterencode(new_obj, markers=markers)

    def _iterencode_dict(self, dct, markers=None):
        # stl JSON lame override #2
        new_dct = {}
        for key, value in dct.iteritems():
            if isinstance(key, float):
                if not math.isnan(key) and not math.isinf(key):
                    key = self.floatstr(key)
            new_dct[key] = value
        return super(MyEncoder, self)._iterencode_dict(new_dct, markers=markers)

Puis, dans python 2.7:

>>> from tmp import MyEncoder
>>> enc = MyEncoder()
>>> enc.encode([23.67, 23.98, 23.87])
'[23.67, 23.98, 23.87]'

En python 2.6, il ne fonctionne pas comme Matthieu Schinckel points ci-après:

>>> import MyEncoder
>>> enc = MyEncoder()  
>>> enc.encode([23.67, 23.97, 23.87])
'["23.67", "23.97", "23.87"]'

Ceux qui ressemblent à des cordes, pas des numéros.
Cela fonctionne à tous les niveaux d'imbrication?

OriginalL'auteur Mike Fogel

Pour:

Fonctionne avec n'importe quel JSON codeur, ou encore python repr.
Court(ish), semble fonctionner.

Contre:

Laid regexp hack, à peine testé.

Complexité quadratique.

def fix_floats(json, decimals=2, quote='"'):
    pattern = r'^((?:(?:"(?:\\.|[^\\"])*?")|[^"])*?)(-?\d+\.\d{'+str(decimals)+'}\d+)'
    pattern = re.sub('"', quote, pattern) 
    fmt = "%%.%df" % decimals
    n = 1
    while n:
        json, n = re.subn(pattern, lambda m: m.group(1)+(fmt % float(m.group(2)).rstrip('0')), json)
    return json

OriginalL'auteur Sam Watkins

1

Lors de l'importation de la norme json d'un module, il suffit de changer la valeur par défaut codeur FLOAT_REPR. Il n'est pas vraiment la nécessité d'importer ou de créer de l'Encodeur instances.
```
import json
json.encoder.FLOAT_REPR = lambda o: format(o, '.2f')

json.dumps([23.67, 23.97, 23.87]) #returns  '[23.67, 23.97, 23.87]'
```
Parfois est également très utile pour la sortie json la meilleure représentation de python peut deviner avec str. Cela permettra de s'assurer signifficant chiffres ne sont pas ignorés.
```
import json
json.dumps([23.67, 23.9779, 23.87489])
# output is'[23.670000000000002, 23.977900000000002, 23.874890000000001]'

json.encoder.FLOAT_REPR = str
json.dumps([23.67, 23.9779, 23.87489])
# output is '[23.67, 23.9779, 23.87489]'
```
OriginalL'auteur F Pereira

Je suis d'accord avec @Nelson, héritant de flotteur est un peu étrange, mais peut-être une solution qui ne touche que le __repr__ fonction peut être forgiveable. J'ai fini par utiliser la decimal paquet pour cette reformater flotteurs en cas de besoin. L'avantage est que cela fonctionne dans tous les contextes où repr() est appelé, de même aussi quand simplement l'impression des listes de stdout par exemple. Aussi, la précision est d'exécution configurable, après la collecte de données a été créé. Inconvénient est bien sûr que vos données doivent être converties à cette classe integer (que malheureusement vous ne semblez pas à monkey patch float.__repr__). Pour que je lui fournisse une brève fonction de conversion.

Le code:

import decimal
C = decimal.getcontext()

class decimal_formatted_float(float):
   def __repr__(self):
       s = str(C.create_decimal_from_float(self))
       if '.' in s: s = s.rstrip('0')
       return s

def convert_to_dff(elem):
    try:
        return elem.__class__(map(convert_to_dff, elem))
    except:
        if isinstance(elem, float):
            return decimal_formatted_float(elem)
        else:
            return elem

Exemple d'utilisation:

>>> import json
>>> li = [(1.2345,),(7.890123,4.567,890,890.)]
>>>
>>> decimal.getcontext().prec = 15
>>> dff_li = convert_to_dff(li)
>>> dff_li
[(1.2345,), (7.890123, 4.567, 890, 890)]
>>> json.dumps(dff_li)
'[[1.2345], [7.890123, 4.567, 890, 890]]'
>>>
>>> decimal.getcontext().prec = 3
>>> dff_li = convert_to_dff(li)
>>> dff_li
[(1.23,), (7.89, 4.57, 890, 890)]
>>> json.dumps(dff_li)
'[[1.23], [7.89, 4.57, 890, 890]]'

OriginalL'auteur user1556435

Vous devez vous connecter pour publier un commentaire.