Elegante Möglichkeiten zur Unterstützung der Äquivalenz („Gleichheit“) in Python-Klassen

Beim Schreiben von benutzerdefinierten Klassen ist es häufig wichtig, die Äquivalenz mithilfe der Operatoren ==und zuzulassen !=. In Python wird dies durch die Implementierung der jeweiligen __eq__bzw. der __ne__speziellen Methode ermöglicht. Der einfachste Weg, dies zu tun, ist die folgende Methode:

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)

Kennen Sie elegantere Mittel, um dies zu tun? Kennen Sie besondere Nachteile bei der Verwendung der oben genannten Methode zum Vergleichen von __dict__s?

Hinweis : Ein bisschen Klarstellung - wenn __eq__und __ne__undefiniert, finden Sie dieses Verhalten:

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

Das heißt, a == bbewertet, Falseweil es wirklich läuft a is b, einen Identitätstest (dh "Ist adas gleiche Objekt wie b?").

Wenn __eq__und __ne__definiert sind, finden Sie dieses Verhalten (das ist das, nach dem wir suchen):

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

Betrachten Sie dieses einfache Problem:

class Number:

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


n1 = Number(1)
n2 = Number(1)

n1 == n2 # False -- oops

Daher verwendet Python standardmäßig die Objektkennungen für Vergleichsoperationen:

id(n1) # 140400634555856
id(n2) # 140400634555920

Das Überschreiben der __eq__Funktion scheint das Problem zu lösen:

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

Denken Sie in Python 2 immer daran, die __ne__Funktion ebenfalls zu überschreiben , wie in der Dokumentation angegeben :

Es gibt keine impliziten Beziehungen zwischen den Vergleichsoperatoren. Die Wahrheit von x==ybedeutet nicht, dass dies x!=yfalsch ist. Dementsprechend sollte beim Definieren __eq__()auch definiert werden __ne__(), dass sich die Operatoren wie erwartet verhalten.

def __ne__(self, other):
    """Overrides the default implementation (unnecessary in Python 3)"""
    return not self.__eq__(other)


n1 == n2 # True
n1 != n2 # False

In Python 3 ist dies nicht mehr erforderlich, wie in der Dokumentation angegeben :

Standardmäßig __ne__()delegiert __eq__()und invertiert das Ergebnis, sofern dies nicht der Fall ist NotImplemented. Es gibt keine anderen impliziten Beziehungen zwischen den Vergleichsoperatoren, zum Beispiel (x<y or x==y)impliziert die Wahrheit von nicht x<=y.

Das löst aber nicht alle unsere Probleme. Fügen wir eine Unterklasse hinzu:

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

Hinweis: Python 2 hat zwei Arten von Klassen:

• Klassen im klassischen Stil (oder im alten Stil ), die nicht erbenobjectund als deklariertclass A:sindclass A():oderclass A(B):woBsich eine Klasse im klassischen Stil befindet;

• Klassen neuen Stils , die voneiner Klasse neuen Stilserbenobjectund alsclass A(object)oderclass A(B):wodeklariert sindB. Python 3 enthält nur Klassen neuen Stils, die alsoderdeklariertclass A:sind.class A(object):class A(B):

Bei Klassen im klassischen Stil ruft eine Vergleichsoperation immer die Methode des ersten Operanden auf, während bei Klassen im neuen Stil unabhängig von der Reihenfolge der Operanden immer die Methode des Operanden der Unterklasse aufgerufen wird .

Also hier, wenn Numberes sich um eine Klasse im klassischen Stil handelt:

• n1 == n3Anrufe n1.__eq__;
• n3 == n1Anrufe n3.__eq__;
• n1 != n3Anrufe n1.__ne__;
• n3 != n1Anrufe n3.__ne__.

Und wenn Numberes sich um eine neue Klasse handelt:

• beide n1 == n3und n3 == n1anrufen n3.__eq__;
• beide n1 != n3und n3 != n1anrufen n3.__ne__.

Um das Nichtkommutativitätsproblem der Operatoren ==und !=für Python 2-Klassen im klassischen Stil zu beheben , sollten die Methoden __eq__und __ne__den NotImplementedWert zurückgeben, wenn ein Operandentyp nicht unterstützt wird. Die Dokumentation definiert den NotImplementedWert als:

Numerische Methoden und umfangreiche Vergleichsmethoden können diesen Wert zurückgeben, wenn sie die Operation für die angegebenen Operanden nicht implementieren. (Der Interpreter versucht dann die reflektierte Operation oder einen anderen Fallback, abhängig vom Operator.) Sein Wahrheitswert ist wahr.

In diesem Fall delegiert der Operator die Vergleichsoperation an die reflektierte Methode des anderen Operanden. In der Dokumentation werden reflektierte Methoden wie folgt definiert:

