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