Python >> Tutoriel Python >  >> Python

Méthode magique Python __ge__()

Bref résumé :

  • Pour personnaliser le comportement de l'opérateur supérieur ou égal à x >= y , remplacez le __ge__() méthode dunder dans votre définition de classe.
  • Python appelle en interne x.__ge__(y) pour obtenir une valeur de retour lors de la comparaison de deux objets en utilisant x >= y .
  • La valeur de retour peut être n'importe quel type de données car toute valeur peut être automatiquement convertie en booléen en utilisant le bool() fonction intégrée.
  • Si le __ge__() méthode n'est pas définie, Python lèvera un TypeError .

Syntaxe

__ge__(self, other)

Pour utiliser le supérieur ou égal à opérateur sur les objets personnalisés, définissez le __ge__() "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 est supérieur ou égal à L'autre.

La méthode doit renvoyer un booléen True ou False - cependant, ce n'est pas obligatoire car chaque objet peut être automatiquement converti en une valeur booléenne à l'aide du bool() intégré fonction.

Regardons un exemple ensuite.

Exemple

Dans le code suivant, vous comparez deux personnes entre elles en utilisant le age attribut comme critère de décision :

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

    def __ge__(self, other):
        return self.age >= other.age



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

print(alice >= bob)
# True

print(alice >= carl)
# True

print(bob >= alice)
# False

Par exemple, comme l'âge d'Alice est de 18 ans et celui de Bob de 17 ans, l'expression alice >= bob évalue à True .

Vidéo de fond

Implémentation par défaut de __ge__

Le __ge__() La méthode dunder n'a pas d'implémentation par défaut. Si vous essayez de comparer des objets en utilisant l'opérateur supérieur ou égal à >= , Python lèvera simplement un TypeError .

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


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

print(alice >= bob)
Traceback (most recent call last):
  File "C:\Users\xcent\Desktop\code.py", line 12, in <module>
    print(alice >= bob)
TypeError: '>=' not supported between instances of 'Person' and 'Person'

TypeError :'>=' non pris en charge entre les instances de '…' et '…'

Si vous obtenez le TypeError: '>=' not supported between instances of '...' and '...' , vous essayez de comparer deux objets en utilisant l'opérateur supérieur ou égal à x >= y dont le __ge__() la méthode magique n'est pas définie.

class Finxter:
    pass


x = Finxter()
y = Finxter()

x >= y    # Python will raise an error!

Sortie :

Traceback (most recent call last):
  File "C:\Users\xcent\Desktop\code.py", line 8, in <module>
    x >= y    # Python will raise an error!
TypeError: '>=' not supported between instances of 'Finxter' and 'Finxter'

Pour corriger l'erreur, définissez simplement le __ge__(self, other) dans votre définition de classe et renvoyez tout objet qui sera ensuite converti en un booléen True ou False .

class Finxter:
    def __ge__(self, other):
        return 42


x = Finxter()
y = Finxter()

x >= y    # Now it works!
# 42

Commutativité supérieure ou égale à>=

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

Vous pouvez le voir dans l'exemple suivant :

class Person:
    def __ge__(self, other):
        return False


class Human:
    def __ge__(self, other):
        return True


alice = Person()
bob = Human()


print(alice >= bob)
# False

print(bob >= alice)
# True


Prochain article