Python, sollte ich den Operator __ne __ () basierend auf __eq__ implementieren?

Python, sollte ich implementieren __ne__() operator basiert auf __eq__?

Kurze Antwort: Nein. Verwenden == statt der __eq__

In Python 3, != ist die negation der == standardmäßig, so dass Sie selbst dann nicht erforderlich, schreiben einen __ne__und die Dokumentation ist nicht mehr rechthaberisch auf das schreiben ein. Aber Bedenken Sie Raymond Hettinger Kommentar:

Den __ne__ Methode folgt automatisch aus __eq__ nur, wenn
__ne__ ist nicht bereits definiert) in einer Oberklasse. Also, wenn Sie
Erben von builtin, es ist am besten zu überschreiben beide.

Auch, wenn Sie müssen Ihren code in Python 2, befolgen Sie die Empfehlung für Python 2 und es funktioniert auch in Python 3 nur in Ordnung.

In Python 2 definieren Sie die __ne__ im Hinblick auf == statt der __eq__.
E. G.

class A(object):
    def __eq__(self, other):
        return self.value == other.value

    def __ne__(self, other):
        return not self == other # NOT `return not self.__eq__(other)`

Den Beweis sehen, dass

• Umsetzung __ne__() operator basiert auf __eq__ und
• nicht die Umsetzung __ne__ in Python 2 auf alle

falsche Verhalten in der Demo unten.

Lange Antwort

Den Dokumentation für Python 2 sagt:

Gibt es keine implizite Beziehungen zwischen den Vergleichs-Operatoren. Die
Wahrheit x==y bedeutet nicht, dass x!=y ist falsch. Entsprechend, wenn
Definition __eq__() sollte man auch definieren __ne__() so, dass die
Operatoren Verhalten sich wie erwartet.

So, dass bedeutet, dass, wenn wir definieren __ne__ im Hinblick auf die inverse von __eq__ können wir ein konsistentes Verhalten.

In diesem Abschnitt der Dokumentation wurde aktualisiert, für Python 3:

Standardmäßig __ne__() Delegierten __eq__() und invertiert das Ergebnis
es sei denn, es ist NotImplemented.

und in der "was ist neu" - Sektionsehen wir dieses Verhalten geändert hat:

• != gibt jetzt das Gegenteil von ==es sei denn == zurück NotImplemented.

Für die Umsetzung __ne__verwenden wir lieber die == Betreiber anstatt die __eq__ - Methode direkt, so dass, wenn self.__eq__(other) einer Unterklasse zurück NotImplemented für den Typ-geprüft, Python entsprechend zu überprüfen other.__eq__(self) Aus der Dokumentation:

Die NotImplemented Objekt

Dieser Typ hat einen einzigen Wert. Es ist ein einzelnes Objekt mit diesem Wert. Dieses Objekt zugegriffen wird durch die built-in-Namen
NotImplemented. Numerische Methoden und Reich-Vergleich Methoden zurückkehren können
diesen Wert, wenn Sie nicht implementieren die operation für die Operanden
zur Verfügung gestellt. (Der Dolmetscher wird dann versuchen, das reflektierte Vorgang, oder
einige andere fallback, je nach Betreiber.) Seine Wahrheit Wert ist
true.

Gegeben, wenn eine reiche Vergleichsoperator, wenn Sie nicht die gleiche Art, Python überprüft, ob die other ist ein Subtyp, und wenn es hat, dass der Betreiber definiert, verwendet es die other's Methode zuerst (umgekehrte für <<=>= und >). Wenn NotImplemented zurückgegeben wird, dann es nutzt die entgegengesetzte Methode. (Es tut nicht check für dieselbe Methode zweimal.) Mit der == operator ermöglicht, diese Logik zu erfolgen.

---

Erwartungen

Semantisch, Sie implementieren sollten __ne__ im Hinblick auf die Prüfung auf Gleichheit, weil die Benutzer Ihrer Klasse erwarten, dass die folgenden Funktionen gleichwertig für alle Instanzen A.:

def negation_of_equals(inst1, inst2):
    """always should return same as not_equals(inst1, inst2)"""
    return not inst1 == inst2

def not_equals(inst1, inst2):
    """always should return same as negation_of_equals(inst1, inst2)"""
    return inst1 != inst2

Ist, die beiden oben beschriebenen Funktionen sollten immer das gleiche Ergebnis zurückgeben. Aber dies ist abhängig von der Programmierer, wie Python selbst nicht automatisch umgesetzt, ein Vorgang in Begriffen eines anderen.

Demonstration von unerwartetem Verhalten beim definieren von __ne__ basierend auf __eq__:

