在 Python 类中支持等价（“相等”）的优雅方法

Question

编写自定义类时，通过 == 和 != 运算符允许等效性通常很重要。 在 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__ 的方法有什么特别的缺点吗？

注意：一点澄清——当 __eq__ 和 __ne__ 未定义时，您会发现以下行为：

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

即 a == b 的计算结果为 False 因为它确实运行了 a is b，即身份测试（即“Is a与 b 相同的对象？”）。

当定义 __eq__ 和 __ne__ 时，您会发现这种行为（这就是我们所追求的行为）：

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

Answer 1

另一种支持等价的优雅方式是使用@dataclass。 您的 Foo 示例将变为：

from dataclasses import dataclass

@dataclass
class Foo:
    item: int

就是这样！ 现在的行为如下：

a = Foo(1)
b = Foo(1)
print(a == b)  # True
c = Foo(2)
print(a == c)  # False

如果您的类需要提供其他实例属性，而这些属性不应在等效性中发挥作用，则在 __post_init__ 中定义它们，如下所示：

from dataclasses import dataclass
from random import randint

@dataclass
class Foo:
    age: int
    name: str
    
    def __post_init__(self):
        self.rnd = randint(1, 100000)

a = Foo(38, "Helen")
b = Foo(38, "Helen")
print(a == b)  # True
print(a.rnd == b.rnd)  # False, probably ;-)

Answer 2

我编写了一个带有 __ne__ 默认实现的自定义基类，它简单地否定了 __eq__：

class HasEq(object):
  """
  Mixin that provides a default implementation of ``object.__neq__`` using the subclass's implementation of ``object.__eq__``.

  This overcomes Python's deficiency of ``==`` and ``!=`` not being symmetric when overloading comparison operators
  (i.e. ``not x == y`` *does not* imply that ``x != y``), so whenever you implement
  `object.__eq__ <https://docs.python.org/2/reference/datamodel.html#object.__eq__>`_, it is expected that you
  also implement `object.__ne__ <https://docs.python.org/2/reference/datamodel.html#object.__ne__>`_

  NOTE: in Python 3+ this is no longer necessary (see https://docs.python.org/3/reference/datamodel.html#object.__ne__)
  """

  def __ne__(self, other):
    """
    Default implementation of ``object.__ne__(self, other)``, delegating to ``self.__eq__(self, other)``.

    When overriding ``object.__eq__`` in Python, one should also override ``object.__ne__`` to ensure that
    ``not x == y`` is the same as ``x != y``
    (see `object.__eq__ <https://docs.python.org/2/reference/datamodel.html#object.__eq__>`_ spec)

    :return: ``NotImplemented`` if ``self.__eq__(other)`` returns ``NotImplemented``, otherwise ``not self.__eq__(other)``
    """
    equal = self.__eq__(other)
    # the above result could be either True, False, or NotImplemented
    if equal is NotImplemented:
      return NotImplemented
    return not equal

如果您从这个基类继承，则只需实现 __eq__ > 和底座。

回想起来，更好的方法可能是将其实现为装饰器。 类似于 @functools.total_ordering

Answer 3

考虑这个简单的问题：

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__ 函数，以及文档< /a> 状态：

比较运算符之间没有隐含关系。 这
x==y 为真并不意味着 x!=y 为假。 因此，当
定义__eq__()，还应该定义__ne__()，以便
操作员将按预期行事。

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 中，这不再是必需的，因为 文档指出：

