Question Jolie impression facile des flotteurs en python?


J'ai une liste de flotteurs. Si je me contente de print ça se voit comme ça:

[9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]

je pourrais utiliser print "%.2f", ce qui nécessiterait un for loop pour parcourir la liste, mais cela ne fonctionnerait pas pour des structures de données plus complexes. Je voudrais quelque chose comme (je invente complètement)

>>> import print_options
>>> print_options.set_float_precision(2)
>>> print [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
[9.0, 0.05, 0.03, 0.01, 0.06, 0.08]

66
2017-10-14 15:07


origine


Réponses:


C'est une vieille question mais j'ajouterais quelque chose de potentiellement utile:

Je sais que vous avez écrit votre exemple dans des listes Python brutes, mais si vous décidez d'utiliser numpy des tableaux à la place (ce qui serait parfaitement légitime dans votre exemple, car vous semblez avoir affaire à des tableaux de nombres), il y a (presque) exactement cette commande que vous dites avoir créée:

import numpy as np
np.set_printoptions(precision=2)

Ou encore mieux dans votre cas, si vous voulez toujours voir tous les nombres décimaux de nombres vraiment précis, mais vous débarrasser de zéros par exemple, utilisez la chaîne de formatage %g:

np.set_printoptions(formatter={"float_kind": lambda x: "%g" % x})

Pour imprimer simplement une fois et ne pas modifier le comportement global, utilisez np.array2string avec les mêmes arguments que ci-dessus.


6
2018-05-03 11:37



Comme personne ne l'a ajouté, il convient de noter qu'à partir de Python 2.6+, la méthode recommandée est la suivante: chaîne de formage est avec format, pour se préparer à Python 3+.

print ["{0:0.2f}".format(i) for i in a]

Le nouveau  syntaxe de formage de chaîne n'est pas difficile à utiliser, et pourtant tout à fait puissant.

Je pensais que cela pourrait être pprint pourrait avoir quelque chose, mais je n'ai rien trouvé.


74
2017-10-14 15:41



Une solution plus permanente consiste à sous-classer float:

>>> class prettyfloat(float):
    def __repr__(self):
        return "%0.2f" % self

>>> x
[1.290192, 3.0002, 22.119199999999999, 3.4110999999999998]
>>> x = map(prettyfloat, x)
>>> x
[1.29, 3.00, 22.12, 3.41]
>>> y = x[2]
>>> y
22.12

Le problème avec le sous-classement float est que cela casse le code qui recherche explicitement le type d'une variable. Mais pour autant que je sache, c'est le seul problème avec ça. Et un simple x = map(float, x) défait la conversion en prettyfloat.

Tragiquement, vous ne pouvez pas simplement patch-singe float.__repr__, car floatest immuable.

Si vous ne voulez pas sous-classe float, mais ne craignez pas de définir une fonction, map(f, x) est beaucoup plus concis que [f(n) for n in x]


67
2017-10-14 16:57



Tu peux faire:

a = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
print ["%0.2f" % i for i in a]

37
2017-10-14 15:12



Notez que vous pouvez également multiplier une chaîne comme "% .2f" (exemple: "% .2f" * 10).

>>> print "%.2f "*len(yourlist) % tuple(yourlist)
2.00 33.00 4.42 0.31 

20
2017-10-14 15:10



print "[%s]"%", ".join(map(str,yourlist))

Cela évitera les erreurs d’arrondi dans la représentation binaire lors de l’impression, sans introduire de contrainte de précision fixe (comme formater avec "%.2f"):

[9.0, 0.053, 0.0325754, 0.0108928, 0.0557025, 0.0793303]

8
2017-10-14 15:20



Je pense que Python 3.1 les imprimera plus facilement par défaut, sans aucun changement de code. Mais cela est inutile si vous utilisez des extensions qui n'ont pas été mises à jour pour fonctionner avec Python 3.1


4
2017-10-14 15:15



Les comps de liste sont votre ami.

print ", ".join("%.2f" % f for f in list_o_numbers)

Essayez-le:

>>> nums = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999]
>>> print ", ".join("%.2f" % f for f in nums)
9.00, 0.05, 0.03, 0.01

4
2017-10-14 15:11



L'option la plus facile devrait être d'utiliser une routine d'arrondi:

import numpy as np
x=[9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]

print('standard:')
print(x)
print("\nhuman readable:")
print(np.around(x,decimals=2))

Cela produit la sortie:

standard:
[9.0, 0.053, 0.0325754, 0.0108928, 0.0557025, 0.0793303]

human readable:
[ 9.    0.05  0.03  0.01  0.06  0.08]

4
2017-11-14 13:29