Fácil impresión bonita de flotadores en python?

Como nadie lo ha añadido, debe tenerse en cuenta que a partir de Python 2.6 + la forma recomendada de hacer formatear cadenas es con format, para prepararse para Python 3+.

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

El nuevo string formating syntax no es difícil de usar, y sin embargo es bastante potente.

Pensé que podría ser pprint podría tener algo, pero no he encontrado nada.

Una solución más permanente es subclase 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

El problema con la subclase float es que rompe el código que está buscando explícitamente el tipo de una variable. Pero por lo que puedo decir, ese es el único problema con él. Y un simple x = map(float, x) deshace la conversión a prettyfloat.

Trágicamente, no puedes simplemente patch-mono float.__repr__, porque float es inmutable.

Si no quieres subclase float, pero no te importa definir una función, map(f, x) es mucho más conciso than [f(n) for n in x]

Puedes hacer:

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

Tenga en cuenta que también puede multiplicar una cadena como "%.2f" (ejemplo: "%.2f " *10).

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

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

Esto evitará los errores de redondeo en la representación binaria cuando se imprima, sin introducir una restricción de precisión fija (como formatear con "%.2f"):

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

Creo que Python 3.1 los imprimirá mejor por defecto, sin ningún cambio de código. Pero eso es inútil si usas cualquier extensión que no se haya actualizado para trabajar con Python 3.1

List comps son tus amigos.

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

Pruébalo:

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

La opción más fácil debería ser usar una rutina de redondeo:

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

Esto produce la salida:

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]

Podrías usar pandas.

Aquí hay un ejemplo con una lista:

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 tienes un dict d, y quieres sus claves como filas:

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

Y otra forma de dar dict a un DataFrame:

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

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

Salida:

9.00, 0.05, 0.03, 0.01, 0.06, 0.08

Primero, los elementos dentro de una colección imprimen su repr. deberías aprender sobre __repr__ y __str__.

Esta es la diferencia entre print repr(1.1) y print 1.1. Unamos todas esas cadenas en lugar de las representaciones:

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)

Me encontré con este problema al intentar usar pprint para generar una lista de tuplas de flotadores. Las comprensiones anidadas pueden ser una mala idea, pero esto es lo que hice:

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

Usé expresiones generadoras al principio, pero pprint solo repred el generador...

Tuve este problema, pero ninguna de las soluciones aquí hizo exactamente lo que quería (quiero que la salida impresa sea una expresión válida de python), así que qué tal esto:

prettylist = lambda l : '[%s]' % ', '.join("%.2f" % f for f in l)

Uso:

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

(Lo sé .format() se supone que es la solución más estándar, pero encuentro esto más legible)

El siguiente código funciona bien para mí.

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

Para controlar el número de dígitos significativos, utilice el especificador de formato %g.

Vamos a nombrar la solución de Emile prettylist2f. Aquí está la modificada:

prettylist2g = lambda l : '[%s]' % ', '.join("%.2g" % x for x in l)

Uso:

>>> 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 desea flexibilidad en el número de dígitos significativos, use formato de cadena f en su lugar:

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]

A partir de Python 3.6, puede usar cadenas 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

Puede utilizar los parámetros de impresión manteniendo el código muy legible:

print(*[f"{element:.2f}" for element in list_], sep='|', end='<--')
#9.00|0.05|0.03|0.01|0.06|0.08<--

Estoy de acuerdo con el comentario de SilentGhost, el bucle for no es tan malo. Puedes lograr lo que quieres con:

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