Zuerst das setup:

class BaseEquatable(object):
    def __init__(self, x):
        self.x = x
    def __eq__(self, other):
        return isinstance(other, BaseEquatable) and self.x == other.x

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

class ComparableRight(BaseEquatable):
    def __ne__(self, other):
        return not self == other

class EqMixin(object):
    def __eq__(self, other):
        """override Base __eq__ & bounce to other for __eq__, e.g. 
        if issubclass(type(self), type(other)): # True in this example
        """
        return NotImplemented

class ChildComparableWrong(EqMixin, ComparableWrong):
    """__ne__ the wrong way (__eq__ directly)"""

class ChildComparableRight(EqMixin, ComparableRight):
    """__ne__ the right way (uses ==)"""

class ChildComparablePy3(EqMixin, BaseEquatable):
    """No __ne__, only right in Python 3."""

Instantiate non-equivalent-Instanzen:

right1, right2 = ComparableRight(1), ChildComparableRight(2)
wrong1, wrong2 = ComparableWrong(1), ChildComparableWrong(2)
right_py3_1, right_py3_2 = BaseEquatable(1), ChildComparablePy3(2)

Erwartetes Verhalten:

(Hinweis: während jede zweite Behauptung der jede der unten gleichwertig ist und daher logischerweise überflüssig vor, ich bin auch Ihnen zu zeigen, dass Reihenfolge spielt keine Rolle, wenn man eine Unterklasse der anderen.)

Diese Instanzen haben __ne__ umgesetzt mit ==:

>>> assert not right1 == right2
>>> assert not right2 == right1
>>> assert right1 != right2
>>> assert right2 != right1

Diesen Fällen die Prüfung unter Python 3, auch korrekt funktioniert:

>>> assert not right_py3_1 == right_py3_2
>>> assert not right_py3_2 == right_py3_1
>>> assert right_py3_1 != right_py3_2
>>> assert right_py3_2 != right_py3_1

Und daran erinnern, dass diese __ne__ umgesetzt mit __eq__ - dies ist zwar das erwartete Verhalten, die Implementierung ist falsch:

>>> assert not wrong1 == wrong2         # These are contradicted by the
>>> assert not wrong2 == wrong1         # below unexpected behavior!

Unerwartetes Verhalten:

Beachten Sie, dass in diesem Vergleich widerspricht die Vergleiche oben (not wrong1 == wrong2).

>>> assert wrong1 != wrong2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

und

>>> assert wrong2 != wrong1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

Nicht überspringen __ne__ in Python 2

Für den Nachweis, dass Sie sollten nicht überspringen Sie die Umsetzung __ne__ in Python 2 finden Sie im folgenden äquivalenten Objekte:

>>> right_py3_1, right_py3_1child = BaseEquatable(1), ChildComparablePy3(1)
>>> right_py3_1 != right_py3_1child # as evaluated in Python 2!
True

Dem obigen Ergebnis sollte False!

Python 3 Quelle

Den CPython-Implementierung ist in typobject.c:

    case Py_NE:
        /* By default, __ne__() delegates to __eq__() and inverts the result,
           unless the latter returns NotImplemented. */
        if (self->ob_type->tp_richcompare == NULL) {
            res = Py_NotImplemented;
            Py_INCREF(res);
            break;
        }
        res = (*self->ob_type->tp_richcompare)(self, other, Py_EQ);
        if (res != NULL && res != Py_NotImplemented) {
            int ok = PyObject_IsTrue(res);
            Py_DECREF(res);
            if (ok < 0)
                res = NULL;
            else {
                if (ok)
                    res = Py_False;
                else
                    res = Py_True;
                Py_INCREF(res);
            }
        }
break;

InformationsquelleAutor der Antwort Aaron Hall

Kurze Antwort: ja (aber Lesen Sie die Dokumentation, um es richtig zu machen)

Zwar interessant, Aaron Hall ' s Antwort ist nicht die richtige Art und Weise zu implementieren, die __ne__ Methode, denn mit der not self == other Umsetzung, die __ne__ Methode des anderen Operanden ist nie in Betracht gezogen. Im Gegensatz dazu, wie unten gezeigt, die Standard-Python-3 Umsetzung der __ne__ Methode, einen Operanden hat fallback auf die __ne__ Methode des anderen Operanden durch Rücksendung NotImplemented wenn seine __eq__ Methode gibt NotImplemented. ShadowRanger gab die korrekte Umsetzung der __ne__ Methode:

def __ne__(self, other):
    result = self.__eq__(other)

    if result is not NotImplemented:
        return not result

    return NotImplemented

Implementierung der Vergleichsoperatoren

