Formatierung Schwimmer in Python ohne nachfolgende Nullen

Wie kann ich das format ein float, so dass es nicht enthalten nachfolgende Nullen? In anderen Worten, ich möchte die resultierende Zeichenfolge so kurz wie möglich.

Beispiel:

3 -> "3"
3. -> "3"
3.0 -> "3"
3.1 -> "3.1"
3.14 -> "3.14"
3.140 -> "3.14"

Das Beispiel macht keinen Sinn. 3.14 == 3.140 - Sie sind die gleiche floating-point-Zahl. Für diese Angelegenheit 3.140000 ist die gleiche floating-point-Zahl. Die null existiert nicht in den ersten Platz.
Ich denke, das Problem ist der DRUCK der float-Zahl ohne Nullen, nicht die tatsächliche äquivalenz der beiden zahlen.
In dem Fall, es gibt keine "überflüssigen" null. %0.2f und %0.3f sind die beiden Formate zu produzieren, die letzten zahlen auf der linken Seite. Verwenden %0.2f zu produzieren, die letzten beiden zahlen auf der rechten Seite.
3.0 -> "3" ist immer noch ein Gültiger Anwendungsfall. print( '{:,g}'.format( X ) bei mir funktioniert die Ausgabe 3 wo X = 6 / 2 und wenn X = 5 / 2 bekam ich eine Ausgabe von 2.5 als erwartet.
alte Frage, aber.. print("%s"%3.140) gibt Ihnen, was Sie wollen. (Ich fügte hinzu, eine Antwort unten siehe unten...)

InformationsquelleAutor TarGz | 2010-03-14

161

Mir, das ich tun würde ('%f' % x).rstrip('0').rstrip('.') -- garantiert fixed-point-Formatierung statt der wissenschaftlichen notation, etc etc. Ja, nicht so glatt und elegant als %g, aber es funktioniert (und ich weiß nicht, wie zu zwingen %g nie in wissenschaftlicher Schreibweise;-).
- Danke es funktioniert genau wie ich es wollte!!! Nur ein kleines bisschen schade gibt es keine Darstellung geben, die für diese Art von Verhalten....
- vereinbart, es wäre sicherlich eleganter zu sein, als einige %-flags für, die. Für modern-Python-Ansatz finden Sie unter docs.python.org/library/... - aber es scheint so zu benehmen, in Bezug auf Ihr spezifisches problem, wie '%g' % x verwendet, es hat nur ein wohl schönere syntax. Plus, können Sie jetzt eine Unterklasse string.Formatter zu tun, Ihre eigenen Anpassungen.
- Das einzige problem mit diesem ist '%.2f' % -0.0001 verlassen Sie mit -0.00 und letztlich -0.
- Es funktioniert nicht: 0.0000001 gerundet 0
- da die Standard-Genauigkeit ist 6, siehe docs.python.org/2/library/string.html: 'f' Fixed point. Displays the number as a fixed-point number. The default precision is 6. Sie würden für die Verwendung von '%0.7 f " in der obigen Lösung.
- Guter Punkt 🙂 ich kann nur hinzufügen, dass die Erhöhung der Präzision über '%0.15f' ist eine schlechte Idee, weil weird stuff beginnt zu geschehen.
- rechts, ~15.95 Dezimalstellen, ist die Grenze für "double precision" (64-bit) schwimmt, für "single precision" (32 bit) es ist ~7.22 Dezimalstellen.
- Ich Frage mich, ob es wäre schneller oder langsamer als: ('%f' % x).rstrip('0.')
- Es ist nicht die vollständige Antwort für die Frage z.B. ('%f' % 15.10).rstrip('0').rstrip('.') return '15.100001' das ist nicht das, was er fragt, aber ich habe keine bessere Antwort, wie dies zu vermeiden unprecision
- Es ist schneller, aber nicht ('%.2f' % -0.001).rstrip('0.') wenn es reduziert sich auf '-'
- was wäre, wenn es in der Vorlage
- In Fall, dass Sie in eine Mitte von einigen anderen string: print('In the middle {} and something else'.format('{:f}'.format(a).rstrip('0')))
- Martelli, loszuwerden, die Doppelzimmer rstrip Befehl. Verwenden Sie einfach diese statt der Streifen sowohl den Punkt (.) und alle nachgestellten Nullen Sie danach in Betrieb: ('%f' % x).rstrip('.0')
InformationsquelleAutor Alex Martelli
125

Könnten Sie %g um dies zu erreichen:
```
'%g'%(3.140)
```
oder, für Python 2.6 oder besser:
```
'{0:g}'.format(3.140)
```
Aus der docs für format: g Ursachen (unter anderem)

unbedeutenden Nullen [zu werden]
entfernt von der Mantisse, und die
Dezimalpunkt wird auch entfernt, wenn es
sind keine weiteren Ziffern Folgen zu können.
- Ach ja, fast! Manchmal ist es die Formate float in Exponentialschreibweise ("2.342 E+09") - ist es möglich, es zu deaktivieren, also immer zeigen alle signifikanten Ziffern?
- Warum '{0:...}'.format(value) wenn Sie könnte verwenden format(value, '...')? Das verhindert, dass analysiert wird der Formatbezeichner aus einer Vorlage-Zeichenfolge, die ist sonst leer.
- Es funktioniert nicht mit 29000.32
- Die winzigen Kosten der Parsen aus dem format-Bezeichner ist überschwemmt von anderen overhead-AFAICT; in der Praxis ist, meine lokalen benchmarks auf 3.6 (mit der Funktion der Festlegung des lösungsumfangs der microbenchmark genau zu-Modell-code) haben format(v, '2.5f') nehmen ~10% länger als '{:2.5f}'.format(v). Auch wenn Sie es nicht Tat, ich Neige dazu, verwenden Sie die str Methode bilden, weil, wenn ich brauche, um es zu optimieren, zusätzliche Werte, etc., es ist weniger zu ändern. Natürlich, wie von 3.6 haben wir die f-Saiten für die meisten Zwecke. 🙂
InformationsquelleAutor unutbu
12

Was zu versuchen die einfachste und wahrscheinlich effektivste Ansatz?
Die Methode normalize() entfernt alle niedrigstwertigen Nullen.
```
from decimal import Decimal

print (Decimal('0.001000').normalize())
# Result: 0.001
```
Arbeitet in Python 2 und Python 3.

-- Aktualisiert --

Nur das problem ist, wie @BobStein-VisiBone darauf hingewiesen wird, dass zahlen wie 10, 100, 1000... werden angezeigt, die in exponentieller Darstellung. Dies kann leicht behoben mit der folgenden Funktion statt:
```
from decimal import Decimal


def format_float(f):
    d = Decimal(str(f));
    return d.quantize(Decimal(1)) if d == d.to_integral() else d.normalize()
```
- Außer Decimal('10.0').normalize() wird '1E+1'
InformationsquelleAutor Ander
10

Nachdem ich über Antworten auf mehrere ähnliche Fragen, scheint dies die beste Lösung für mich:
```
def floatToString(inputValue):
    return ('%.15f' % inputValue).rstrip('0').rstrip('.')
```
Meine überlegung:

%g nicht loszuwerden, die wissenschaftliche notation.
```
>>> '%g' % 0.000035
'3.5e-05'
```
15 Dezimalstellen scheint zu vermeiden, seltsames Verhalten und hat viel Präzision für meine Bedürfnisse.
```
>>> ('%.15f' % 1.35).rstrip('0').rstrip('.')
'1.35'
>>> ('%.16f' % 1.35).rstrip('0').rstrip('.')
'1.3500000000000001'
```
Hätte ich format(inputValue, '.15f'). statt '%.15f' % inputValue, aber das ist etwas langsamer (~30%).

Hätte ich Decimal(inputValue).normalize(), aber dies hat ein paar Probleme. Zum einen, es ist VIEL langsamer (~11x). Ich fand auch, dass, obwohl es hat ziemlich große Präzision, es leidet immer noch unter Präzisions-Verlust bei der Verwendung von normalize().
```
>>> Decimal('0.21000000000000000000000000006').normalize()
Decimal('0.2100000000000000000000000001')
>>> Decimal('0.21000000000000000000000000006')
Decimal('0.21000000000000000000000000006')
```
Allem würde ich immer noch auf die Umwandlung zu Decimal aus einer float was machen Sie am Ende mit etwas anderes als die Nummer, die Sie in es gesetzt. Ich denke Decimal funktioniert am besten, wenn das arithmetische bleibt in Decimal und die Decimal initialisiert ein string.
```
>>> Decimal(1.35)
Decimal('1.350000000000000088817841970012523233890533447265625')
>>> Decimal('1.35')
Decimal('1.35')
```
Ich bin sicher, dass die Präzision Ausgabe von Decimal.normalize() eingestellt werden kann, was notwendig ist, mit Kontext-Einstellungen, aber in Anbetracht der bereits langsame Geschwindigkeit und nicht brauchen lächerlich Präzision und die Tatsache, dass ich immer noch die Konvertierung von float und verlieren Genauigkeit wie auch immer, ich nicht denke, dass es Wert war, verfolgt.

Ich bin nicht besorgt über die möglichen "-0" Ergebnis seit -0.0 ist eine gültige floating point Zahl, und es wäre wahrscheinlich ein Seltenes Ereignis in jedem Fall, aber da hat man noch erwähnen, Sie wollen, halten Sie die Zeichenfolge Ergebnis so kurz wie möglich, Sie können immer mit einer extra-bedingt sehr wenig zusätzliche Geschwindigkeit Kosten.
```
def floatToString(inputValue):
    result = ('%.15f' % inputValue).rstrip('0').rstrip('.')
    return '0' if result == '-0' else result
```
- Leider funktioniert nur bei zahlen mit weniger als ungefähr) fünf oder mehr stellen Links von der Dezimalstelle. floatToString(12345.6) zurück '12345.600000000000364' zum Beispiel. Eine Verringerung der 15 in %.15f zu einer niedrigeren Nummer betätigt, löst es in diesem Beispiel, aber dieser Wert muss verringert werden, mehr und mehr, als die Zahl größer wird. Es könnte sein, dynamisch berechnet auf der Basis des log-Basis 10 von der Zahl, aber das wird schnell sehr kompliziert.
- Ein Weg, um dieses problem zu lösen sein könnte, beschränken Sie die Länge der gesamten Zahl (anstatt nur die Ziffern nach dem Dezimalkomma): result = ('%15f' % val).rstrip('0').rstrip('.').lstrip(' ')
- Ich bin mir nicht sicher, ob dies vermeidbar ist. Es ist eine Nebenwirkung von Fließkomma-zahlen nicht in der Lage, zu vertreten, die Genauigkeit, wenn mehr Ziffern erforderlich sind, auf der linken Seite. Was ich sagen kann, die Zahl, die raus kommt ein string, der die gleiche Nummer, der geht wie ein Schwimmer, oder zumindest die nächsten Darstellung. >>>12345.600000000000364 == 12345.6 True
InformationsquelleAutor PolyMesh
5

