Wie kann ich einen Float so formatieren, dass er keine nachgestellten Nullen enthält? Mit anderen Worten, ich möchte, dass die resultierende Zeichenfolge so kurz wie möglich ist.

Beispielsweise:

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

Ich würde es tun ('%f' % x).rstrip('0').rstrip('.')- garantiert eine Festkomma-Formatierung anstelle einer wissenschaftlichen Notation usw. usw. Ja, nicht so schick und elegant wie %g, aber es funktioniert (und ich weiß nicht, wie ich zwingen soll %g, niemals wissenschaftliche Notation zu verwenden; -).

Sie könnten dies verwenden %g, um dies zu erreichen:

'%g'%(3.140)

oder für Python 2.6 oder besser:

'{0:g}'.format(3.140)

Aus den Dokumenten fürformat : gUrsachen (unter anderem)

Unbedeutende nachfolgende Nullen werden aus dem Signifikanten entfernt, und der Dezimalpunkt wird ebenfalls entfernt, wenn keine verbleibenden Ziffern darauf folgen.

Was ist mit dem einfachsten und wahrscheinlich effektivsten Ansatz? Die Methode normalize () entfernt alle am weitesten rechts stehenden Nullen.

from decimal import Decimal

print (Decimal('0.001000').normalize())
# Result: 0.001

Funktioniert in Python 2 und Python 3 .

-- Aktualisiert --

Das einzige Problem, wie @ BobStein-VisiBone hervorhob, ist, dass Zahlen wie 10, 100, 1000 ... in exponentieller Darstellung angezeigt werden. Dies kann einfach mit der folgenden Funktion behoben werden:

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

Nachdem ich mir die Antworten auf einige ähnliche Fragen angesehen habe, scheint dies die beste Lösung für mich zu sein:

def floatToString(inputValue):
    return ('%.15f' % inputValue).rstrip('0').rstrip('.')

Meine Argumentation:

%g wird die wissenschaftliche Notation nicht los.

>>> '%g' % 0.000035
'3.5e-05'

15 Dezimalstellen scheinen seltsames Verhalten zu vermeiden und haben viel Präzision für meine Bedürfnisse.

>>> ('%.15f' % 1.35).rstrip('0').rstrip('.')
'1.35'
>>> ('%.16f' % 1.35).rstrip('0').rstrip('.')
'1.3500000000000001'

Ich hätte format(inputValue, '.15f').stattdessen verwenden können '%.15f' % inputValue, aber das ist etwas langsamer (~ 30%).

Ich hätte es gebrauchen können Decimal(inputValue).normalize(), aber das hat auch ein paar Probleme. Zum einen ist es VIEL langsamer (~ 11x). Ich fand auch heraus, dass es, obwohl es eine ziemlich hohe Präzision aufweist, bei der Verwendung immer noch unter Präzisionsverlust leidet normalize().

>>> Decimal('0.21000000000000000000000000006').normalize()
Decimal('0.2100000000000000000000000001')
>>> Decimal('0.21000000000000000000000000006')
Decimal('0.21000000000000000000000000006')

Am wichtigsten ist, dass ich immer noch Decimalvon einem konvertieren würde, floatwas dazu führen kann, dass Sie etwas anderes als die Nummer erhalten, die Sie dort eingegeben haben. Ich denke, Decimalfunktioniert am besten, wenn die Arithmetik erhalten bleibt Decimalund die Decimalmit einer Zeichenfolge initialisiert wird.

>>> Decimal(1.35)
Decimal('1.350000000000000088817841970012523233890533447265625')
>>> Decimal('1.35')
Decimal('1.35')

Ich bin mir sicher, dass das Präzisionsproblem von Decimal.normalize()mithilfe der Kontexteinstellungen an die Anforderungen angepasst werden kann, aber angesichts der ohnehin langsamen Geschwindigkeit, die keine lächerliche Präzision erfordert, und der Tatsache, dass ich immer noch von einem Float konvertieren und trotzdem an Präzision verlieren würde, habe ich es nicht getan Ich glaube nicht, dass es sich gelohnt hat, sie zu verfolgen.

Ich bin nicht besorgt über das mögliche "-0" -Ergebnis, da -0.0 eine gültige Gleitkommazahl ist und es wahrscheinlich sowieso selten vorkommt, aber da Sie erwähnt haben, dass Sie das String-Ergebnis so kurz wie möglich halten möchten, Sie könnte immer eine zusätzliche Bedingung bei sehr geringen zusätzlichen Geschwindigkeitskosten verwenden.

def floatToString(inputValue):
    result = ('%.15f' % inputValue).rstrip('0').rstrip('.')
    return '0' if result == '-0' else result

Hier ist eine Lösung, die für mich funktioniert hat. Es ist eine Mischung aus der Lösung von PolyMesh und der Verwendung 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

