Surcharge des opérateurs Python

Programmation orientée objet intermédiaire en Python

Jake Roach

Data Engineer

Surcharge des opérateurs de comparaison

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

  def __eq__(self, other):
      return self.name == other.name

Personnaliser le comportement de ==

Utilisez la méthode magique __eq__()
Reçoit self et other
Retourne une valeur booléenne

bryce = Person("Bryce")
orion = Person("Orion")
print(bryce == orion)

False

chuck = Person("Charles Carmichael")
charles = Person("Charles Carmichael")
print(chuck == charles)

True

Additionner deux objets

class Team:
  def __init__(self, team_members):
      self.team_members = team_members

# Create two Team objects, attempt to add them
rookies = Team(["Casey", "Emmitt"])
veterans = Team(["Mike", "Chuck"])
dream_team = rookies + veterans

Traceback (most recent call last):
  File "<stdin>", line 8, in <module>
TypeError: unsupported operand type(s) for +: 'Team' and 'Team'

Surcharger l'opérateur +

class Team:
  def __init__(self, team_members):
    # team_members is a list of names
    self.team_members = team_members

  def __add__(self, other):
    # Adding Team objects creates a larger Team
    return Team(self.team_members + other.team_members)

Utilisez la méthode magique __add__() pour surcharger +
self et other sont passés à __add__()
Créez un nouvel objet Team en combinant les team_members des objets « ajoutés »

Additionner deux objets

# Create two Team objects
rookies = Team(["Casey", "Emmitt"])
veterans = Team(["Mike", "Chuck"])

# Attempt to add these two Teams together
dream_team = rookies + veterans
print(type(dream_team))
print(dream_team.team_members)

Team
["Casey", "Emmitt", "Mike", "Chuck"]

Utiliser + pour créer un nouvel objet

class Team:
  def __init__(self, team_members):
      self.team_members = team_members

class Employee:
  def __init__(self, name, title):
    self.name = name
    self.title = title

  def __add__(self, other):
    # Use the + operator to create a
    # Team with the name of each Employee
    return Team([self.name, other.name])

Et si nous voulions créer une Team en combinant des objets Employee ?

__add__ est défini dans la classe Employee
Crée un nouvel objet Team en générant une liste de noms d'Employee
Le résultat de l'addition de deux Employee est une seule Team

Additionner deux objets pour en créer un nouveau

# Create two Employee objects
anna = Employee("Anna", "Technical Specialist")
jeff = Employee("Jeffrey", "Musician")

# Now, attempt to add these together to create a team
audio_team = anna + jeff
print(type(audio_team))
print(audio_team.team_members)

Team
["Anna", "Jeffrey"]

Surcharger d'autres opérateurs

Opérateur	Méthode magique	Type d'opérateur
-	`__sub__`	Arithmétique
!=	`__ne__`	Comparaison
<	`__lt__`	Comparaison
>	`__gt__`	Comparaison
+=	`__iadd__`	Affectation
and	`__and__`	Logique
in	`__contains__`	Appartenance
is	`__is__`	Identité

… et bien d'autres encore !

Passons à la pratique !

Programmation orientée objet intermédiaire en Python