Hier ist eine Lösung, die für mich gearbeitet. Es ist eine Mischung der Lösung von PolyMesh und Nutzung der neuen .format() syntax.
```
for num in 3, 3., 3.0, 3.1, 3.14, 3.140:
    print('{0:.2f}'.format(num).rstrip('0').rstrip('.'))
```
Ausgabe:
```
3
3
3
3.1
3.14
3.14
```
- Einzige, was falsch mit diesem ist, dass Sie haben, um eine sinnvolle Anzahl von Nachkommastellen. Je höher Sie setzen, desto genauer zahlen kann man darstellen, aber wenn Sie dies tun eine Menge, kann es die Leistung beeinträchtigen.
- Hinzufügen beruic Kommentar, dies funktioniert nicht für floats größere Präzision (z.B. 3.141) als .2f ist hart codiert.
InformationsquelleAutor Kaushal Modi
2

Können Sie einfach format() um dies zu erreichen:

format(3.140, '.10g') wobei 10 die Präzision, die Sie wollen.

InformationsquelleAutor clel
2
```
>>> str(a if a % 1 else int(a))
```
- Nicht du meinst int(a) if a % 1 else a?
- Liebe Beruic, Ihrer Antwort ergibt sich eine negative Antwort. a if a % 1 else int(a) korrekt ist. Frage muss die Ausgabe in string , So dass ich nur Hinzugefügt str
- Ah, ich bekomme es jetzt. a % 1 ist truthy, weil es nicht null ist. Ich implizit und fälschlicherweise denken, es a % 1 == 0.
InformationsquelleAutor Shameem
2