Sie können einfach format () verwenden, um dies zu erreichen:

format(3.140, '.10g') Dabei ist 10 die gewünschte Präzision.

>>> str(a if a % 1 else int(a))

Während die Formatierung wahrscheinlich die pythonischste ist, gibt es hier eine alternative Lösung mit dem more_itertools.rstripTool.

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, bei der nachfolgende Zeichen, die ein Prädikat erfüllen, entfernt werden. Die Funktionsdefinition fmtist nicht erforderlich, wird hier jedoch zum Testen von Zusicherungen verwendet, die alle bestehen. Hinweis: Es funktioniert mit Zeichenfolgeneingaben und akzeptiert optionale Prädikate.

Siehe auch Details zu dieser Drittanbieter-Bibliothek more_itertools.

Wenn Sie mit 3. und 3.0 leben können, die als "3.0" angezeigt werden, ist dies ein sehr einfacher Ansatz, bei dem Nullen aus Float-Darstellungen entfernt werden:

print("%s"%3.140)

(danke @ellimilial für den Hinweis auf die Ausnahmen)

Die Verwendung des QuantiPhy-Pakets ist eine Option. Normalerweise wird QuantiPhy verwendet, wenn mit Zahlen mit Einheiten und SI-Skalierungsfaktoren gearbeitet wird, es bietet jedoch eine Vielzahl nützlicher Formatierungsoptionen für Zahlen.

    >>> from quantiphy import Quantity

    >>> cases = '3 3. 3.0 3.1 3.14 3.140 3.14000'.split()
    >>> for case in cases:
    ...    q = Quantity(case)
    ...    print(f'{case:>7} -> {q:p}')
          3 -> 3
         3. -> 3
        3.0 -> 3
        3.1 -> 3.1
       3.14 -> 3.14
      3.140 -> 3.14
    3.14000 -> 3.14

In dieser Situation wird keine E-Notation verwendet:

    >>> cases = '3.14e-9 3.14 3.14e9'.split()
    >>> for case in cases:
    ...    q = Quantity(case)
    ...    print(f'{case:>7} -> {q:,p}')
    3.14e-9 -> 0
       3.14 -> 3.14
     3.14e9 -> 3,140,000,000

Eine Alternative, die Sie vielleicht bevorzugen, ist die Verwendung von SI-Skalierungsfaktoren, möglicherweise mit Einheiten.

    >>> cases = '3e-9 3.14e-9 3 3.14 3e9 3.14e9'.split()
    >>> for case in cases:
    ...    q = Quantity(case, 'm')
    ...    print(f'{case:>7} -> {q}')
       3e-9 -> 3 nm
    3.14e-9 -> 3.14 nm
          3 -> 3 m
       3.14 -> 3.14 m
        3e9 -> 3 Gm
     3.14e9 -> 3.14 Gm

OP möchte überflüssige Nullen entfernen und die resultierende Zeichenfolge so kurz wie möglich machen.

Ich finde, dass die exponentielle Formatierung von% g die resultierende Zeichenfolge für sehr große und sehr kleine Werte verkürzt. Das Problem tritt bei Werten auf, die keine Exponentialschreibweise benötigen, wie 128,0, die weder sehr groß noch sehr klein sind.

Hier ist eine Möglichkeit, Zahlen als kurze Zeichenfolgen zu formatieren, die nur dann die Exponentialnotation% g verwenden, wenn Decimal.normalize zu lange Zeichenfolgen erstellt. Dies ist möglicherweise nicht die schnellste Lösung (da Decimal.normalize verwendet wird).

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

Für Float können Sie Folgendes verwenden:

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

Probier es aus:

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

Für Dezimalstellen siehe Lösung hier: https://stackoverflow.com/a/42668598/5917543

"{:.5g}".format(x)

Ich benutze dies, um Floats zu formatieren, um Nullen zu verfolgen.

Hier ist die Antwort:

import numpy

num1 = 3.1400
num2 = 3.000
numpy.format_float_positional(num1, 3, trim='-')
numpy.format_float_positional(num2, 3, trim='-')

Ausgabe "3.14" und "3"

trim='-' Entfernt sowohl die nachgestellten Nullen als auch die Dezimalstelle.

Verwenden Sie% g mit einer ausreichend großen Breite, z. B. '% .99g'. Es wird in Festkommanotation für jede einigermaßen große Zahl gedruckt.

EDIT: es funktioniert nicht

>>> '%.99g' % 0.0000001
'9.99999999999999954748111825886258685613938723690807819366455078125e-08'

Sie können max()wie folgt verwenden:

print(max(int(x), x))

Sie können dies auf die meisten pythonischen Arten erreichen:

python3:

"{:0.0f}".format(num)

Umgang mit% f und Sie sollten setzen

% .2f

, wobei: .2f == .00 schwimmt.

Beispiel:

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

Ausgabe:

Preis: 1,50