Es gibt keine Versionen dieser Methoden mit ausgetauschten Argumenten (die verwendet werden sollen, wenn das linke Argument die Operation nicht unterstützt, das rechte Argument jedoch). vielmehr __lt__()und __gt__()sind die Reflexion des anderen __le__()und __ge__()sind die Reflexion des anderen und __eq__()und __ne__()sind ihre eigene Reflexion.

Das Ergebnis sieht folgendermaßen aus:

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

Die Rückgabe des NotImplementedWerts anstelle von Falseist auch für Klassen neuen Stils das Richtige, wenn die Kommutativität der Operatoren ==und !=gewünscht wird, wenn die Operanden nicht verwandte Typen haben (keine Vererbung).

Sind wir schon da? Nicht ganz. Wie viele eindeutige Nummern haben wir?

len(set([n1, n2, n3])) # 3 -- oops

Sets verwenden die Hashes von Objekten, und Python gibt standardmäßig den Hash des Bezeichners des Objekts zurück. Versuchen wir es zu überschreiben:

def __hash__(self):
    """Overrides the default implementation"""
    return hash(tuple(sorted(self.__dict__.items())))

len(set([n1, n2, n3])) # 1

Das Endergebnis sieht folgendermaßen aus (ich habe am Ende einige Aussagen zur Validierung hinzugefügt):

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

Sie müssen mit der Vererbung vorsichtig sein:

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

Überprüfen Sie die Typen strenger wie folgt:

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

Abgesehen davon wird Ihr Ansatz gut funktionieren, dafür gibt es spezielle Methoden.

Die Art, wie Sie beschreiben, ist die Art, wie ich es immer getan habe. Da es vollständig generisch ist, können Sie diese Funktionalität jederzeit in eine Mixin-Klasse aufteilen und in Klassen erben, in denen Sie diese Funktionalität wünschen.

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

Keine direkte Antwort, schien aber relevant genug, um angegangen zu werden, da dies gelegentlich ein wenig langwierige Langeweile erspart. Schneiden Sie direkt aus den Dokumenten ...

functools.total_ordering (cls)

Bei einer Klasse, die eine oder mehrere umfangreiche Vergleichsordnungsmethoden definiert, liefert dieser Klassendekorateur den Rest. Dies vereinfacht den Aufwand für die Angabe aller möglichen umfangreichen Vergleichsoperationen:

Die Klasse muss eine von definieren __lt__(), __le__(), __gt__(), oder __ge__(). Zusätzlich sollte die Klasse eine __eq__()Methode bereitstellen .

Neu in Version 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()))

Sie müssen nicht beide überschreiben __eq__und __ne__können nur überschreiben __cmp__, dies hat jedoch Auswirkungen auf das Ergebnis von == ,! ==, <,> usw.

isTests für die Objektidentität. Dies bedeutet, dass a isb Trueder Fall ist, wenn a und b beide die Referenz auf dasselbe Objekt enthalten. In Python enthalten Sie immer einen Verweis auf ein Objekt in einer Variablen, nicht auf das eigentliche Objekt. Wenn also a b wahr ist, sollten sich die darin enthaltenen Objekte im Wesentlichen an derselben Speicherstelle befinden. Wie und vor allem warum sollten Sie dieses Verhalten außer Kraft setzen?

Bearbeiten: Ich wusste nicht, dass __cmp__aus Python 3 entfernt wurde, also vermeiden Sie es.

Aus dieser Antwort: https://stackoverflow.com/a/30676267/541136 Ich habe gezeigt, dass es zwar richtig ist, __ne__Begriffe zu definieren __eq__- statt

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

du solltest benutzen:

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

Ich denke, dass die beiden Begriffe, nach denen Sie suchen, Gleichheit (==) und Identität (ist) sind. Zum Beispiel:

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

Der 'is'-Test testet die Identität mit der eingebauten' id () '- Funktion, die im Wesentlichen die Speicheradresse des Objekts zurückgibt und daher nicht überladbar ist.

Wenn Sie jedoch die Gleichheit einer Klasse testen möchten, möchten Sie Ihre Tests wahrscheinlich etwas strenger gestalten und nur die Datenattribute in Ihrer Klasse vergleichen:

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

Dieser Code vergleicht nur Nicht-Funktionsdaten-Mitglieder Ihrer Klasse und überspringt alles Private, was im Allgemeinen gewünscht wird. Im Fall von einfachen alten Python-Objekten habe ich eine Basisklasse, die __init__, __str__, __repr__ und __eq__ implementiert, sodass meine POPO-Objekte nicht die Last all dieser zusätzlichen (und in den meisten Fällen identischen) Logik tragen.

Anstatt Unterklassen / Mixins zu verwenden, verwende ich gerne einen generischen Klassendekorateur

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

Verwendungszweck:

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

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

Dies beinhaltet die Kommentare zu Algorias 'Antwort und vergleicht Objekte mit einem einzigen Attribut, da mir das ganze Diktat egal ist. hasattr(other, "id")muss wahr sein, aber ich weiß, dass es daran liegt, dass ich es im Konstruktor festgelegt habe.

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