做一些像下面这样简单的事情就足够了:

return abs(f1 - f2) <= allowed_error

使用Python的decimal模块，该模块提供decimal类。

评论如下:

值得注意的是，如果你 做繁重的数学工作，而你没有 绝对需要精准的 小数，这很麻烦 下来。浮点数要快得多 处理，但不精确。小数是 非常精确但很慢。

I'm not aware of anything in the Python standard library (or elsewhere) that implements Dawson's AlmostEqual2sComplement function. If that's the sort of behaviour you want, you'll have to implement it yourself. (In which case, rather than using Dawson's clever bitwise hacks you'd probably do better to use more conventional tests of the form if abs(a-b) <= eps1*(abs(a)+abs(b)) + eps2 or similar. To get Dawson-like behaviour you might say something like if abs(a-b) <= eps*max(EPS,abs(a),abs(b)) for some small fixed EPS; this isn't exactly the same as Dawson, but it's similar in spirit.

浮点数不能相等比较的常识是不准确的。浮点数与整数没有什么不同:如果你计算“a == b”，如果它们是相同的数字，你就会得到真值，否则就会得到假值(要理解两个nan当然不是相同的数字)。

实际的问题是:如果我做了一些计算，但不确定我要比较的两个数字是否完全正确，那么该怎么办?这个问题对于浮点数和整数是一样的。如果计算整数表达式“7/3*3”，它将不等于“7*3/3”。

假设我们问"如何比较整数是否相等"在这种情况下。没有唯一的答案;你应该做什么取决于具体的情况，尤其是你有什么样的错误和你想要达到什么。

这里有一些可能的选择。

If you want to get a "true" result if the mathematically exact numbers would be equal, then you might try to use the properties of the calculations you perform to prove that you get the same errors in the two numbers. If that is feasible, and you compare two numbers that result from expressions that would give equal numbers if computed exactly, then you will get "true" from the comparison. Another approach is that you might analyze the properties of the calculations and prove that the error never exceeds a certain amount, perhaps an absolute amount or an amount relative to one of the inputs or one of the outputs. In that case, you can ask whether the two calculated numbers differ by at most that amount, and return "true" if they are within the interval. If you cannot prove an error bound, you might guess and hope for the best. One way of guessing is to evaluate many random samples and see what sort of distribution you get in the results.

当然，因为我们只设置了在数学上精确的结果相等的情况下获得“真”的要求，所以即使它们不相等，我们也保留了获得“真”的可能性。(事实上，我们可以通过总是返回“true”来满足这个要求。这使得计算简单，但通常是不可取的，所以我将在下面讨论如何改善这种情况。)

如果您希望在数学上精确的数字不相等时得到“错误”结果，则需要证明在数学上精确的数字不相等时，对数字的计算会产生不同的数字。在许多常见情况下，从实际的角度来看，这可能是不可能的。所以让我们考虑另一种选择。

A useful requirement might be that we get a "false" result if the mathematically exact numbers differ by more than a certain amount. For example, perhaps we are going to calculate where a ball thrown in a computer game traveled, and we want to know whether it struck a bat. In this case, we certainly want to get "true" if the ball strikes the bat, and we want to get "false" if the ball is far from the bat, and we can accept an incorrect "true" answer if the ball in a mathematically exact simulation missed the bat but is within a millimeter of hitting the bat. In that case, we need to prove (or guess/estimate) that our calculation of the ball's position and the bat's position have a combined error of at most one millimeter (for all positions of interest). This would allow us to always return "false" if the ball and bat are more than a millimeter apart, to return "true" if they touch, and to return "true" if they are close enough to be acceptable.

所以，在比较浮点数时，如何决定返回什么很大程度上取决于你的具体情况。

As to how you go about proving error bounds for calculations, that can be a complicated subject. Any floating-point implementation using the IEEE 754 standard in round-to-nearest mode returns the floating-point number nearest to the exact result for any basic operation (notably multiplication, division, addition, subtraction, square root). (In case of tie, round so the low bit is even.) (Be particularly careful about square root and division; your language implementation might use methods that do not conform to IEEE 754 for those.) Because of this requirement, we know the error in a single result is at most 1/2 of the value of the least significant bit. (If it were more, the rounding would have gone to a different number that is within 1/2 the value.)

Going on from there gets substantially more complicated; the next step is performing an operation where one of the inputs already has some error. For simple expressions, these errors can be followed through the calculations to reach a bound on the final error. In practice, this is only done in a few situations, such as working on a high-quality mathematics library. And, of course, you need precise control over exactly which operations are performed. High-level languages often give the compiler a lot of slack, so you might not know in which order operations are performed.

关于这个主题还有很多可以(也已经)写的东西，但我必须在这里停下来。总之，答案是:没有用于这种比较的库例程，因为没有适合大多数需求的单一解决方案值得放入库例程中。(如果比较相对或绝对误差间隔对您来说足够了，您可以不使用库例程简单地进行比较。)

我同意Gareth的答案可能是最合适的轻量级函数/解决方案。

但我认为，如果您正在使用NumPy或正在考虑使用NumPy，那么有一个打包的函数用于此，这将是有帮助的。

numpy.isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)

