我想比较一对字典并使用“模糊” float 比较或更好地使用 numpy.allclose() 来这样做。但是，在 Python 中为字典使用默认的 == 或 != 不会执行此操作。

我想知道是否有办法改变浮点比较操作(可能使用上下文管理器进行安全清理)。

我相信一个例子会有所帮助。我有一个包含各种值的深层嵌套字典。其中一些值是浮点值。我知道“比较”浮点值等有很多陷阱。

d1 = {'a': {'b': 1.123456}}
d2 = {'a': {'b': 1.1234578}}

我想使用 != 来比较这两个字典，如果唯一的区别是某个范围内的 float ，则让它返回 True。例如，如果接近(还不确定我想要的精度)，则不要计算不同的值。

我想我可以自己递归地检查字典并手动只使用 numpy.allclose() 来获取浮点值，然后回退到对所有其他类型等的正常相等性测试。但是，这有点棘手且容易出错。我确实认为这是一个可以接受的解决方案，我很乐意看到这样的解决方案。希望有更优雅的东西。

我脑海中的优雅解决方案如下所示。但是，我不知道这样的事情是否可行:

with hacked_float_compare:
    result = d1 != d2

因此，在这个上下文管理器中，我将用我自己的比较或 numpy.allclose() 替换浮点比较(仅针对标准 float() 值) .

同样，我不确定这是否可行，因为猴子修补 float() 无法真正完成，因为它是用 C 编写的。我还想避免必须将字典中的每个浮点值更改为我自己的具有 __eq__() 的浮点类。也许这是最佳方式？

最佳答案

避免子类化内置类型。当您发现您的对象由于某种未知原因改变了类型时，您会后悔的。改用委派。例如:

import operator as op


class FuzzyDict(object):
    def __init__(self, iterable=(), float_eq=op.eq):
        self._float_eq = float_eq
        self._dict = dict(iterable)

    def __getitem__(self, key):
        return self._dict[key]

    def __setitem__(self, key, val):
        self._dict[key] = val

    def __iter__(self):
        return iter(self._dict)

    def __len__(self):
        return len(self._dict)

    def __contains__(self, key):
        return key in self._dict

    def __eq__(self, other):
        def compare(a, b):
            if isinstance(a, float) and isinstance(b, float):
                return self._float_eq(a, b)
            else:
                return a == b
        try:
            if len(self) != len(other):
                return False
            for key in self:
                if not compare(self[key], other[key]):
                    return False
            return True
        except Exception:
            return False

    def __getattr__(self, attr):
        # free features borrowed from dict
        attr_val = getattr(self._dict, attr)
        if callable(attr_val):
            def wrapper(*args, **kwargs):
                result = attr_val(*args, **kwargs)
                if isinstance(result, dict):
                    return FuzzyDict(result, self._float_eq)
                return result
            return wrapper
        return attr_val

还有一个用法示例:

>>> def float_eq(a, b):
...     return abs(a - b) < 0.01
... 
>>> A = FuzzyDict(float_eq=float_eq)
>>> B = FuzzyDict(float_eq=float_eq)
>>> A['a'] = 2.345
>>> A['b'] = 'a string'
>>> B['a'] = 2.345
>>> B['b'] = 'a string'
>>> B['a'] = 2.3445
>>> A == B
True
>>> B['a'] = 234.55
>>> A == B
False
>>> B['a'] = 2.345
>>> B['b'] = 'a strin'
>>> A == B
False

它们甚至在嵌套时也能工作:

>>> A['nested'] = FuzzyDict(float_eq=float_eq)
>>> A['nested']['a'] = 17.32
>>> B['nested'] = FuzzyDict(float_eq=float_eq)
>>> B['nested']['a'] = 17.321
>>> B['b'] = 'a string'   # changed before
>>> A == B
True
>>> B['nested']['a'] = 17.34
>>> A == B
False

dict 的完全替代将需要更多的代码，并且可能需要一些测试来了解它的健壮性，但即使是上述解决方案也提供了许多 dict 功能(例如，copy、setdefault、get、update 等)

关于为什么你不应该子类化一个内置的。

此解决方案看似简单且正确，但实际上并非如此。 首先，即使您可以子类化内置类型，但这并不意味着它们被编写为用作子类，因此您可能会发现要使某些东西正常工作，您必须编写比您想象的更多的代码。

此外，您可能希望使用内置方法，但这些方法将返回内置类型的实例而不是类的实例，这意味着您必须重新实现类型。此外，有时您还必须实现内置函数中未实现的其他方法。

例如，子类化 list 你可能认为，因为 list 只实现了 __iadd__ 和 __add__ 你重新实现这两个方法是安全的，但你错了!您还必须实现 __radd__，否则表达式如下:

[1,2,3] + MyList([1,2,3])

将返回一个普通的 list 而不是 MyList。

总而言之，对内置函数进行子类化的后果比您一开始想象的要多得多，并且它可能会由于您未预料到的类型或行为的变化而引入一些不可预测的错误。调试也变得更加困难，因为您不能简单地在日志中打印对象的实例，表示是正确的!您确实必须检查周围所有对象的类才能捕获这种细微的错误。

在您的特定情况下，如果您计划仅在单个方法内转换字典，那么您可以避免子类化 dict 的大部分缺点，但在这一点上，您为什么不简单地编写一个函数并将 dict 与其进行比较？ 这应该可以正常工作，除非您想将 dict 传递给进行比较的库函数。

关于python - 将 Python 字典与包含的浮点值进行比较，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13749218/