用于浮点数集合的Python单元测试中的AssertalPosteQual

Question

Python的单元测试框架中的assertAlmostEqual（x， y）方法测试x和y是否近似相等，假设它们是浮点数。

assertAlmostEqual（）的问题在于它只在浮动上工作。我正在寻找一种类似于assertAlmostEqual（）的方法，它适用于浮点数列表、浮点数集、浮点数字典、浮点数元组、浮点数元组列表、浮点数列表集等。

例如，让x=0.1234567890，y=0.1234567891x和y几乎相等，因为它们在每个数字上都一致，但最后一个数字除外。因此，self。assertAlmostEqual（x，y）为True，因为assertAlmostEqual（）适用于浮动。

我正在寻找一个更通用的assertAlmostEquals（），它还计算对True的以下调用：

• self.assertAlmostEqual_generic（[x， x， x]，[y， y， y]）.
• self.assertAlmostEqual_generic（{1： x，2： x，3： x}，{1： y，2： y，3： y}）.
• self.assertAlmostEqual_generic（[（x， x）]，[（y， y）]）.

有没有这样的方法，还是要我自己去实施？

澄清：

>

assertAlmostEquals（）有一个名为places的可选参数，通过计算四舍五入到小数位数的差值来比较这些数字。默认情况下places=7，因此self。assertAlmostEqual（0.5,0.4）为False，而为self。AssertalPosteQual（0.12345678，0.12345679）为真。我的推测性assertAlmostEqual\u generic（）应该具有相同的功能。

如果两个列表的数字几乎相等，且顺序完全相同，则认为它们几乎相等。形式上，表示范围（n）中的i:self。assertAlmostEqual（列表1[i]，列表2[i]）。

类似地，如果可以将两个集合转换为几乎相等的列表（通过为每个集合指定顺序），则认为它们几乎相等。

类似地，如果每个字典的密钥集几乎等于另一个字典的密钥集，则认为两个字典几乎相等，并且对于每个几乎相等的密钥对，都有一个对应的几乎相等的值。

一般来说，我认为两个集合几乎相等，如果它们是相等的，除了一些对应的浮点，它们几乎彼此相等。换句话说，我希望真正比较对象，但在比较浮动时，精度较低（自定义）。




Answer 1

匿名用户

下面是我如何实现一个通用的is_almost_equal（第一，第二）函数：

首先，复制需要比较的对象（第一个和第二个），但不要复制一个精确的副本：剪切对象内部遇到的任何浮点小数。

现在您已经有了无小数点的first和second副本，只需使用=操作符比较first和second。

假设我们有一个递归（obj，places）函数，它复制了obj，但只在原始obj中保留每个浮点数的places最高有效小数位数。下面是几乎等于（第一，第二，位置）的一个工作实现：

from insignificant_digit_cutter import cut_insignificant_digits_recursively

def is_almost_equal(first, second, places):
    '''returns True if first and second equal. 
    returns true if first and second aren't equal but have exactly the same
    structure and values except for a bunch of floats which are just almost
    equal (floats are almost equal if they're equal when we consider only the
    [places] most significant digits of each).'''
    if first == second: return True
    cut_first = cut_insignificant_digits_recursively(first, places)
    cut_second = cut_insignificant_digits_recursively(second, places)
    return cut_first == cut_second

下面是一个递归（obj，places）剪切不重要数字的工作实现：

def cut_insignificant_digits(number, places):
    '''cut the least significant decimal digits of a number, 
    leave only [places] decimal digits'''
    if  type(number) != float: return number
    number_as_str = str(number)
    end_of_number = number_as_str.find('.')+places+1
    if end_of_number > len(number_as_str): return number
    return float(number_as_str[:end_of_number])

def cut_insignificant_digits_lazy(iterable, places):
    for obj in iterable:
        yield cut_insignificant_digits_recursively(obj, places)

def cut_insignificant_digits_recursively(obj, places):
    '''return a copy of obj except that every float loses its least significant 
    decimal digits remaining only [places] decimal digits'''
    t = type(obj)
    if t == float: return cut_insignificant_digits(obj, places)
    if t in (list, tuple, set):
        return t(cut_insignificant_digits_lazy(obj, places))
    if t == dict:
        return {cut_insignificant_digits_recursively(key, places):
                cut_insignificant_digits_recursively(val, places)
                for key,val in obj.items()}
    return obj

代码及其单元测试可以在这里获得：https://github.com/snakile/approximate_comparator.我欢迎任何改进和错误修复。

Answer 2

从python 3.5开始，您可以使用

math.isclose(a, b, rel_tol=1e-9, abs_tol=0.0)

如pep-0485所述。实施应等同于

abs(a-b) <= max( rel_tol * max(abs(a), abs(b)), abs_tol )

Answer 3

如果您不介意使用NumPy（随您的Python（x，y）附带），您可能需要查看定义assert_almost_equal函数的np.testing模块。

签名是np。测试。断言几乎相等（实际值、期望值、小数=7、err\u msg=''、verbose=True）

>>> x = 1.000001
>>> y = 1.000002
>>> np.testing.assert_almost_equal(x, y)
AssertionError: 
Arrays are not almost equal to 7 decimals
ACTUAL: 1.000001
DESIRED: 1.000002
>>> np.testing.assert_almost_equal(x, y, 5)
>>> np.testing.assert_almost_equal([x, x, x], [y, y, y], 5)
>>> np.testing.assert_almost_equal((x, x, x), (y, y, y), 5)