Wie erreicht man Äquivalenz in Python-Klassen: Ein tiefer Einblick in __eq__, __ne__ und Hashing?

Äquivalenz in Python-Klassen mit Eleganz implementieren

In Python können benutzerdefinierte Klassen durch die Implementierung der speziellen Methoden eq und mit Äquivalenz ausgestattet werden ne für die Operatoren == bzw. !=. Dadurch können Objekte aus solchen Klassen anhand ihrer Attribute auf Gleichheit verglichen werden.

Eine grundlegende Implementierung

Eine einfache, aber effektive Methode, um Gleichwertigkeit zu erreichen, ist der Vergleich der Wörterbücher, die die Attribute der Objekte enthalten :

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)

Überwindung der Fallstricke

Während diese Methode die Äquivalenz zwischen Objekten derselben Klasse herstellt, steht sie beim Umgang mit Unterklassen oder Instanzen nicht verwandter Typen vor Herausforderungen. Um diese Probleme anzugehen, sind die folgenden Überlegungen wichtig:

Nichtkommutativität von Klassen im klassischen Stil:

Python 2-Klassen im klassischen Stil führen die Gl. aus -Methode des ersten Operanden, während ne für den zweiten aufgerufen wird. Um die Symmetrie sicherzustellen, sollten Sie erwägen, NotImplemented für nicht unterstützte Operandentypen zurückzugeben.

NotImplemented für nicht unterstützte Typen zurückgeben:

Für Fälle, in denen der Operand von einem anderen Typ ist (Nr Vererbung), die in eq NotImplemented zurückgibt und ne den Vergleich an die reflektierte Methode des anderen Operanden delegiert. Dies gewährleistet Kommutativität und ermöglicht die Verwendung von Mengen zur Bestimmung eindeutiger Instanzen.

Hashing und Mengenverarbeitung:

Standardmäßig werden Objekte mithilfe ihrer Objektkennung gehasht. Um einen ordnungsgemäßen Vergleich innerhalb von Sätzen sicherzustellen, überschreiben Sie Hash, um einen konsistenten Hash basierend auf den Attributen des Objekts zu berechnen.

Eine robustere Implementierung

Die Einbeziehung dieser Überlegungen führt zu einer robusteren Implementierung für Objektäquivalenz:

class Number:

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

    def __eq__(self, other):
        if isinstance(other, Number):
            return self.number == other.number
        return NotImplemented

    def __ne__(self, other):
        x = self.__eq__(other)
        if x is not NotImplemented:
            return not x
        return NotImplemented

    def __hash__(self):
        return hash(tuple(sorted(self.__dict__.items())))

Diese Implementierung gewährleistet korrekte Äquivalenz und Hashing auch über Unterklassen und nicht verwandte Instanzen hinweg und bietet eine elegantere und umfassendere Möglichkeit zur Unterstützung der Äquivalenz in Python-Klassen.

Das obige ist der detaillierte Inhalt vonWie erreicht man Äquivalenz in Python-Klassen: Ein tiefer Einblick in __eq__, __ne__ und Hashing?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!