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

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

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

Podría usar la 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)

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

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

Sé que escribiste tu ejemplo en listas crudas de Python, pero si decides usar matrices numpy (lo que sería perfectamente legítimo en tu ejemplo, porque parece que estás tratando con matrices de números), existe (casi exactamente) este comando usted dijo que usted hizo para arriba

 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 deshacerse de los ceros finales, por ejemplo, use la cadena de formato %g :

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

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

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

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

La nueva syntax de formación de cadenas no es difícil de usar y, sin embargo, es bastante potente.

Pienso que puede ser que pprint pueda tener algo, pero no he encontrado nada.

Una solución más permanente es hacer 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 float subclases es que rompe el código que busca explícitamente el tipo de una variable. Pero por lo que 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 float.__repr__ parche del mono float.__repr__ , porque el float es inmutable.

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

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

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

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] 

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

Los comps de lista son tus amigos.

 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 

Podrías usar los 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. usted debe aprender sobre __repr__ y __str__ .

Esta es la diferencia entre print repr (1.1) e 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) 

Acabo de encontrarme 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 de generador al principio, pero pprint solo reprimió 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 de python válida), entonces, ¿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 se supone que .format () es la solución más estándar, pero me parece más legible)

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

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

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

Llamemos a 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 de caracteres 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, puedes 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 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 quieras con:

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