Während der Formatierung ist wahrscheinlich, dass die meisten Pythonic way, hier ist eine Alternative Lösung, mit der more_itertools.rstrip tool.
```
import more_itertools as mit


def fmt(num, pred=None):
    iterable = str(num)
    predicate = pred if pred is not None else lambda x: x in {".", "0"}
    return "".join(mit.rstrip(iterable, predicate))

assert fmt(3) == "3"
assert fmt(3.) == "3"
assert fmt(3.0) == "3"
assert fmt(3.1) == "3.1"
assert fmt(3.14) == "3.14"
assert fmt(3.140) == "3.14"
assert fmt(3.14000) == "3.14"
assert fmt("3,0", pred=lambda x: x in set(",0")) == "3"
```
Die Zahl wird in eine Zeichenfolge konvertiert, die beraubt nachfolgende Zeichen erfüllen ein Prädikat. Die definition der Funktion fmt ist nicht erforderlich, aber es wird hier verwendet, um test-assertions, die alle erfolgreich waren. Hinweis: es funktioniert auf string-Eingänge und akzeptiert optionale Prädikate.

Siehe auch details auf dieser Drittanbieter-Bibliothek more_itertools.

InformationsquelleAutor pylang
1

Wenn Sie Leben können mit 3. und 3.0 erscheinen als "3.0", ein sehr einfacher Ansatz, der rechts-Streifen Nullen von float-Darstellungen:
```
print("%s"%3.140)
```
(danke @ellimilial für den Hinweis auf die Ausnahmen)
- Aber print("%s"%3.0) tut.
InformationsquelleAutor drevicko
0