不过有一点免责声明:根据您的平台，安装NumPy可能是一种非常重要的体验。

我发现下面的比较很有帮助:

str(f1) == str(f2)

对于一些可以影响源数表示的情况，可以使用整数分子和整数分母将它们表示为分数而不是浮点数。这样你就可以进行准确的比较。

详见分数模块中的分数。

Python 3.5增加了数学运算。Isclose和cmath。isclose函数如PEP 485所述。

如果您使用的是较早版本的Python，相应的函数在文档中给出。

def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
    return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

Rel_tol是一个相对容差，它乘以两个参数的大小中较大的一个;当值变大时，它们之间允许的差异也会变大，但仍然认为它们相等。

Abs_tol是在所有情况下按原样应用的绝对容差。如果差值小于这些公差中的任何一个，则认为值相等。

如果你想在测试/TDD环境中使用它，我认为这是一种标准方法:

from nose.tools import assert_almost_equals

assert_almost_equals(x, y, places=7) # The default is 7

math.isclose()已为此添加到Python 3.5(源代码)。这里是它到Python 2的一个端口。它与Mark Ransom的单行程序的不同之处在于它可以正确地处理“inf”和“-inf”。

def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
    '''
    Python 2 implementation of Python 3.5 math.isclose()
    https://github.com/python/cpython/blob/v3.5.10/Modules/mathmodule.c#L1993
    '''
    # sanity check on the inputs
    if rel_tol < 0 or abs_tol < 0:
        raise ValueError("tolerances must be non-negative")

    # short circuit exact equality -- needed to catch two infinities of
    # the same sign. And perhaps speeds things up a bit sometimes.
    if a == b:
        return True

    # This catches the case of two infinities of opposite sign, or
    # one infinity and one finite number. Two infinities of opposite
    # sign would otherwise have an infinite relative tolerance.
    # Two infinities of the same sign are caught by the equality check
    # above.
    if math.isinf(a) or math.isinf(b):
        return False

    # now do the regular computation
    # this is essentially the "weak" test from the Boost library
    diff = math.fabs(b - a)
    result = (((diff <= math.fabs(rel_tol * b)) or
               (diff <= math.fabs(rel_tol * a))) or
              (diff <= abs_tol))
    return result

这可能是一个有点丑陋的hack，但当你不需要超过默认的浮点精度(大约11个小数)时，它工作得很好。

round_to函数使用内置str类中的format方法将浮点数四舍五入为表示浮点数的字符串，其中包含所需的小数数，然后将eval内置函数应用于四舍五入的浮点数字符串，以返回浮点数字类型。

is_close函数只是对四舍五入的浮点数应用一个简单的条件。

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

更新:

正如@stepehjfox所建议的，构建一个避免“eval”的rount_to函数的更干净的方法是使用嵌套格式:

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

遵循同样的思想，使用新的f-string (Python 3.6+)代码可以更简单:

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

所以，我们甚至可以用一个简单干净的'is_close'函数来概括它:

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

我喜欢Sesquipedal的建议，但有修改(一个特殊的用例时，两个值都是0返回False)。在我的例子中，我使用的是Python 2.7，只使用了一个简单的函数:

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

这对于你想要确保两个数字是相同的“达到精度”的情况很有用，并且不需要指定公差:

求这两个数的最小精度 将两者舍入到最小精度并进行比较

def isclose(a, b):
    astr = str(a)
    aprec = len(astr.split('.')[1]) if '.' in astr else 0
    bstr = str(b)
    bprec = len(bstr.split('.')[1]) if '.' in bstr else 0
    prec = min(aprec, bprec)
    return round(a, prec) == round(b, prec)

如上所述，它只适用于字符串表示中没有'e'的数字(意思是0.999999999999995e -4 < number <= 0.99999999999999995e11)

例子:

>>> isclose(10.0, 10.049)
True
>>> isclose(10.0, 10.05)
False

不带atol/rtol与给定小数进行比较:

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

print(almost_equal(0.0, 0.0001, decimal=5)) # False
print(almost_equal(0.0, 0.0001, decimal=4)) # True 

至于绝对误差，你可以检查一下

if abs(a - b) <= error:
    print("Almost equal")

一些关于Python中浮动行为怪异的信息: Python 3教程03 - if-else，逻辑运算符和初学者常犯的错误

你也可以用数学。相对误差接近。

使用==是一个简单的好方法，如果你不关心公差精确。

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

但是要注意0:

>>> 0 == 0.00000000000000000000000000000000000000000001
False

0始终是0。

使用数学。如果你想控制公差，是接近的。

默认值a == b等价于数学。Isclose (a, b, rel_tol=1e-16, abs_tol=0)。

如果你仍然想使用==带有自定义容差:

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

到目前为止，我没有找到任何地方配置它全局浮动。此外，mock也不能用于float.__eq__。

如果你想在测试或TDD上下文中使用pytest包，下面是如何做到的:

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)

如果你想比较浮点数，上面的选项很好，但在我的情况下，我最终使用Enum的，因为我只有几个有效的浮点数，我的用例可以接受。

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

然后运行:

testable_value = 2.0
HolidayMultipliers(testable_value)

如果float是有效的，就没问题，否则它会抛出一个ValueError。