number - python print format float

Fácil impresión bonita de carrozas en pitón?

Question

Tengo una lista de carrozas. Si simplemente lo print , aparece así:

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

Podría usar print "%.2f" , que requeriría un bucle for para recorrer la lista, pero luego no funcionaría para estructuras de datos más complejas. Me gustaría algo como (estoy inventando esto por completo)

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

Answer 1

A partir de Python 3.6, puede usar f-strings:

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 usar parámetros de impresión mientras mantiene 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<--

Answer 2

Acabo de encontrarme con este problema al intentar usar pprint para generar una lista de tuplas de flotantes. 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 de generador al principio, pero pprint simplemente repredió el generador ...

Answer 3

Como nadie lo ha agregado, se debe tener en cuenta que a partir de Python 2.6+, la forma recomendada de hacer format cadenas es con format , para prepararse para Python 3+.

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

La nueva sintaxis de formateo de cadenas no es difícil de usar y, sin embargo, es bastante potente.

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

Answer 4

Creo que Python 3.1 los imprimirá mejor por defecto, sin ningún cambio de código. Pero eso es inútil si usa extensiones que no se han actualizado para funcionar con Python 3.1.

Answer 5

El código de abajo funciona bien para mí.

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

Answer 6

Es una vieja pregunta, pero agregaría algo potencialmente útil:

Sé que escribiste tu ejemplo en listas en bruto de Python, pero si decides usar matrices numpy lugar (lo cual sería perfectamente legítimo en tu ejemplo, porque pareces tratar con matrices de números), hay (casi exactamente) este comando dijiste que inventaste

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

O incluso mejor en su caso si aún desea ver todos los decimales de números realmente precisos, pero elimine los ceros finales, por ejemplo, use la cadena de formato %g :

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

Para simplemente imprimir una vez y no cambiar el comportamiento global, use np.array2string con los mismos argumentos que antes.

Answer 7

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

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

Answer 8

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]

Answer 9

Las compilaciones de lista son su amigo.

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

Intentalo:

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

Answer 10

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

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

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

Answer 11

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 tiene un dict d, y quiere 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'')

Answer 12

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) e print 1.1. Vamos a unir 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)

Answer 13

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

Answer 14

Tu puedes hacer:

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

Answer 15

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]

(Sé que .format () se supone que es la solución más estándar, pero me parece más legible)

Answer 16

Una solución más permanente es subclass 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 subclassing float es que rompe código que busca explícitamente el tipo de variable. Pero hasta donde puedo decir, ese es el único problema con eso. Y un simple x = map(float, x) deshace la conversión a prettyfloat .

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

Si no quiere subclasificar float , pero no le importa definir una función, map(f, x) es mucho más conciso que [f(n) for n in x]

Answer 17

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

Answer 18

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 el formateo con "%.2f" ):

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