Den Python Language Reference für Python 3 Staaten in Ihrer Kapitel III Daten-Modell:

object.__lt__(self, other)

object.__le__(self, other)

object.__eq__(self, other)

object.__ne__(self, other)

object.__gt__(self, other)

object.__ge__(self, other)

Diese sind die so genannten "Reich-Vergleich" Methoden. Die Korrespondenz
zwischen operator-Symbole und Methode Namen ist wie folgt: x<y Anrufe
x.__lt__(y)x<=y Anrufe x.__le__(y)x==y Anrufe x.__eq__(y)
x!=y Anrufe x.__ne__(y)x>y Anrufe x.__gt__(y)und x>=y
Anrufe x.__ge__(y).

Einer Reich-Vergleich-Methode zurückgeben kann die singleton - NotImplemented wenn
es nicht zu implementieren, den Betrieb für eine bestimmte paar der Argumente.

Gibt es keine getauscht-argument-Versionen dieser Methoden (zu verwendet werden
wenn das linke argument unterstützt nicht den Betrieb, aber die rechten
argument ist); vielmehr __lt__() und __gt__() sind gegenseitig
Reflexion __le__() und __ge__() jeweils anderen nachdenken, und
__eq__() und __ne__() sind Ihr eigenes Spiegelbild. Wenn die Operanden
sind von verschiedenen Arten, und der Rechte operand ist der Typ eine direkte oder
indirekte Unterklasse der linke operand den Typ, das reflektierte Methode der
der Rechte operand hat Priorität, ansonsten in der linken Operanden s Methode
die Priorität hat. Virtuelle Unterklassen nicht berücksichtigt.

Übersetzt diese in Python-code (operator_eq für ==operator_ne für !=operator_lt für <operator_gt für >operator_le für <= und operator_ge für >=):

def operator_eq(left, right):
    if isinstance(right, type(left)):
        result = right.__eq__(left)

        if result is NotImplemented:
            result = left.__eq__(right)
    else:
        result = left.__eq__(right)

        if result is NotImplemented:
            result = right.__eq__(left)

    if result is NotImplemented:
        result = left is right

    return result


def operator_ne(left, right):
    if isinstance(right, type(left)):
        result = right.__ne__(left)

        if result is NotImplemented:
            result = left.__ne__(right)
    else:
        result = left.__ne__(right)

        if result is NotImplemented:
            result = right.__ne__(left)

    if result is NotImplemented:
        result = left is not right

    return result


def operator_lt(left, right):
    if isinstance(right, type(left)):
        result = right.__gt__(left)

        if result is NotImplemented:
            result = left.__lt__(right)
    else:
        result = left.__lt__(right)

        if result is NotImplemented:
            result = right.__gt__(left)

    if result is NotImplemented:
        raise TypeError(f"'<' not supported between instances of '{type(left).__name__}' and '{type(right).__name__}'")

    return result


def operator_gt(left, right):
    if isinstance(right, type(left)):
        result = right.__lt__(left)

        if result is NotImplemented:
            result = left.__gt__(right)
    else:
        result = left.__gt__(right)

        if result is NotImplemented:
            result = right.__lt__(left)

    if result is NotImplemented:
        raise TypeError(f"'>' not supported between instances of '{type(left).__name__}' and '{type(right).__name__}'")

    return result


def operator_le(left, right):
    if isinstance(right, type(left)):
        result = right.__ge__(left)

        if result is NotImplemented:
            result = left.__le__(right)
    else:
        result = left.__le__(right)

        if result is NotImplemented:
            result = right.__ge__(left)

    if result is NotImplemented:
        raise TypeError(f"'<=' not supported between instances of '{type(left).__name__}' and '{type(right).__name__}'")

    return result


def operator_ge(left, right):
    if isinstance(right, type(left)):
        result = right.__le__(left)

        if result is NotImplemented:
            result = left.__ge__(right)
    else:
        result = left.__ge__(right)

        if result is NotImplemented:
            result = right.__le__(left)

    if result is NotImplemented:
        raise TypeError(f"'>=' not supported between instances of '{type(left).__name__}' and '{type(right).__name__}'")

    return result

Default-Implementierung des Vergleichs von Methoden

Die Dokumentation fügt hinzu:

Standardmäßig __ne__() Delegierten __eq__() und invertiert das Ergebnis
es sei denn, es ist NotImplemented. Es gibt keine anderen stillschweigenden
Beziehungen zwischen den Vergleichs-Operatoren, zum Beispiel, die Wahrheit
der (x<y or x==y) bedeutet nicht x<=y.

Die default-Implementierung der Methoden-Vergleich (__eq____ne____lt____gt____le__ und __ge__) somit gegeben durch:

def __eq__(self, other):
    return NotImplemented

def __ne__(self, other):
    result = self.__eq__(other)

    if result is not NotImplemented:
        return not result

    return NotImplemented

def __lt__(self, other):
    return NotImplemented

def __gt__(self, other):
    return NotImplemented

def __le__(self, other):
    return NotImplemented

def __ge__(self, other):
    return NotImplemented

So ist dies die korrekte Umsetzung der __ne__ Methode. Und es nicht immer wieder die inverse der __eq__ Methode, weil, wenn die __eq__ Methode gibt NotImplementeddessen Kehrwert not NotImplemented ist False (wie bool(NotImplemented) ist True) statt der gewünschten NotImplemented.

Fehlerhafte Implementierungen von __ne__

Als Aaron Hall oben gezeigt, not self.__eq__(other) ist nicht die korrekte Umsetzung der __ne__ Methode. Aber noch ist not self == other. Letztere ist unten gezeigt durch Vergleich des Verhaltens der Standard-Implementierung mit dem Verhalten der not self == other Umsetzung in zwei Fällen:

• die __eq__ Methode gibt NotImplemented;
• die __eq__ - Methode gibt einen Wert Verschieden von NotImplemented.

Default-Implementierung

Lassen Sie uns sehen, was passiert, wenn die A.__ne__ Methode verwendet die Standard-Implementierung und die A.__eq__ Methode gibt NotImplemented:

class A:
    pass


class B:

    def __ne__(self, other):
        return "B.__ne__"


assert (A() != B()) == "B.__ne__"

1. != Anrufe A.__ne__.
2. A.__ne__ Anrufe A.__eq__.
3. A.__eq__ zurück NotImplemented.
4. != Anrufe B.__ne__.
5. B.__ne__ zurück "B.__ne__".

Dies zeigt, dass, wenn die A.__eq__ Methode gibt NotImplementeddie A.__ne__ Methode fällt wieder auf die B.__ne__ Methode.

Nun wollen wir sehen, was passiert, wenn die A.__ne__ Methode verwendet die Standard-Implementierung und die A.__eq__ - Methode gibt einen Wert Verschieden von NotImplemented:

class A:

    def __eq__(self, other):
        return True


class B:

    def __ne__(self, other):
        return "B.__ne__"


assert (A() != B()) is False

1. != Anrufe A.__ne__.
2. A.__ne__ Anrufe A.__eq__.
3. A.__eq__ zurück True.
4. != zurück not Truedas ist False.

Dies zeigt, dass in diesem Fall die A.__ne__ Methode liefert das inverse der A.__eq__ Methode. So ist die __ne__ Methode verhält sich wie angekündigt in der Dokumentation.

Überschreiben der Standardimplementierung der A.__ne__ Methode mit der korrekten Umsetzung oben angegeben liefert die gleichen Ergebnisse.

not self == other Umsetzung

Lassen Sie uns sehen, was passiert, wenn das überschreiben der default-Implementierung des A.__ne__ Methode mit der not self == other Umsetzung und die A.__eq__ Methode gibt NotImplemented:

class A:

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


class B:

    def __ne__(self, other):
        return "B.__ne__"


assert (A() != B()) is True

1. != Anrufe A.__ne__.
2. A.__ne__ Anrufe ==.
3. == Anrufe A.__eq__.
4. A.__eq__ zurück NotImplemented.
5. == Anrufe B.__eq__.
6. B.__eq__ zurück NotImplemented.
7. == zurück A() is B()das ist False.
8. A.__ne__ zurück not Falsedas ist True.

Die default-Implementierung der __ne__ Methode zurückgegeben "B.__ne__"nicht True.

Nun wollen wir sehen, was passiert, wenn das überschreiben der default-Implementierung des A.__ne__ Methode mit der not self == other Umsetzung und die A.__eq__ - Methode gibt einen Wert Verschieden von NotImplemented:

class A:

    def __eq__(self, other):
        return True

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


class B:

    def __ne__(self, other):
        return "B.__ne__"


assert (A() != B()) is False

1. != Anrufe A.__ne__.
2. A.__ne__ Anrufe ==.
3. == Anrufe A.__eq__.
4. A.__eq__ zurück True.
5. A.__ne__ zurück not Truedas ist False.

Die default-Implementierung der __ne__ Methode auch zurückgegeben False in diesem Fall.

Da diese Umsetzung scheitert repliziert das Verhalten der Standardimplementierung der __ne__ - Methode, wenn die __eq__ Methode gibt NotImplemented ist es falsch.

InformationsquelleAutor der Antwort Maggyero