OP entfernen möchten superflouous Nullen und stellen Sie die resultierende Zeichenfolge so kurz wie möglich.

Ich finde die %g exponentiellen Formatierung verkürzt den entsprechenden string für sehr große und sehr kleine Werte. Das problem kommt für Werte, die nicht brauchen, exponential-notation, wie 128.0, die weder sehr groß oder sehr klein.

Hier ist eine Möglichkeit zum formatieren von zahlen als kurze Zeichenfolgen, die verwendet %g Exponentialschreibweise nur wenn Nachkommastellen.normalisieren schafft Zeichenfolgen, die zu lang sind. Das ist vielleicht nicht die Schnellste Lösung (da es nicht Dezimal.normalisieren)
```
def floatToString (inputValue, precision = 3):
    rc = str(Decimal(inputValue).normalize())
    if 'E' in rc or len(rc) > 5:
        rc = '{0:.{1}g}'.format(inputValue, precision)        
    return rc

inputs = [128.0, 32768.0, 65536, 65536 * 2, 31.5, 1.000, 10.0]

outputs = [floatToString(i) for i in inputs]

print(outputs)

# ['128', '32768', '65536', '1.31e+05', '31.5', '1', '10']
```
InformationsquelleAutor kinok

Für float-Sie können diese:

def format_float(num):
    return ('%i' if num == int(num) else '%s') % num

Test:

>>> format_float(1.00000)
'1'
>>> format_float(1.1234567890000000000)
'1.123456789'

Dezimal-Lösung finden Sie hier: https://stackoverflow.com/a/42668598/5917543

InformationsquelleAutor Artem Skoretskiy

-1

Benutzen Sie %g mit groß genug Breite, zum Beispiel '%.99g'.
Es wird gedruckt in fixed-point notation für jede halbwegs große Nummer.

EDIT: es funktioniert nicht
```
>>> '%.99g' % 0.0000001
'9.99999999999999954748111825886258685613938723690807819366455078125e-08'
```
- .99 ist die Präzision, nicht Breite; irgendwie nützlich, aber Sie nicht bekommen, um die tatsächliche Genauigkeit dieser Art (andere als mit dem abschneiden von selbst).
- Dies ist auch sehr falsch ist, versuchen Sie drucken 0.51 damit.
InformationsquelleAutor alexanderlukanin13
-1

Können Sie max() wie diese:

print(max(int(x), x))
- Sie haben, um den Fall betrachten, wo x negativ ist. if x < 0: print(min(x), x) else : print(max(x), x)
- Eine nützliche Methode, wenn ich will, zu tun, json stringify. float 1.0 ändern, zu int-1, so führen Sie einfach dieselben wie in javascript.
InformationsquelleAutor elig
-2

Umgang mit "%f", und Sie sollten

%.2f

wo:
.2f == .00 schwimmt.

Beispiel:

print "Preis: %.2f" % Preise[Produkt]

Ausgabe:

Preis: 1.50
- Dies ist eindeutig nicht, was die Frage will. Müssen downvote.
InformationsquelleAutor Alex M.
-3

Können Sie erreichen, dass in den meisten pythonic way so:

Python ist3:
```
"{:0.0f}".format(num)
```
- "{:0.0f}".format(3.1) ist "3" nicht "3.1"
InformationsquelleAutor Lan Vukušič

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Ausgabe: