Python >> Tutoriel Python >  >> Python

Méthode magique Python __ne__

Pour personnaliser le comportement de l'opérateur de non-égalité x != y , remplacez le __ne__() méthode dunder dans votre définition de classe. Python appelle en interne x.__ne__(y) pour comparer deux objets en utilisant x != y . Si le __ne__() méthode n'est pas définie, Python utilisera le i s n o t opérateur par défaut qui vérifie pour deux objets arbitraires s'ils résident sur une adresse mémoire différente.

Syntaxe

__ne__(self, other)

Pour utiliser le pas égal à opérateur sur les objets personnalisés, définissez le __ne__() "dunder" méthode magique qui prend deux arguments :self et other . Vous pouvez ensuite utiliser les attributs des objets personnalisés pour déterminer si l'un n'est pas égal à l'autre. Il doit renvoyer un booléen True ou False .

Regardons un exemple ensuite.

Exemple

Dans le code suivant, vous vérifiez si une personne n'est pas égale à une autre personne en utilisant le age attribut comme critère de décision :

class Person:
    def __init__(self, age):
        self.age = age

    def __ne__(self, other):
        return self.age != other.age



alice = Person(18)
bob = Person(19)
carl = Person(18)

print(alice != bob)
# True

print(alice != carl)
# False

Parce qu'Alice a 18 ans et Bob 19 ans, et 18 != 19 est True , le résultat de alice != bob est True . Mais le résultat de alice != carl évalue à False car les deux ont le même âge.

Vidéo de fond

Implémentation par défaut de __ne__

Par défaut, le __ne__() la méthode dunder est implémentée en utilisant le is not opérateur d'identité. Les opérateurs d'identité sont utilisés pour vérifier si deux valeurs ou variables résident à un emplacement de mémoire différent, c'est-à-dire se réfèrent à un objet différent en mémoire.

Étant donné que l'opérateur d'identité de secours est défini pour chaque objet, vous pouvez également vérifier la non-égalité pour deux objets.

L'exemple suivant montre que vous pouvez comparer des personnes personnalisées à l'aide de l'opérateur de non-égalité != , même sans définir le __ne__ méthode. En interne, Python utilise l'opérateur de non-identité :

class Person:
    def __init__(self, age):
        self.age = age



alice = Person(18)
bob = Person(19)
carl = Person(18)

print(alice != bob)
# True

print(alice != carl)
# True

print(alice != alice)
# False

Opérateur d'identité vidéo en arrière-plan

Pour comprendre l'opérateur d'identité, n'hésitez pas à regarder la vidéo de fond suivante :

Commutativité de la non-égalité !=

La sortie de x != y et y != x peut être différent car le premier appelle x.__ne__(y) et ce dernier appelle y.__ne__(x) . Si x et y ont des définitions différentes de la méthode dunder __ne__() , l'opération devient non commutative .

Vous pouvez le voir dans l'exemple suivant :

class Person:
    def __ne__(self, other):
        return 42


class Human:
    def __ne__(self, other):
        return 0


alice = Person()
bob = Human()


print(alice != bob)
# 42

print(bob != alice)
# 0

Post précédent