在编写自定义类时，通过 == 和 != 运算符允许等价通常很重要。在 Python 中，这可以通过分别实现 __eq__ 和 __ne__ 特殊方法来实现。我发现最简单的方法是以下方法:

class Foo:
    def __init__(self, item):
        self.item = item

    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.__dict__ == other.__dict__
        else:
            return False

    def __ne__(self, other):
        return not self.__eq__(other)

你知道更优雅的方法吗？你知道使用上述比较 __dict__s 的方法有什么特别的缺点吗？

注意:澄清一下——当 __eq__ 和 __ne__ 未定义时，您会发现这种行为:

>>> a = Foo(1)
>>> b = Foo(1)
>>> a is b
False
>>> a == b
False

也就是说，a == b 的计算结果为 False，因为它确实运行 a is b，即身份测试(即“a 和 b 是同一个对象吗？").

当 __eq__ 和 __ne__ 被定义时，你会发现这种行为(这是我们所追求的):

>>> a = Foo(1)
>>> b = Foo(1)
>>> a is b
False
>>> a == b
True

最佳答案

考虑这个简单的问题:

class Number:

    def __init__(self, number):
        self.number = number


n1 = Number(1)
n2 = Number(1)

n1 == n2 # False -- oops

因此，Python 默认使用对象标识符进行比较操作:

id(n1) # 140400634555856
id(n2) # 140400634555920

覆盖 __eq__功能似乎解决了问题:

def __eq__(self, other):
    """Overrides the default implementation"""
    if isinstance(other, Number):
        return self.number == other.number
    return False


n1 == n2 # True
n1 != n2 # True in Python 2 -- oops, False in Python 3

在 Python 2 中，永远记得覆盖 __ne__功能也一样，documentation状态:

There are no implied relationships among the comparison operators. The truth of x==y does not imply that x!=y is false. Accordingly, when defining __eq__(), one should also define __ne__() so that the operators will behave as expected.

def __ne__(self, other):
    """Overrides the default implementation (unnecessary in Python 3)"""
    return not self.__eq__(other)


n1 == n2 # True
n1 != n2 # False

在 Python 3 中，这不再是必需的，因为 documentation状态:

By default, __ne__() delegates to __eq__() and inverts the result unless it is NotImplemented. There are no other implied relationships among the comparison operators, for example, the truth of (x<y or x==y) does not imply x<=y.

但这并不能解决我们所有的问题。让我们添加一个子类:

class SubNumber(Number):
    pass


n3 = SubNumber(1)

n1 == n3 # False for classic-style classes -- oops, True for new-style classes
n3 == n1 # True
n1 != n3 # True for classic-style classes -- oops, False for new-style classes
n3 != n1 # False

注意:Python 2 有两种类:

• classic-style (或旧式)类，不继承自object并且声明为 class A: , class A():或 class A(B):在哪里 B是经典风格的类；

• new-style 类，确实继承自 object并且声明为 class A(object)或 class A(B):在哪里 B是新式类。 Python 3 只有声明为 class A: 的新型类。 , class A(object):或 class A(B): .

对于经典类，比较操作总是调用第一个操作数的方法，而对于新类，它总是调用子类操作数的方法，regardless of the order of the operands .

所以在这里，如果 Number是经典风格的类:

• n1 == n3来电n1.__eq__ ;
• n3 == n1来电n3.__eq__ ;
• n1 != n3来电n1.__ne__ ;
• n3 != n1来电n3.__ne__ .

如果 Number是一个新式的类:

• 两者都是n1 == n3和 n3 == n1调用n3.__eq__ ;
• 两者都是n1 != n3和 n3 != n1调用n3.__ne__ .

修复 == 的不可交换性问题和 != Python 2 经典风格类的运算符 __eq__和 __ne__方法应该返回 NotImplemented不支持操作数类型时的值。 documentation定义 NotImplemented值为:

Numeric methods and rich comparison methods may return this value if they do not implement the operation for the operands provided. (The interpreter will then try the reflected operation, or some other fallback, depending on the operator.) Its truth value is true.

在这种情况下，运算符将比较操作委托(delegate)给其他操作数的反射方法。 documentation将反射方法定义为:

There are no swapped-argument versions of these methods (to be used when the left argument does not support the operation but the right argument does); rather, __lt__() and __gt__() are each other’s reflection, __le__() and __ge__() are each other’s reflection, and __eq__() and __ne__() are their own reflection.

结果如下:

def __eq__(self, other):
    """Overrides the default implementation"""
    if isinstance(other, Number):
        return self.number == other.number
    return NotImplemented

def __ne__(self, other):
    """Overrides the default implementation (unnecessary in Python 3)"""
    x = self.__eq__(other)
    if x is NotImplemented:
        return NotImplemented
    return not x

返回 NotImplemented值而不是 False如果 == 的 commutativity 是新式类的正确做法和 !=当操作数属于不相关类型(无继承)时，需要使用运算符。

我们到了吗？不完全的。我们有多少个唯一编号？

len(set([n1, n2, n3])) # 3 -- oops

集合使用对象的哈希值，默认情况下 Python 返回对象标识符的哈希值。让我们尝试覆盖它:

def __hash__(self):
    """Overrides the default implementation"""
    return hash(tuple(sorted(self.__dict__.items())))

len(set([n1, n2, n3])) # 1

最终结果是这样的(我在最后添加了一些断言进行验证):

class Number:

    def __init__(self, number):
        self.number = number

    def __eq__(self, other):
        """Overrides the default implementation"""
        if isinstance(other, Number):
            return self.number == other.number
        return NotImplemented

    def __ne__(self, other):
        """Overrides the default implementation (unnecessary in Python 3)"""
        x = self.__eq__(other)
        if x is not NotImplemented:
            return not x
        return NotImplemented

    def __hash__(self):
        """Overrides the default implementation"""
        return hash(tuple(sorted(self.__dict__.items())))


class SubNumber(Number):
    pass


n1 = Number(1)
n2 = Number(1)
n3 = SubNumber(1)
n4 = SubNumber(4)

assert n1 == n2
assert n2 == n1
assert not n1 != n2
assert not n2 != n1

assert n1 == n3
assert n3 == n1
assert not n1 != n3
assert not n3 != n1

assert not n1 == n4
assert not n4 == n1
assert n1 != n4
assert n4 != n1

assert len(set([n1, n2, n3, ])) == 1
assert len(set([n1, n2, n3, n4])) == 2

关于python - 在 Python 类中支持等价的优雅方法 ("equality")，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/390250/