Facile jolie impression de flotteurs en python?
J'ai une liste de flotteurs. Si je simplement print cela, il se présente comme ceci:
[9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
Je pourrais utiliser print "%.2f", qui nécessiterait une boucle for pour parcourir la liste, mais cela ne fonctionnerait pas pour des structures de données plus complexes. Je voudrais quelque chose comme (je suis complètement inventer cela)
>>> 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]
C'est une vieille question mais j'ajouterais quelque chose de potentiellement utile:
Je sais que vous avez écrit votre exemple dans les listes raw Python, mais si vous décidez d'utiliser plutôt les tableaux numpy (ce qui serait parfaitement légitime dans votre exemple, car vous semblez avoir affaire à avec des tableaux de nombres), il y a (presque exactement) cette commande que vous avez dite avoir composée:
import numpy as np
np.set_printoptions(precision=2)
Ou encore mieux dans votre cas si vous voulez toujours voir toutes les décimales de nombres très précis, mais vous débarrasser des zéros de fin par exemple, utilisez la chaîne de mise en forme %g:
np.set_printoptions(formatter={"float_kind": lambda x: "%g" % x})
Pour seulement imprimer une fois et ne pas changer le comportement global, utilisez np.array2string avec les mêmes arguments que ci-dessus.
Comme personne ne l'a ajouté, il est à noter qu'avant Python 2.6+, la méthode recommandée pour faire formater une chaîne) est avec format , pour se préparer à Python 3+.
print ["{0:0.2f}".format(i) for i in a]
Le nouveasyntaxe de formatage de chaîne n'est pas difficile à utiliser, et pourtant, il est assez puissant.
Je pensais que cela pouvait être pprint pourrait avoir quelque chose, mais je n'ai rien trouvé.
Une solution plus permanente consiste à sous-classe 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 qu’il casse le code qui recherche explicitement le type d’une variable. Mais pour autant que je sache, c'est le seul problème. Et un simple x = map(float, x) annule la conversion en prettyfloat.
Tragiquement, vous ne pouvez pas simplement monkey-patch float.__repr__, Car float est immuable.
Si vous ne voulez pas sous-classer float, mais que la définition d'une fonction ne vous dérange pas, map(f, x) est beaucoup plus concis que [f(n) for n in x]
Tu peux faire:
a = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
print ["%0.2f" % i for i in a]
Notez que vous pouvez également multiplier une chaîne telle que "% .2f" (exemple: "% .2f" * 10).
>>> print "%.2f "*len(yourlist) % Tuple(yourlist)
2.00 33.00 4.42 0.31
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]
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))
Ceci 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]
Je pense que Python 3.1 les imprimera plus agréablement par défaut, sans 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
l = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
Python 2:
print ', '.join('{:0.2f}'.format(i) for i in l)
Python 3:
print(', '.join('{:0.2f}'.format(i) for i in l))
Sortie:
9.00, 0.05, 0.03, 0.01, 0.06, 0.08
Liste comps 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
Vous pourriez utiliser des pandas.
Voici un exemple avec une liste:
In: import pandas as P
In: P.set_option('display.precision',3)
In: L = [3.4534534, 2.1232131, 6.231212, 6.3423423, 9.342342423]
In: P.Series(data=L)
Out:
0 3.45
1 2.12
2 6.23
3 6.34
4 9.34
dtype: float64
Si vous avez un dict d et que vous voulez ses clés sous forme de lignes:
In: d
Out: {1: 0.453523, 2: 2.35423234234, 3: 3.423432432, 4: 4.132312312}
In: P.DataFrame(index=d.keys(), data=d.values())
Out:
0
1 0.45
2 2.35
3 3.42
4 4.13
Et une autre façon de donner dict à un DataFrame:
P.DataFrame.from_dict(d, orient='index')
Je viens de rencontrer ce problème en essayant d'utiliser pprint pour générer une liste de nuplets de flottants. Les compréhensions imbriquées peuvent être une mauvaise idée, mais voici ce que j'ai fait:
tups = [
(12.0, 9.75, 23.54),
(12.5, 2.6, 13.85),
(14.77, 3.56, 23.23),
(12.0, 5.5, 23.5)
]
pprint([['{0:0.02f}'.format(num) for num in tup] for tup in tups])
J'ai utilisé les expressions du générateur au début, mais pprint vient de réprimander le générateur ...
Tout d'abord, les éléments d'une collection impriment leur repr. vous devriez en apprendre davantage sur __repr__ et __str__.
C'est la différence entre print repr (1.1) et print 1.1. Joignons toutes ces chaînes au lieu des représentations:
numbers = [9.0, 0.053, 0.0325754, 0.0108928, 0.0557025, 0.07933]
print "repr:", " ".join(repr(n) for n in numbers)
print "str:", " ".join(str(n) for n in numbers)
Pour contrôler le nombre de chiffres significatifs , utilisez le spécificateur de format% g.
Appelons la solution prettylist2f d'Emile. Voici le modifié:
prettylist2g = lambda l : '[%s]' % ', '.join("%.2g" % x for x in l)
Usage:
>>> c_e_alpha_eps0 = [299792458., 2.718281828, 0.00729735, 8.8541878e-12]
>>> print(prettylist2f(c_e_alpha_eps0)) # [299792458.00, 2.72, 0.01, 0.00]
>>> print(prettylist2g(c_e_alpha_eps0)) # [3e+08, 2.7, 0.0073, 8.9e-12]
Si vous voulez plus de flexibilité dans le nombre de chiffres significatifs, utilisez plutôt formatage de chaîne de caractères :
prettyflexlist = lambda p, l : '[%s]' % ', '.join(f"{x:.{p}}" for x in l)
print(prettyflexlist(3,c_e_alpha_eps0)) # [3e+08, 2.72, 0.0073, 8.85e-12]
J'ai eu ce problème, mais aucune des solutions ici n'a exactement ce que je voulais (je veux que la sortie imprimée soit une expression python valide) valide, alors que diriez-vous de cela :
prettylist = lambda l : '[%s]' % ', '.join("%.2f" % f for f in l)
Usage:
>>> ugly = [9.0, 0.052999999999999999, 0.032575399999999997,
0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
>>> prettylist = lambda l : '[%s]' % ', '.join("%.2f" % f for f in l)
>>> print prettylist(ugly)
[9.00, 0.05, 0.03, 0.01, 0.06, 0.08]
(Je sais que .format () est supposé être la solution la plus standard, mais je trouve cela plus lisible)
À partir de Python 3.6, vous pouvez utiliser des chaînes de caractères f:
list_ = [9.0, 0.052999999999999999,
0.032575399999999997, 0.010892799999999999,
0.055702500000000002, 0.079330300000000006]
print(*[f"{element:.2f}" for element in list_])
#9.00 0.05 0.03 0.01 0.06 0.08
Vous pouvez utiliser les paramètres d'impression tout en maintenant le code très lisible:
print(*[f"{element:.2f}" for element in list_], sep='|', end='<--')
#9.00|0.05|0.03|0.01|0.06|0.08<--
Le code ci-dessous fonctionne bien pour moi.
list = map (lambda x: float('%0.2f' % x), list)