Impresión bonita y sencilla de carrozas en pitón?

Question

Tengo una lista de carrozas. Si simplemente se print, se muestra así:

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

que podría utilizar print "%.2f", lo que requeriría un bucle for para recorrer la lista, pero entonces no trabajaría para estructuras de datos más complejas. me gustaría algo así (estoy completamente haciendo esto para arriba)

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

Una solución más permanente es una 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 subclasificación float es que rompe el código que está buscando de forma explícita para el tipo de una 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 se puede simplemente mono parche float.__repr__, porque float es inmutable.

Si no desea subclase float, pero no les importa la definición de una función, map(f, x) es mucho más concisa que [f(n) for n in x]

Answer 2

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 3

Las composiciones de la lista son su amigo.

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

Inténtelo:

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

Usted puede hacer:

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

Answer 5

creo que Python 3.1 se imprimirlos más agradable por defecto, sin cambiar ningún código. Pero eso es inútil si usa cualquier extensión que no se haya actualizado para funcionar con Python 3.1

Answer 6

Estoy de acuerdo con el comentario de SilentGhost, el bucle for no es tan malo. Se puede lograr lo que quiere con:

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

Answer 7

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

Esto evitará los errores de redondeo en la representación binaria cuando se imprimen, 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] 

Answer 8

Como nadie lo ha agregado, se debe tener en cuenta que, en adelante, desde Python 2.6+, la forma recomendada de hacer string formating es con format, para prepararse para Python 3+.

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

The newstring 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.

Answer 9

Primero, los elementos dentro de una colección imprimen su repr. usted debe aprender sobre __repr__ y __str__.

Esta es la diferencia entre print repr (1.1) e print 1.1. Vamos a unirse a todas aquellas 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 10

simplemente me encontré con este problema al intentar utilizar pprint a la salida de una lista de tuplas de carrozas comprensiones anidados podría 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]) 

que utilizan las expresiones generadoras al principio, pero simplemente pprint repred el generador ...

Answer 11

Usted podría utilizar pandas.

Aquí se muestra un ejemplo de 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 usted tiene un diccionario d, y desea que sus teclas 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 manera de dar dict a una trama de datos :

Answer 12

tuve este problema, pero ninguna de las soluciones que aquí hice exactamente lo que quería (Quiero la salida impresa como una expresión válida en Python), por lo que 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é .formato() se supone que es la solución más estándar, pero me parece más legible)

Answer 13

El código siguiente funciona bien para mí.

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

Answer 14

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 15

La opción más fácil debería ser el uso de un redondeo rutina:

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 16

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

Denominemos la solución de Emile prettylist2f.Aquí está el uno 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, utilice f-string formatting 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]