比较Python dict与包含的浮点值

我想比较一对字典并使用“fuzzy”浮点比较，或者更好地使用

numpy.allclose（）。但是，使用默认的
==
或
=不能做到这一点

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

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

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

我想使用
=
比较这两个dict，如果唯一的差异是某个范围内的浮点数，则返回
True
。例如，如果值接近（还不确定我想要的精度），则不要计算不同的值

我想我可以自己递归地检查dicts，手动使用
numpy.allclose（）
进行浮点值测试，然后返回到所有其他类型的正常相等性测试，等等。但是，这有点棘手，而且容易出错。我确实认为这是一个可以接受的解决方案，我希望看到一个这样的解决方案。希望有更优雅的东西

我脑海中优雅的解决方案如下所示。然而，我不知道这样的事情是否可能：

with hacked_float_compare:
    result = d1 != d2

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

同样，我不确定这是否可行，因为猴子补丁
float（）
实际上无法完成，因为它是用
C
编写的。我还希望避免不得不将dicts中的每个浮点值都更改为我自己的float类，该类具有
\uuuueq\uuuuo（）
。也许这是最好的方法？
要覆盖比较运算符，您需要定义一个使用不同运算符的派生类。因此，您不能按照建议的方式进行操作。您可以做的是派生一个“模糊浮点”类（如@Null）建议，或从
dict
派生和分类，并指定它在浮点上使用模糊比较：

class fuzzydict(dict):
    def __eq__(self, other):
        """Manually compare each element of `self` with `other`.
           Float values are compared up to reasonable precision."""

你必须自己翻阅字典比较的逻辑，它可能不会像内置比较那样快，但你可以在代码中写入
dict1==dict2
。只要确保对所有可能包含浮点的（嵌套）字典使用
fuzzydict
，而不是
dict

然而，我应该补充一点，你正在冒着不确定性的风险：你的字典会比较相等，但包含的数字略有不同，因此，根据你使用的字典，后续计算可能会得出不相等的结果。在我看来，更安全（更理智）方法是在字典中插入浮点数时将它们四舍五入，以便它们严格相等。
避免对内置类型进行子类化。当您发现您的对象由于未知原因更改了类型时，您会后悔。请改用委派。例如：

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

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


关于为什么不应该将内置的子类化

这个解决方案似乎简单而正确，但通常不是。
首先，即使您可以对内置类型进行子类化，但这并不意味着它们是作为子类来编写的，因此您可能会发现，要使某些东西正常工作，您必须编写比您想象的更多的代码

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

例如，子类化
list
您可能会认为，由于
list
只实现
\uuud\uud\uud
和
\uud\uud\uud
您可以安全地重新实现这两种方法，但您错了！您还必须实现
\uradd\uud\uud
，否则表达式如下：

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

将返回一个正常的
列表
，而不是
MyList

总之，子类化内置的后果比您一开始想象的要严重得多，而且由于类型或行为的更改，它可能会引入一些不可预测的错误，这是您没有预料到的。调试也变得更加困难，因为您不能简单地在日志中打印对象的实例，因此表示将是正确的t！您确实必须检查周围所有对象的类，以捕获这些微妙的bug

在您的特定情况下，如果您计划只在单个方法中转换字典，那么您可以避免子类化
dict
的大多数缺点，但是在这一点上，为什么不简单地编写一个函数并将
dict
与之进行比较呢？
这应该可以很好地工作，除非您想将dict传递给进行比较的库函数。
仅供参考，我认为在我的情况下，子类化不是最好的方法。我已经制定了一个最有可能使用的解决方案

这不是公认的答案，因为这是一种基于我从这个线程中学到的协作方法。只是想要一个其他人可以从中受益的“解决方案”。
一个选项是为float创建一个包装器，并覆盖那里的
\uuuuuueq\uuuu
。但是您需要使用
fuzz创建所有的float
[1,2,3] + MyList([1,2,3])