Python, eine weit verbreitete Programmiersprache, zeichnet sich durch numerische Rechenaufgaben aus, ist jedoch nicht immun gegen die Herausforderungen der Gleitkomma-Arithmetik. Gleitkommazahlen in Python sind Näherungen reeller Zahlen und führen zu Rundungsfehler, Präzisionsverlust und Stornierungen Das kann Berechnungen durcheinander bringen. Wir können Erkennen Sie diese Fehler, indem Sie nach seltsamen Ergebnissen suchen und die Verwendung von Werkzeugennumpy.finfo>Zu Präzision überwachen . Mit etwas Vorsicht und cleveren Tricks schaffen wir das Halten Sie diese Fehler unter Kontrolle und stellen Sie sicher, dass unsere Python-Berechnungen zuverlässig sind. In diesem Artikel werden wir die Feinheiten von Gleitkommafehlern untersuchen Python .
Was sind Gleitkommazahlen?
Gleitkommazahlen sind eine effiziente Möglichkeit, reelle Zahlen in Computern darzustellen. Sie bestehen aus drei Teilen:
- Bedeutsam: Die tatsächlichen Ziffern, die die Zahl darstellen (z. B. 3.14159)
- Exponent: Gibt an, um wie viele Stellen der Signifikand nach links oder rechts verschoben werden soll (z. B. -2 in 3,14159 x 10^-2).
- Base: Typischerweise 2 für Computer, bestimmt, wie Zahlen intern dargestellt werden
Warum treten Gleitkommafehler auf?
Gleitkommafehler entstehen, weil Computer reelle Zahlen mit einer endlichen Anzahl von Bits speichern, was zu Näherungen und möglichen Ungenauigkeiten führt. Gleitkommazahlen haben intrinsische Einschränkungen:
- Endliche Präzision: Im Signifikanten kann nur eine begrenzte Anzahl von Ziffern gespeichert werden, was zu führt Rundungsfehler bei der Darstellung exakter Dezimalzahlen.
- Präzisionsverlust: Operationen wie Addition oder Subtraktion können die Präzision weiter verringern und die Auswirkungen der Rundung verstärken.
- Unterlauf/Überlauf: Extrem kleine oder große Zahlen können außerhalb des darstellbaren Bereichs liegen und dazu führen Unterlauf (wird Null) oder Überlauf (wird unendlich).
Arten von Gleitkommafehlern
a) Rundungsfehler: Am häufigsten kommt es vor, dass eine exakte Dezimalzahl angenähert werden muss, um der begrenzten Genauigkeit einer Gleitkommazahl zu entsprechen.
b) Präzisionsverlust: Bei nachfolgenden Vorgängen können sich nach und nach Rundungsfehler anhäufen, was zu erheblichen Ungenauigkeiten im Endergebnis führt.
c) Katastrophale Absage: Wenn nahezu gleiche Zahlen mit entgegengesetzten Vorzeichen subtrahiert werden, heben sich ihre signifikanten Ziffern auf, was zu einem kleinen und ungenauen Ergebnis führt.
d) Überlauf/Unterlauf: Diese treten auf, wenn Berechnungen den darstellbaren Bereich von Float-Werten überschreiten, was zu ungenauen oder bedeutungslosen Ergebnissen führt.
Erkennen von Gleitkommafehlern
- Beobachtung unerwarteter Ergebnisse: Der Vergleich berechneter Werte mit erwarteten Ergebnissen oder die Visualisierung von Daten kann Inkonsistenzen aufdecken, die häufig auf Fehler zurückzuführen sind.
- Verwendung von Bibliotheken wie
numpy.finfo>: Bibliotheken mögennumpy>Bereitstellung von Tools wiefinfo>um die Genauigkeit und Einschränkungen verschiedener Float-Datentypen zu überprüfen.
Python-Gleitkommafehler
Hier diskutieren wir verschiedene Arten von Beispielen, die Gleitkommafehler in Python veranschaulichen:
Präzisionsverlust bei der Dezimal-Binär-Konvertierung
In diesem Beispiel wird die Dezimalzahl 0,1 in eine Binärzahl umgewandelt. Aufgrund der unendlichen binären Entwicklung von 0,1 wird nur eine endliche Anzahl von Bits verwendet, was zu einem Genauigkeitsverlust führt.
Python3
Teilstring-Methode Java
decimal_number>=> 0.1> binary_representation>=> format>(decimal_number,>'.30f'>)># 30 decimal places> print>(f>'Decimal: {decimal_number}
Binary: {binary_representation}'>)> |
>
>
Ausgabe:
Decimal: 0.1 Binary: 0.100000000000000005551115123126>
Rundungsfehler
Hier wird erwartet, dass das Ergebnis der dreifachen Addition von 1/3 1,0 beträgt. Aufgrund von Rundungsfehlern bei der Darstellung von 1/3 beträgt die Summe jedoch möglicherweise nicht genau 1,0.
Python3
result>=> 1.0> /> 3.0> sum_result>=> result>+> result>+> result> print>(f>'Expected Result: 1.0
Actual Result: {sum_result}'>)> |
>
>
Ausgabe:
Expected Result: 1.0 Actual Result: 1.0>
Kumulative Fehler bei iterativen Berechnungen
Dieses Beispiel zeigt, wie bei iterativen Berechnungen kumulative Fehler auftreten können. Das zehnmalige Addieren von 0,1 führt aufgrund von Einschränkungen der Gleitkommagenauigkeit möglicherweise nicht zu einem genauen Ergebnis von 1,0.
Python3
total>=> 0.0> for> i>in> range>(>10>):> >total>+>=> 0.1> print>(f>'Expected Result: 1.0
Actual Result: {total}'>)> |
>
>
Ausgabe:
Expected Result: 1.0 Actual Result: 0.9999999999999999>
Vergleichsprobleme
In diesem Fall ergibt der Vergleich der Summe von 0,1 und 0,2 mit 0,3 möglicherweise nicht das erwartete ErgebnisTrue>Ergebnis aufgrund der inhärenten Ungenauigkeit von Gleitkommazahlen.
Python3
Alphabet als Zahlen
a>=> 0.1> +> 0.2> b>=> 0.3> print>(f>'a: {a}
b: {b}
Equal: {a == b}'>)> |
>
>
Ausgabe:
a: 0.30000000000000004 b: 0.3 Equal: False>
Unerwartete Ergebnisse in Berechnungen
Hier ist die Subtraktion von1e16>aus der Summe(1e16 + 1)>wird voraussichtlich 1 ergeben, aber aufgrund von Gleitkommafehlern ist das Ergebnis möglicherweise nicht genau 1.
cdr vollständiges Formular
Python3
a>=> 0.1> +> 0.2> b>=> 0.3> print>(f>'a: {a}
b: {b}
Equal: {a == b}'>)> |
>
>
Ausgabe:
Expected Result: 1 Actual Result: 0.0>
Gleitkomma-Präzision verstehen
Hier werden wir die Gleitkomma-Präzision verstehen: Die 1,2 – 1,0-Anomalie in Python-
Herausforderungen bei der Repräsentation
Es ist bekannt, dass 1,2 – 1,0 = 0,2. Aber wenn Sie versuchen, dasselbe in Python zu tun, werden Sie von den Ergebnissen überrascht sein:
>>> 1,2 - 1,0>
Ausgabe:
0.199999999999999996>
Dies kann als Fehler in Python betrachtet werden, ist es aber nicht. Das hat wenig mit Python zu tun, sondern vielmehr damit, wie die zugrunde liegende Plattform mit Gleitkommazahlen umgeht. Dies ist ein normaler Fall, der bei der internen Verarbeitung von Gleitkommazahlen in einem System auftritt. Es handelt sich um ein Problem, das bei der internen Darstellung von Gleitkommazahlen auftritt, bei der eine feste Anzahl von Binärziffern zur Darstellung einer Dezimalzahl verwendet wird. Es ist schwierig, einige Dezimalzahlen binär darzustellen, daher führt dies in vielen Fällen zu kleinen Rundungsfehlern. Wir kennen ähnliche Fälle in der Dezimalmathematik, viele Ergebnisse können nicht mit einer festen Anzahl von Dezimalstellen dargestellt werden, z Beispiel
10 / 3 = 3.33333333.......>
In diesem Fall, am Beispiel von 1,2, ist die binäre Darstellung von 0,2 0,00110011001100110011001100…… und so weiter. Es ist schwierig, diese unendliche Dezimalzahl intern zu speichern. Normalerweise wird der Wert eines Float-Objekts als binäres Gleitkomma mit einer festen Genauigkeit gespeichert ( typischerweise 53 Bit ). Also vertreten wir 1.2 intern als,
1.0011001100110011001100110011001100110011001100110011>
Was genau gleich ist:
1.1999999999999999555910790149937383830547332763671875>
Behandlung von Gleitkommafehlern
Hier werden wir verschiedene Beispiele zum Umgang mit Gleitkommafehlern in Python diskutieren:
Auf eine bestimmte Dezimalstelle runden
Indem Sie das Ergebnis auf eine bestimmte Dezimalstelle (z. B. 2) runden, können Sie die Auswirkungen kleiner Gleitkommafehler abmildern.
Python3
Java-Sortierarray
result>=> 1.2> -> 1.0> rounded_result>=> round>(result,>2>)> print>(f>'Original Result: {result}
Rounded Result: {rounded_result}'>)> |
>
>
Ausgabe:
Original Result: 0.19999999999999996 Rounded Result: 0.2>
Verwendung der Dezimalklasse für hohe Präzision
Derdecimal>Modul bietet dieDecimal>Klasse, was eine höhere Präzision bei der Arithmetik ermöglicht. Präzision einstellen mitgetcontext().prec>kann bei der Verwaltung der Präzision für bestimmte Berechnungen hilfreich sein
Python3
from> decimal>import> Decimal, getcontext> getcontext().prec>=> 4> # Set precision to 4 decimal places> result>=> Decimal(>'1.2'>)>-> Decimal(>'1.0'>)> print>(f>'High Precision Result: {result}'>)> |
>
>
Ausgabe:
High Precision Result: 0.2>
Brüche für exakte Darstellungen verwenden
Derfractions>Das Modul ermöglicht das Arbeiten mit exakten Bruchdarstellungen und vermeidet Gleitkommafehler.
Python3
from> fractions>import> Fraction> result>=> Fraction(>'1.2'>)>-> Fraction(>'1.0'>)> print>(f>'Exact Fractional Result: {result}'>)> |
>
>
Ausgabe:
Exact Fractional Result: 1/5>
Umgang mit Zwischenergebnissen mit Dezimalzahlen
Benutzen Sie dieDecimal>Klasse für Zwischenberechnungen, um kumulative Fehler vor der Rückkonvertierung in Float zu minimieren.
Python3
from> decimal>import> Decimal, getcontext> getcontext().prec>=> 6> # Set precision to 6 decimal places> intermediate_result>=> Decimal(>'1.2'>)>-> Decimal(>'1.0'>)> final_result>=> float>(intermediate_result)># Convert back to float if needed> print>(f>'Intermediate Result: {intermediate_result}
Final Result: {final_result}'>)> |
>
>
Ausgabe:
Intermediate Result: 0.2 Final Result: 0.2>
Abschluss
Trotzdem denkst du darüber nach, warum Python löst dieses Problem nicht , eigentlich hat es nichts mit Python zu tun. Das liegt daran, dass die zugrunde liegende C-Plattform Gleitkommazahlen auf diese Weise verarbeitet, und aufgrund der Ungenauigkeit werden wir Zahlen immer als Folge einer festen Anzahl von Ziffern aufgeschrieben. Beachten Sie, dass dies in der Natur des binären Gleitkommas liegt: Auch hier handelt es sich nicht um einen Fehler Python oder C , und es ist auch kein Fehler in Ihrem Code. Sie werden in allen Sprachen, die die Gleitkomma-Arithmetik unserer Hardware unterstützen, das gleiche Verhalten feststellen, obwohl einige Sprachen den Unterschied möglicherweise nicht standardmäßig oder in allen Ausgabemodi anzeigen. Wir müssen dieses Verhalten berücksichtigen, wenn wir uns mit mathematischen Problemen befassen, bei denen genaue Genauigkeiten erforderlich sind oder wenn wir sie in bedingten Anweisungen verwenden. Überprüfen Gleitkomma Weitere Informationen zu solchen Verhaltensweisen finden Sie im Abschnitt in der Python-Dokumentation.
Häufig gestellte Fragen (FAQs)
1. Was ist ein Gleitkommafehler in Python?
Ein Gleitkommafehler in Python bezieht sich auf Diskrepanzen zwischen den erwarteten und tatsächlichen Ergebnissen beim Arbeiten mit Gleitkommazahlen, die sich aus den Einschränkungen bei der Darstellung reeller Zahlen in einem binärbasierten System ergeben.
2. Warum tut 1.2 - 1.0> nicht gleich 0.2> in Python?
Die Diskrepanz ist auf die inhärenten Herausforderungen bei der binären Darstellung von Dezimalzahlen zurückzuführen. Bei der internen Binärdarstellung treten Rundungsfehler auf, die zu unerwarteten Ergebnissen führen.
3. Ist der Gleitkommafehler ein Fehler in Python?
Nein, es ist kein Fehler in Python. Es handelt sich um ein häufiges Problem beim Rechnen, das mit der internen Darstellung von Gleitkommazahlen zusammenhängt. Python hält sich an den IEEE 754-Standard für Gleitkomma-Arithmetik.
Enum tostring Java
4. Wie kann ich ein Gleitkommaergebnis auf eine bestimmte Dezimalstelle runden?
Du kannst den ... benutzen
round()>Funktion zum Runden eines Gleitkommaergebnisses auf eine bestimmte Dezimalstelle. Zum Beispiel,rounded_result = round(result, 2)>.
5. Was ist der decimal> Modul und wie hilft es bei der Behandlung von Gleitkommafehlern?
Der
decimal>Modul bietet dieDecimal>Klasse für Arithmetik mit höherer Präzision. Präzision einstellen und verwendenDecimal>kann dabei helfen, Gleitkommafehler zu verringern.