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

你描述的方式就是我一直用的方式。由于它是完全泛型的，所以您总是可以将该功能分解到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

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

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

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

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

你需要小心继承:

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

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

我喜欢使用泛型类装饰器，而不是使用子类化/mixins

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