Formatieren von Gleitkommazahlen ohne nachgestellte Nullen

Question 1

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.

Zum Beispiel:

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

Question 2

Ich würde es tun ('%f' % x).rstrip('0').rstrip('.') — garantiert Festkommaformatierung statt wissenschaftlicher Notation usw. Ja, nicht so glatt und elegant wie %gaber es funktioniert (und ich weiß nicht, wie man es erzwingt %g niemals die wissenschaftliche Schreibweise zu verwenden;-).

Question 3

Du könntest benutzen %g um das zu erreichen:

'%g'%(3.140)

oder mit Python ≥ 2.6:

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

oder mit Python ≥ 3.6:

f'{3.140:g}'

Von dem Dokumente für format: g Ursachen (unter anderem)

unbedeutende nachgestellte Nullen [to be]
von der Mantisse entfernt, und der Dezimalpunkt wird ebenfalls entfernt, wenn keine verbleibenden Ziffern darauf folgen.

Question 4

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

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

Meine Begründung:

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

hätte ich gebrauchen können format(inputValue, '.15f'). Anstatt von '%.15f' % inputValueaber das ist etwas langsamer (~30%).

hätte ich gebrauchen können Decimal(inputValue).normalize(), aber das hat auch ein paar Probleme. Zum einen ist es VIEL langsamer (~11x). Ich fand auch, dass es, obwohl es eine ziemlich große Präzision hat, 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 wäre, ich würde immer noch konvertieren Decimal von einem float was dazu führen kann, dass Sie am Ende etwas anderes als die Zahl haben, die Sie dort eingegeben haben. Ich finde Decimal funktioniert am besten, wenn die Arithmetik drin bleibt Decimal und die Decimal wird mit einem String initialisiert.

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

Ich bin mir sicher, das Problem der Präzision Decimal.normalize() kann mithilfe der Kontexteinstellungen an die Anforderungen angepasst werden, aber in Anbetracht der ohnehin langsamen Geschwindigkeit und der Notwendigkeit, keine lächerliche Präzision zu benötigen, und der Tatsache, dass ich immer noch von einem Float konvertieren und die Präzision sowieso verlieren würde, hielt ich es nicht für wert, weiterverfolgt zu werden.

Ich mache mir keine Sorgen um das mögliche “-0” -Ergebnis, da -0.0 eine gültige Gleitkommazahl ist und wahrscheinlich sowieso selten vorkommt, aber da Sie erwähnt haben, dass Sie das Zeichenfolgenergebnis so kurz wie möglich halten möchten, Sie könnte immer eine zusätzliche Bedingung zu sehr geringen zusätzlichen Geschwindigkeitskosten verwenden.

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

Question 5

Wie wäre es mit dem einfachsten und wahrscheinlich effektivsten Ansatz? Die Methode normalisieren() entfernt alle abschließenden Nullen ganz rechts.

from decimal import Decimal

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

Arbeitet in Python 2 und Python 3.

— Aktualisiert —

Das einzige Problem, wie @BobStein-VisiBone betonte, ist, dass Zahlen wie 10, 100, 1000 … in Exponentialdarstellung angezeigt werden. Dies kann stattdessen 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()

Question 6

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

Question 7

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

format(3.140, '.10g') wobei 10 die gewünschte Genauigkeit ist.

Question 8

Während die Formatierung wahrscheinlich die pythonischste Art ist, ist hier eine alternative Lösung mit der more_itertools.rstrip Werkzeug.

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 von nachgestellten Zeichen befreit wird, die ein Prädikat erfüllen. Die Funktionsdefinition fmt ist nicht erforderlich, wird aber hier verwendet, um Behauptungen zu testen, die alle bestehen. Hinweis: Es funktioniert mit Zeichenfolgeneingaben und akzeptiert optionale Prädikate.

Siehe auch Details zu dieser Drittanbieter-Bibliothek, more_itertools.