Was ist der beste Weg, um in Python Floats auf fast Gleichheit zu vergleichen?

Question

Es ist bekannt, dass Vergleichen von Gleitkommazahlen auf Gleichheit aufgrund von Rundungs- und Präzisionsproblemen etwas kompliziert ist.

Zum Beispiel: Vergleichen von Gleitkommazahlen, Ausgabe 2012

Was ist der empfohlene Weg, um damit in Python umzugehen?

Gibt es irgendwo eine Standardbibliotheksfunktion dafür?

Answer 1

Für einige der Fälle, in denen Sie die Darstellung von Zahlen beeinflussen können, können Sie sie als Brüche anstelle von Fließkommazahlen darstellen, indem Sie einen ganzzahligen Zähler und Nenner verwenden. Auf diese Weise können Sie genaue Vergleiche durchführen.

Weitere Informationen finden Sie unter Bruch im fractions-Modul.

Answer 2

Ich mochte Sesquipedals Vorschlag, aber mit Modifikation (ein spezieller Anwendungsfall, bei dem beide Werte 0 zurückgeben). In meinem Fall war ich auf Python 2.7 und habe einfach eine einfache Funktion verwendet:

if f1 ==0 and f2 == 0:
    return True
else:
    return abs(f1-f2) < tol*max(abs(f1),abs(f2))

Answer 3

Wenn Sie dies in einem Test- oder TDD-Kontext mit dem pytest-Paket tun möchten, ist hier, wie:

import pytest

PRECISION = 1e-3

def assert_almost_equal():
    obtained_value = 99.99
    expected_value = 100.00
    assert obtained_value == pytest.approx(expected_value, PRECISION)

Answer 4

Ich fand den folgenden Vergleich hilfreich:

str(f1) == str(f2)

Answer 5

Dies ist vielleicht ein etwas hässlicher Hack, funktioniert aber ziemlich gut, wenn Sie nicht mehr als die Standard-Gleitkommagenauigkeit benötigen (etwa 11 Dezimalstellen).

Die round_to-Funktion verwendet die Format-Methode der integrierten str-Klasse, um die Gleitkommazahl auf eine Zeichenkette zu runden, die die Gleitkommazahl mit der erforderlichen Anzahl von Dezimalstellen darstellt, und wendet dann die integrierte Funktion eval auf die gerundete Gleitkommazahl-Zeichenkette an, um zum Gleitkommazahl-Numeriktyp zurückzukehren.

Die is_close-Funktion wendet einfach eine einfache Bedingung auf die aufgerundete Gleitkommazahl an.

def round_to(float_num, prec):
    return eval("'{:." + str(int(prec)) + "f}'.format(" + str(float_num) + ")")

def is_close(float_a, float_b, prec):
    if round_to(float_a, prec) == round_to(float_b, prec):
        return True
    return False

>>>a = 10.0
10.0
>>>b = 10.0001
10.0001
>>>print is_close(a, b, prec=3)
True
>>>print is_close(a, b, prec=4)
False

Update:

Wie von @stepehjfox vorgeschlagen, ein saubererer Weg, um eine round_to-Funktion zu erstellen, die "eval" vermeidet, ist die Verwendung von verschachtelter Formatierung:

def round_to(float_num, prec):
    return '{:.{precision}f}'.format(float_num, precision=prec)

Dem gleichen Gedanken folgend kann der Code sogar noch einfacher sein, wenn die großartigen neuen f-Strings (Python 3.6+) verwendet werden:

def round_to(float_num, prec):
    return f'{float_num:.{prec}f}'

Also könnten wir alles sogar in einer einfachen und sauberen Funktion 'is_close' zusammenfassen:

def is_close(a, b, prec):
    return f'{a:.{prec}f}' == f'{b:.{prec}f}'