Comment obtenir l'équivalence dans les classes Python : une plongée approfondie dans __eq__, __ne__ et le hachage ?

Implémentation de l'équivalence dans les classes Python avec élégance

En Python, les classes personnalisées peuvent être équipées d'équivalence grâce à l'implémentation des méthodes spéciales eq et ne pour les opérateurs == et !=, respectivement. Cela permet de comparer l'égalité des objets de ces classes en fonction de leurs attributs.

Une implémentation de base

Une méthode simple mais efficace pour obtenir l'équivalence consiste à comparer les dictionnaires contenant les attributs des objets. :

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)

Surmonter les pièges

Bien que cette méthode établisse l'équivalence entre des objets d'une même classe, elle se heurte à des défis lorsque traitant de sous-classes ou d’instances de types non liés. Pour résoudre ces problèmes, les considérations suivantes sont importantes :

Non-commutativité des classes de style classique :

Les classes Python 2 de style classique exécutent l'eq méthode du premier opérande tandis que ne est appelée sur le second. Pour garantir la symétrie, envisagez de renvoyer NotImplemented pour les types d'opérandes non pris en charge.

Retour de NotImplemented pour les types non pris en charge :

Pour les cas où l'opérande est d'un type différent (non héritage), renvoyant NotImplemented dans eq et ne délègue la comparaison à la méthode réfléchie de l'autre opérande. Cela garantit la commutativité et permet l'utilisation d'ensembles pour déterminer des instances uniques.

Hashage et gestion des ensembles :

Par défaut, les objets sont hachés en utilisant leur identifiant d'objet. Pour garantir une comparaison appropriée au sein des ensembles, remplacez hash pour calculer un hachage cohérent en fonction des attributs de l'objet.

Une implémentation plus robuste

L'intégration de ces considérations aboutit à un résultat plus robuste implémentation pour l'équivalence d'objet :

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

Cette implémentation garantit une équivalence et un hachage corrects même entre les sous-classes et les instances non liées, fournissant un moyen plus élégant et complet de prendre en charge l'équivalence dans les classes Python.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!