你需要小心继承:

>>> 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

除此之外，你的方法也可以很好地工作，这就是特殊方法的用途。

我认为你要找的两个术语是相等(==)和同一性(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

我用__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_orders

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

测试对象标识。这意味着当a和b都持有对同一对象的引用时，a是b将为True。在python中，你总是在变量中保存一个对象的引用，而不是实际的对象，所以本质上，a是b，它们中的对象应该位于相同的内存位置。最重要的是，你要如何覆盖这种行为?

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

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

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

'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对象不承担所有额外的(在大多数情况下相同)逻辑的负担。