Pythonクラスで等価（「等価」）をサポートするエレガントな方法

カスタムクラスを作成する場合、==and !=演算子を使用して同等性を許可することがしばしば重要になります。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

つまり、IDのテスト（つまり、「と同じオブジェクトですか？」）が実際に実行a == bされるFalseため、に評価されます。a is bab

とき__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__ように、同様の機能をドキュメントの状態：

比較演算子間に暗黙の関係はありません。の真実は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<y or x==y)ません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には2種類のクラスがあります。

• クラシックなスタイル（または古いスタイルでください）クラスではないから継承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クラシックスタイルクラスの==and !=演算子の非可換性の問題を修正するには、オペランドの型がサポートされていない場合に__eq__and __ne__メソッドがNotImplemented値を返す必要があります。ドキュメントには、定義NotImplementedとしての価値を：

数値メソッドと豊富な比較メソッドは、提供されたオペランドの演算を実装していない場合、この値を返すことがあります。（インタープリターは、オペレーターに応じて、反映された操作またはその他のフォールバックを試行します。）その真理値は真です。

この場合、演算子は比較演算を他のオペランドのリフレクトメソッドに委譲します。ドキュメント：定義のような方法を反映しました

これらのメソッドのスワップされた引数のバージョンはありません（左側の引数が操作をサポートしていないが、右側の引数はサポートしている場合に使用されます）。むしろ、__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

継承には注意する必要があります。

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

その上、あなたのアプローチはうまくいきます、それが特別な方法があるためです。

あなたが説明する方法は、私がいつもそれをしてきた方法です。完全に汎用的なため、いつでもその機能をミックスインクラスに分割し、その機能を必要とするクラスに継承することができます。

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

直接的な回答ではありませんが、時々冗長な退屈な作業を省くため、十分に関連性があるように思われました。ドキュメントから直接カット...

functools.total_ordering（cls）

1つまたは複数の豊富な比較順序付けメソッドを定義するクラスが与えられると、このクラスデコレータが残りを提供します。これにより、可能な豊富な比較操作のすべてを指定するための作業が簡素化されます。

クラスは次のいずれかを定義しなければならない__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()))

あなたは、両方をオーバーライドする必要はありません__eq__し、__ne__あなただけ上書きすることができます__cmp__が、これは==、！==、<、>などの結果に意義を行います。

isオブジェクトの同一性をテストします。これは、isa Trueとbの両方が同じオブジェクトへの参照を保持している場合にa bが存在することを意味します。Pythonでは常に、実際のオブジェクトではなく変数内のオブジェクトへの参照を保持するため、基本的にaがbである場合、それらのオブジェクトは同じメモリ位置に配置する必要があります。どのようにそして最も重要なのに、なぜあなたはこの振る舞いをオーバーライドしようとするのですか？

編集：私は__cmp__python 3から削除されたことを知りませんでしたので、それを避けてください。

この回答から：https : //stackoverflow.com/a/30676267/541136私はそれを実証しましたが、__ne__用語で定義することは正しいです__eq__-の代わりに

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

あなたは使うべきです：

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

私が探している2つの用語は、平等（==）と同一性（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

'is'テストは、本質的にオブジェクトのメモリアドレスを返す組み込みの 'id（）'関数を使用して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オブジェクトは余分な（ほとんどの場合同一の）ロジックの負担を負いません。

サブクラス化/ミックスインを使用する代わりに、ジェネリッククラスデコレーターを使用したい

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

これにはAlgoriasの回答に関するコメントが組み込まれており、dict全体については気にしないので、オブジェクトを単一の属性で比較します。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