Elegante Möglichkeiten, Äquivalenz ("Gleichheit") in Python-Klassen zu unterstützen

Beim schreiben von benutzerdefinierten Klassen ist es oft wichtig, dass die Gleichwertigkeit durch die == und != Betreiber. In Python, möglich wird dies durch die Umsetzung der __eq__ und __ne__ spezielle Methoden, beziehungsweise. Der einfachste Weg, die ich gefunden habe, um 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 mehr elegante Art, dies zu tun? Kennen Sie eine insbesondere Nachteile bei der Verwendung der oben genannten Methode zu vergleichen __dict__s?

Hinweis: Ein wenig Klarstellung-wenn __eq__ und __ne__ sind nicht definiert, Sie finden dieses Verhalten:

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

Dass a == b ausgewertet False weil es wirklich läuft a is b eine Prüfung der Identität (D. H., "Ist a auf das gleiche Objekt wie b?").

Wenn __eq__ und __ne__ definiert sind, finden Sie dieses Verhalten (das ist die eine, die wir suchen):

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

InformationsquelleAutor der Frage | 

  1. 203

    Betrachten Sie dieses einfache problem:

    class Number:

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


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

n1 == n2 # False -- oops

    So, Python standardmäßig verwendet die Objekt-IDS für Vergleichsoperationen:

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

    Ü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

    In Python 2immer daran denken, überschreiben Sie die __ne__ - Funktion als auch, wie die Dokumentation Staaten:

    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.

    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 3ist dies nicht mehr notwendig, da die Dokumentation Staaten:

    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.

    Aber, dass nicht alle unsere Probleme lösen. Fügen wir eine Unterklasse:

    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 gibt es zwei Arten von Klassen:

    • classic-Stil (oder alten Stil) - Klassen, die nicht Erben von object und deklariert werden, wie class A:class A(): oder class A(B): wo B ist ein Klassiker-Stil-Klasse;

    • neuen Stil Klassen, die Erben von object und deklariert werden, wie class A(object) oder class A(B): wo B ist ein new-style Klasse. Python 3 hat nur new-style-Klassen deklariert sind, als class A:class A(object): oder class A(B):.

    Für classic-style-Klassen, ein Vergleich Betrieb immer ruft die Methode des ersten Operanden, während es für die new-style-Klassen, es ruft immer die Methode der Unterklasse Operanden, unabhängig von der Reihenfolge der Operanden.

    Also hier, wenn Number ist ein Klassiker-Stil-Klasse:

    • n1 == n3 Anrufe n1.__eq__;
    • n3 == n1 Anrufe n3.__eq__;
    • n1 != n3 Anrufe n1.__ne__;
    • n3 != n1 Anrufe n3.__ne__.

    Und wenn Number ist eine new-style class:

    • beide n1 == n3 und n3 == n1 nennen n3.__eq__;
    • beide n1 != n3 und n3 != n1 nennen n3.__ne__.

    To fix the non-commutativity Problem der == und != Betreiber für Python 2 classic-style-Klassen, die __eq__ und __ne__ Methoden sollte die Rückkehr der NotImplemented Wert, wenn ein operand-Typ wird nicht unterstützt. Die Dokumentation definiert die NotImplemented Wert:

    Numerische Methoden und Reich-Vergleich Methoden können return-Wert, wenn
    Sie nicht umsetzen, den Betrieb für die Operanden zur Verfügung gestellt. (Die
    Dolmetscher werden dann versuchen, das reflektierte Betrieb, oder einige andere
    fallback je nach Betreiber.) Ihr Wahrheitswert ist wahr.

    In diesem Fall wird der Betreiber die Delegierten der Vergleichsvorgang auf der reflektierte Methode der anderen Operanden. Die Dokumentation definiert, reflektiert Methoden:

    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.

    Das Ergebnis sieht wie folgt 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 not NotImplemented:
        return not x
    return NotImplemented

    Rücksendung der NotImplemented Wert statt False ist, das richtige zu tun, auch für die new-style-Klassen, wenn commutativity der == und != Betreiber erwünscht ist, wenn die Operanden von nicht verwandten Arten (keine Vererbung).

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

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

    Sets verwenden Sie die hashes der Objekte, und standardmäßig Python gibt den hash-Wert der id des Objekts. Lassen Sie uns versuchen, um 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 wie folgt aus (ich habe einige Behauptungen am Ende für die Validierung):

    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

    InformationsquelleAutor der Antwort

  2. 180

    Müssen Sie vorsichtig sein mit Vererbung:

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

    Check-Typen genauer, wie diese:

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

    Außer, dass dein Ansatz funktionieren, das ist, was die speziellen Methoden gibt es für.

    InformationsquelleAutor der Antwort

  3. 154

    Die Art und Weise, die Sie beschreiben, ist die Art, wie ich es immer getan haben. Da ist es völlig generisch ist, können Sie immer die Pause, die Funktionalität in eine mixin-Klasse und erbt es Klassen, in denen Sie möchten, dass die Funktionalität.

    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

    InformationsquelleAutor der Antwort

  4. 12

    Nicht eine direkte Antwort, schien aber relevant genug zu sein, wendete auf als es spart ein bisschen verbose Langeweile bei Gelegenheit. Gerade geschnitten, aus der docs...

    functools.total_ordering(cls)

    Gegeben eine Klasse definieren Sie einen oder mehrere reiche Vergleich Bestell-Methoden, die diese Klasse decorator versorgt den rest. Dies vereinfacht den Aufwand bei der Angabe aller möglichen reiche Vergleichsoperationen:

    Muss die Klasse definieren, lt(), le(), gt(), oder ge(). Darüber hinaus sollte die Klasse Versorgung ein eq () - Methode.

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

    InformationsquelleAutor der Antwort

  5. 8

    Du nicht überschreiben, sowohl __eq__ und __ne__ können Sie überschreiben nur __cmp__ aber dadurch wird eine Wirkung auf das Ergebnis von ==, !==, < , > und so weiter.

    is tests für Objekt-Identität. Dies bedeutet eine is b True in dem Fall, wenn a und b beide halten den Verweis auf dasselbe Objekt. In python geben, die Sie immer halten eine Referenz auf ein Objekt in einer variable nicht das eigentliche Objekt, also im wesentlichen für a ist b, wahr zu sein die Objekte in Ihnen sollte sich in der gleichen Position im Speicher. Wie und vor allem warum würden Sie gehen über das überschreiben dieses Verhalten?

    Edit: ich wusste nicht __cmp__ entfernen von python 3 so vermeiden Sie es.

    InformationsquelleAutor der Antwort

  6. 3

    Aus dieser Antwort: https://stackoverflow.com/a/30676267/541136 habe ich gezeigt, dass, während es richtig zu definieren __ne__ im Hinblick auf __eq__ - statt 

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

    sollten Sie verwenden:

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

    InformationsquelleAutor der Antwort

  7. 2

    Ich denke, dass die beiden Begriffe, die du suchst Gleichheit (==) und Identität (ist). 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

    InformationsquelleAutor der Antwort

  8. 1

    'Ist' test-test für die Identität mit dem builtin 'id ()" - Funktion, die im wesentlichen liefert die Speicheradresse des Objekts und kann daher nicht overloadable.

    Aber in dem Fall der Prüfung der Gleichheit der a-Klasse werden Sie wahrscheinlich wollen, um ein bisschen mehr strenge über Ihre tests, und vergleichen Sie nur die Daten, die Attribute in der Klasse:

    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 wird nur dann vergleichen Sie nicht die Funktion Daten-member der Klasse sowie das überspringen etwas privates, das ist in der Regel, was Sie wollen. Im Fall von Plain Old Python-Objekte-ich habe eine Basis-Klasse implementiert die __init__, __str__, __repr__ und __eq__, so dass mein POPO Objekte tragen nicht die Last aller, die extra (und in den meisten Fällen identisch) Logik.

    InformationsquelleAutor der Antwort

Schreibe einen Kommentar