Einfaches hübsches Drucken von Floats in Python?

Ich habe eine Liste von Schwimmern. Wenn ich es einfach printmache, zeigt es sich so:

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

Ich könnte verwenden print "%.2f", was eine forSchleife erfordern würde , um die Liste zu durchlaufen, aber dann würde es für komplexere Datenstrukturen nicht funktionieren. Ich hätte gerne so etwas wie (ich mache das komplett nach)

>>> 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 ist eine alte Frage, aber ich möchte etwas potenziell Nützliches hinzufügen:

Ich weiß, dass Sie Ihr Beispiel in rohen Python-Listen geschrieben haben, aber wenn Sie sich numpystattdessen für die Verwendung von Arrays entscheiden (was in Ihrem Beispiel absolut legitim wäre, weil Sie sich anscheinend mit Arrays von Zahlen befassen), gibt es (fast genau) diesen Befehl sagte du hast erfunden:

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

Oder noch besser in Ihrem Fall, wenn Sie immer noch alle Dezimalstellen wirklich präziser Zahlen sehen möchten, aber nachfolgende Nullen entfernen möchten, verwenden Sie beispielsweise die Formatierungszeichenfolge %g:

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

Verwenden Sie np.array2stringdieselben Argumente wie oben , um nur einmal zu drucken und das globale Verhalten nicht zu ändern .

Wie noch niemand hinzugefügt hat, sollte beachtet werden, dass ab Python 2.6+ die empfohlene Methode zum Formatieren von Zeichenfolgen darin besteht format, sich auf Python 3+ vorzubereiten .

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

Die neue Syntax zur Formatierung von Zeichenfolgen ist nicht schwer zu verwenden und dennoch recht leistungsfähig.

Ich dachte, das pprintkönnte etwas haben, aber ich habe nichts gefunden.

Eine dauerhaftere Lösung ist die Unterklasse 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

Das Problem bei der Unterklasse floatbesteht darin, dass Code unterbrochen wird, der explizit nach dem Typ einer Variablen sucht. Aber soweit ich das beurteilen kann, ist das das einzige Problem. Und ein einfaches x = map(float, x)macht die Konvertierung zu rückgängig prettyfloat.

Tragischerweise kann man nicht einfach Affenpflaster machen float.__repr__, weil es floatunveränderlich ist.

Wenn Sie keine Unterklasse erstellen möchten float, aber nichts dagegen haben, eine Funktion zu definieren, map(f, x)ist dies viel prägnanter als[f(n) for n in x]

Du kannst tun:

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

Beachten Sie, dass Sie auch eine Zeichenfolge wie "% .2f" multiplizieren können (Beispiel: "% .2f" * 10).

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

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

Dadurch werden Rundungsfehler in der Binärdarstellung beim Drucken vermieden, ohne dass eine feste Genauigkeitsbeschränkung eingeführt wird (wie beim Formatieren mit "%.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))

Ausgabe:

9.00, 0.05, 0.03, 0.01, 0.06, 0.08

Die einfachste Option sollte die Verwendung einer Rundungsroutine sein:

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

Dies erzeugt die Ausgabe:

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]

Ich glaube, dass Python 3.1 sie standardmäßig besser druckt, ohne dass sich der Code ändert. Dies ist jedoch nutzlos, wenn Sie Erweiterungen verwenden, die nicht für Python 3.1 aktualisiert wurden

List Comps sind dein Freund.

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

Versuch es:

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

Verwenden Sie den Formatbezeichner% g, um die Anzahl der signifikanten Stellen zu steuern .

Nennen wir Emiles Lösung prettylist2f. Hier ist die modifizierte:

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

Verwendung:

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

Wenn Sie Flexibilität bei der Anzahl der signifikanten Stellen wünschen, verwenden Sie stattdessen die Formatierung der F-Zeichenfolge :

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]

Sie könnten Pandas verwenden.

Hier ist ein Beispiel mit einer 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

Wenn Sie ein Diktat d haben und dessen Schlüssel als Zeilen möchten:

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

Und eine andere Möglichkeit, einem DataFrame ein Diktat zu geben:

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

Erstens drucken Elemente in einer Sammlung ihre Repräsentanten. Sie sollten über __repr__und lernen __str__.

Dies ist der Unterschied zwischen print repr (1.1) und print 1.1. Verbinden wir alle diese Zeichenfolgen anstelle der Darstellungen:

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)

Ich bin gerade auf dieses Problem gestoßen, als ich versucht habe, mit pprint eine Liste von Tupeln von Floats auszugeben. Verschachtelte Verständnisse mögen eine schlechte Idee sein, aber ich habe Folgendes getan:

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

Ich habe zuerst Generatorausdrücke verwendet, aber pprint hat den Generator nur wiederholt ...

Ab Python 3.6 können Sie F-Strings verwenden:

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

Sie können Druckparameter verwenden, während der Code gut lesbar bleibt:

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

Ich hatte dieses Problem, aber keine der Lösungen hier hat genau das getan , was ich wollte (ich möchte, dass die gedruckte Ausgabe ein gültiger Python-Ausdruck ist). Wie wäre es also damit:

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

Verwendung:

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

(Ich weiß, dass .format () die Standardlösung sein soll, aber ich finde dies besser lesbar.)

Ich stimme dem Kommentar von SilentGhost zu, die for-Schleife ist nicht so schlecht. Sie können erreichen, was Sie wollen mit:

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

Der folgende Code funktioniert gut für mich.

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