Python __eq__ 中是否需要传递性？

Question

我正在使用自定义 __eq__ 实现我自己的类。对于数学意义上不“相等”，但模糊方式“匹配”的事物，我想返回 True。

然而，这样做的一个问题是，这会导致数学意义上的传递性丧失，即 a == b && b ==c，而a可能不等于c。

问题：Python 是否依赖于 __eq__ 的传递性？我想要做的事情会破坏事情吗？或者只要我小心翼翼地不假设传递性就可以做到这一点吗？

用例

我想要将电话号码彼此匹配，而这些电话号码可以是国际格式的，也可以仅供国内使用（没有指定国家/地区代码）。如果没有指定国家/地区代码，我希望一个数字等于带有 1 的数字，但如果指定了，它应该只等于具有相同国家/地区代码或不带有 1 的数字。

所以：

• 当然，+31 6 12345678应该等于+31 6 12345678，而06 12345678应该等于06 12345678 >
• +31 6 12345678 应等于 06 12345678（和 vv）
• +49 6 12345678 应该等于 06 12345678（和 vv）
• 但是 +31 6 12345678 不应该是等于 +49 6 12345678

我不需要散列（所以不会实现它），这样至少让生活变得更轻松。

Answer 1

对于与通常理解的关系一致的比较，没有“必须”关系，而是“应该”关系。 Python 明确地不强制执行此操作，并且 float 是一种内置类型，由于 float("nan") 而具有不同的行为。

表达式：值比较

[…]
如果可能的话，自定义比较行为的用户定义的类应该遵循一些一致性规则：

• […]
• 比较应该是对称的。换句话说，以下表达式应该具有相同的结果：
  • x == y 和 y == x
  • x != y 和 y != x
  • <代码>x < y 和 y > x
  • x <= y 和 y >= x
• 比较应该是传递性的。以下（非详尽的）示例说明了这一点：
  • x > y 和 y > z 意味着 x > z
  • x < y 和 y <= z 意味着 x < z

Python 不强制执行这些一致性规则。事实上，非数字值就是不遵守这些规则的一个例子。

不过，请记住，异常非常罕见，并且很容易被忽略：大多数人会对待 float 例如，具有全序。使用不常见的比较关系会严重增加维护工作量。

---

通过运算符对“模糊匹配”进行建模的规范方法是使用不对称运算符作为子集、子序列或包含。

• set 和 frozenset 支持 >、>= 等，表示一个集合包含所有值另一个。

  >>> a, b = {1, 5, 6, 8}, {5, 6}
  >>>>> a>=a，a>=b，b>=a
  （真、真、假）
  

• str 和 bytes 支持 in 来指示子序列被覆盖。

  >>> a、b =“+31 6 12345678”、“6 12345678”
  >>>>> a在b中，b在a中
  （假，真）
  

• range 和 ipaddress 网络支持 in 来指示覆盖特定项目。

  >>> IPv4网络('192.0.2.0/28')中的IPv4地址('192.0.2.6')
  真的
  

值得注意的是，虽然这些运算符可能是传递的，但它们不是对称的。例如，a >= b 和 c >= b 并不意味着 b >= c，因此也不是 a >= c > 或反之亦然。

实际上，可以将“不带国家/地区代码的号码”建模为同一号码的“带国家/地区代码的号码”的超集。这意味着 06 12345678 >= +31 6 12345678 和 06 12345678 >= +49 6 12345678 但反之则不然。为了进行对称比较，可以使用 a >= b 或 b >= a 而不是 a == b。

Answer 2

__eq__ 方法应该是传递的；至少字典是这么认为的。

class A:
    def __init__(self, name):
        self.name = name

    def __eq__(self, other):
        for element in self.values:
            if element is other:
                return True
        return False

    def __hash__(self):
        return 0

    def __repr__(self):
        return self.name

x, y, z = A('x'), A('y'), A('z')
x.values = [x,y]
y.values = [x,y,z]
z.values = [y,z]

print(x == y)
--> True

print (y == z)
--> True

print(x == z)
--> False

print({**{x:1},**{y:2, z: 3}})
--> {x: 3}

print({**{x:1},**{z:3, y:2}})
--> {x: 1, z: 2}

{**{x:1},**{y: 2, z:3}} 是两个字典的并集。没有人希望字典在更新后删除某个键。

print(z in {**{x:1},**{y:2, z: 3}})
--> False

通过更改联合中的顺序，您甚至可以获得不同大小的字典：

print(len({**{x:1},**{y:2, z: 3}}))
--> 1

print(len({**{x:1},**{z:3, y:2}}))
--> 2