默认情况下，__ne__() 委托给 __eq__() 并反转结果
除非它是NotImplemented。 没有其他暗示
比较运算符之间的关系，例如真相
(x并不意味着 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 有两种类：

• 经典风格（或旧风格）类，不< /em> 继承自 object 并声明为 class A:、class A(): 或 class A(B) : 其中 B 是经典风格的类；

• 新风格 类，继承自 object 并声明为 class A(object) 或 class A(B)： 其中 B 是新式类。 Python 3 仅具有声明为 class A:、class A(object): 或 class A(B): 的新式类。

对于经典风格的类，比较操作总是调用第一个操作数的方法，而对于新风格的类，它总是调用子类操作数的方法，不管操作数的顺序。

所以在这里，如果 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 值。 文档定义了NotImplemented< /code> 值为：

数值方法和丰富的比较方法可能会返回此值，如果
它们不执行所提供的操作数的操作。 （这
然后解释器将尝试反射的操作，或其他一些
回退，取决于运算符。）其真值为 true。

在这种情况下，运算符将比较操作委托给其他操作数的反射方法。 文档将反射方法定义为：

这些方法没有交换参数版本（要使用
当左参数不支持操作但右参数不支持时
论证确实如此）； 相反，__lt__() 和 __gt__() 是彼此的
反射，__le__() 和 __ge__() 是彼此的反射，并且
__eq__() 和 __ne__() 是它们自己的反射。

结果如下所示：

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 是正确的做法，即使对于新式类，如果当操作数属于不相关类型（无继承）时，需要使用 == 和 != 运算符。

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

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

Answer 4

您需要小心继承：

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

>>> class Bar(Foo):pass

>>> b = Bar()
>>> f = Foo()
>>> f == b
True
>>> b == f
False

更严格地检查类型，如下所示：

def __eq__(self, other):
    if type(other) is type(self):
        return self.__dict__ == other.__dict__
    return False

除此之外，您的方法将正常工作，这就是特殊方法的用途。

Answer 5

你所描述的方式是我一直以来的做法。 由于它是完全通用的，因此您始终可以将该功能分解为 mixin 类，并在需要该功能的类中继承它。

class CommonEqualityMixin(object):

    def __eq__(self, other):
        return (isinstance(other, self.__class__)
            and self.__dict__ == other.__dict__)

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

class Foo(CommonEqualityMixin):

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

Answer 6

这不是一个直接的答案，但似乎足够相关，可以补充，因为它有时可以节省一些冗长的乏味。 直接从文档中剪切...

---

functools.total_ordering(cls)

< strong>给定一个定义一个或多个丰富比较排序方法的类，该类装饰器提供其余的内容。这简化了指定所有可能的丰富比较操作所涉及的工作：

该类必须定义以下之一：__lt__ ()、__le__()、__gt__() 或 __ge__()。 此外，该类应该提供一个 __eq__() 方法。

2.7版本新增

@total_ordering
class Student:
    def __eq__(self, other):
        return ((self.lastname.lower(), self.firstname.lower()) ==
                (other.lastname.lower(), other.firstname.lower()))
    def __lt__(self, other):
        return ((self.lastname.lower(), self.firstname.lower()) <
                (other.lastname.lower(), other.firstname.lower()))

Answer 7

您不必同时覆盖 __eq__ 和 __ne__ 您可以仅覆盖 __cmp__ 但这将对 == 的结果产生影响， !==, < ，> 等等。

is 测试对象身份。 这意味着当 a 和 b 都持有对同一对象的引用时，a is b 将为 True。 在Python中，您总是在变量中保存对对象的引用，而不是实际对象，因此本质上，对于a is b为真，它们中的对象应该位于相同的内存位置。 最重要的是，你为什么要重写这种行为？

编辑：我不知道 __cmp__ 已从 python 3 中删除，因此请避免使用它。

Answer 8

从这个答案： https://stackoverflow.com/a/30676267/541136 我已经证明了这一点，虽然这是正确的用 __eq__ 定义 __ne__ - 而不是

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

你应该使用：

def __ne__(self, other):
    return not self == other

Answer 9

我认为您要查找的两个术语是平等 (==) 和身份 (is)。 例如：

>>> a = [1,2,3]
>>> b = [1,2,3]
>>> a == b
True       <-- a and b have values which are equal
>>> a is b
False      <-- a and b are not the same list object

Answer 10

“is”测试将使用内置的“id()”函数来测试身份，该函数本质上返回对象的内存地址，因此不可重载。

但是，在测试类的相等性的情况下，您可能希望对测试更加严格，并且仅比较类中的数据属性：

import types

class ComparesNicely(object):

    def __eq__(self, other):
        for key, value in self.__dict__.iteritems():
            if (isinstance(value, types.FunctionType) or 
                    key.startswith("__")):
                continue

            if key not in other.__dict__:
                return False

            if other.__dict__[key] != value:
                return False

         return True

此代码将仅比较类的非函数数据成员并跳过任何私人的东西通常都是你想要的。 对于普通旧 Python 对象，我有一个实现 __init__、__str__、__repr__ 和 __eq__ 的基类，因此我的 POPO 对象不承担所有额外（并且在大多数情况下相同）逻辑的负担。

Answer 11

我不喜欢使用子类化/混合，而是使用通用类装饰器

def comparable(cls):
    """ Class decorator providing generic comparison functionality """

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

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

    cls.__eq__ = __eq__
    cls.__ne__ = __ne__
    return cls

用法：

@comparable
class Number(object):
    def __init__(self, x):
        self.x = x

a = Number(1)
b = Number(1)
assert a == b

Answer 12

这结合了对 Algorias 答案的评论，并通过单个属性比较对象，因为我不关心整个字典。 hasattr(other, "id") 必须为 true，但我知道这是因为我在构造函数中设置了它。

def __eq__(self, other):
    if other is self:
        return True

    if type(other) is not type(self):
        # delegate to superclass
        return NotImplemented

    return other.id == self.id