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

Um bis zu einer bestimmten Dezimalstelle zu vergleichen, ohne atol/rtol:

def fast_gleich(a, b, dezimal=6):
    return '{0:.{1}f}'.format(a, dezimal) == '{0:.{1}f}'.format(b, dezimal)

print(fast_gleich(0.0, 0.0001, dezimal=5)) # False
print(fast_gleich(0.0, 0.0001, dezimal=4)) # True

Answer 2

Wenn Sie Floats vergleichen möchten, sind die oben genannten Optionen großartig, aber in meinem Fall habe ich Enum's verwendet, da ich nur wenige gültige Floats hatte, die mein Anwendungsfall akzeptierte.

from enum import Enum
class HolidayMultipliers(Enum):
    EMPLOYED_LESS_THAN_YEAR = 2.0
    EMPLOYED_MORE_THAN_YEAR = 2.5

Dann führen Sie aus:

testable_value = 2.0
HolidayMultipliers(testable_value)

Wenn der Float gültig ist, ist das in Ordnung, ansonsten wird einfach ein ValueError ausgelöst.

Answer 3

Ziemlich lahm, aber es funktioniert trotzdem

  def isEqual(f1, f2):
        f1 = float(f1)
        f2 = float(f2)
        ans1 = f1-f2
        ans2 = f2-f1
        return (ans1 == ans2)

Verwendung

 f1 = 4.000444
 f2 = 4.0
 print(isEqual(f1, f2))
 print(isEqual(f2, f2))

Sie können auch für die Annäherungsgleichheit runden

import math

def isEqual(f1, f2):
    f1 = math.ceil(f1)
    f2 = math.ceil(f2)
    ans1 = f1-f2
    ans2 = f2-f1
    return (ans1 == ans2)

was ich nicht weiß, ob es effizient für Ihre Anwendung ist!

Answer 4

Die Verwendung von == ist eine einfache gute Methode, wenn Sie sich nicht genau um Toleranz kümmern.

# Python 3.8.5
>>> 1.0000000000001 == 1
False
>>> 1.00000000000001 == 1
True

Aber achten Sie auf 0:

>>> 0 == 0.00000000000000000000000000000000000000000001
False

Die 0 ist immer die Null.

---

Verwenden Sie math.isclose, wenn Sie die Toleranz kontrollieren möchten.

Das Standardverhalten von a == b entspricht math.isclose(a, b, rel_tol=1e-16, abs_tol=0).

---

Wenn Sie trotzdem == mit einer selbstdefinierten Toleranz verwenden möchten:

>>> class MyFloat(float):
        def __eq__(self, another):
        return math.isclose(self, another, rel_tol=0, abs_tol=0.001)

>>> a == MyFloat(0)
>>> a
0.0
>>> a == 0.001
True

Bisher habe ich keinen globalen Ort gefunden, um es für float zu konfigurieren. Außerdem funktioniert mock auch nicht für float.__eq__.