Python-operatoren overbelasten

Gevorderde objectgeoriënteerde programmering in Python

Jake Roach

Data Engineer

Vergelijkingsoperatoren overbelasten

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

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

Pas de functionaliteit van == aan

Gebruik de magic-methode __eq__()
Neemt self en other
Geeft een booleaanse waarde terug

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

False

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

True

Twee objecten optellen

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

# Maak twee Team-objecten, probeer ze op te tellen
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'

+-operator overbelasten

class Team:
  def __init__(self, team_members):
    # team_members is een lijst met namen
    self.team_members = team_members

  def __add__(self, other):
    # Team-objecten optellen maakt een groter Team
    return Team(self.team_members + other.team_members)

Gebruik de magic-methode __add__() om + te overbelasten
self en other worden aan __add__() doorgegeven
Maak een nieuw Team met de team_members van de toegevoegde objecten

Twee objecten optellen

# Maak twee Team-objecten
rookies = Team(["Casey", "Emmitt"])
veterans = Team(["Mike", "Chuck"])

# Probeer deze twee Teams op te tellen
dream_team = rookies + veterans
print(type(dream_team))
print(dream_team.team_members)

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

+ gebruiken om een nieuw objecttype te maken

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):
    # Gebruik de +-operator om een
    # Team met de naam van elke Employee te maken
    return Team([self.name, other.name])

Wat als we een Team willen maken door Employee-objecten te combineren?

__add__ is geïmplementeerd in de klasse Employee
Maakt een nieuw Team-object met een lijst van Employee-namen
Het optellen van twee Employee-objecten geeft één Team

Tel twee objecten op tot een nieuw object

# Maak twee Employee-objecten
anna = Employee("Anna", "Technical Specialist")
jeff = Employee("Jeffrey", "Musician")

# Tel ze op om een team te maken
audio_team = anna + jeff
print(type(audio_team))
print(audio_team.team_members)

Team
["Anna", "Jeffrey"]

Andere operatoren overbelasten

Operator	Magic-methode	Operatortype
-	`__sub__`	Rekenkundig
!=	`__ne__`	Vergelijking
<	`__lt__`	Vergelijking
>	`__gt__`	Vergelijking
+=	`__iadd__`	Toewijzing
and	`__and__`	Logisch
in	`__contains__`	Lidmaatschap
is	`__is__`	Identiteit

... En nog veel meer!

Laten we oefenen!

Gevorderde objectgeoriënteerde programmering in Python