Jolie impression facile de flotteurs en python?

J'ai une liste de flotteurs. Si je le fais simplement print, cela se présente comme ceci:

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

Je pourrais utiliser print "%.2f", ce qui nécessiterait une forboucle pour parcourir la liste, mais cela ne fonctionnerait pas pour des structures de données plus complexes. J'aimerais quelque chose comme (j'invente complètement ça)

>>> 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 des listes Python brutes, mais si vous décidez d'utiliser des numpytableaux à 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 vous dit que tu as inventé:

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 vraiment précis, mais supprimez les 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 imprimer une seule fois et ne pas changer le comportement global, utilisez np.array2stringles mêmes arguments que ci-dessus.

Comme personne ne l'a ajouté, il convient de noter qu'à partir de Python 2.6+, la manière recommandée de formater une chaîne est avec format, pour se préparer pour Python 3+.

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

La nouvelle syntaxe de formatage de chaîne n'est pas difficile à utiliser, et pourtant elle est assez puissante.

Je pensais que ça pprintpouvait avoir quelque chose, mais je n'ai rien trouvé.

Une solution plus permanente consiste à sous float- classer :

>>> 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 float- classement est qu'il rompt 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 faire un patch de singe float.__repr__, car c'est floatimmuable.

Si vous ne voulez pas de sous float- classe , mais que la définition d'une fonction ne vous dérange pas, map(f, x)c'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 comme "% .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 le formatage avec "%.2f"):

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

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

Production:

9.00, 0.05, 0.03, 0.01, 0.06, 0.08

L'option la plus simple 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]

Je crois que Python 3.1 les imprimera mieux par défaut, sans aucun changement de code. Mais cela ne sert à rien si vous utilisez des extensions qui n'ont pas été mises à jour pour fonctionner avec Python 3.1

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

Pour contrôler le nombre de chiffres significatifs , utilisez le spécificateur de format% g.

Appelons la solution d'Emile prettylist2f. Voici la version modifiée:

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 de la flexibilité dans le nombre de chiffres significatifs, utilisez plutôt le formatage de chaîne F :

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]

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 un dict à un DataFrame:

P.DataFrame.from_dict(d, orient='index')

Tout d'abord, les éléments d'une collection impriment leur repr. vous devriez vous renseigner 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)

Je viens de rencontrer ce problème en essayant d'utiliser pprint pour générer une liste de tuples 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é des expressions de générateur au début, mais pprint vient de reprendre le générateur ...

Depuis Python 3.6, vous pouvez utiliser des chaînes 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 gardant 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<--

J'ai eu ce problème, mais aucune des solutions ici n'a fait exactement ce que je voulais (je veux que la sortie imprimée soit une expression python valide), alors que diriez-vous de ceci:

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 censé être la solution la plus standard, mais je trouve cela plus lisible)

Je suis d'accord avec le commentaire de SilentGhost, la boucle for n'est pas si mal. Vous pouvez réaliser ce que vous voulez avec:

l = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
for x in l: print "%0.2f" % (x)

Le code ci-dessous fonctionne bien pour moi.

list = map (lambda x: float('%0.2f' % x), list)