Ga naar hoofdinhoud

Operatoren in Python

Deze tutorial behandelt de verschillende typen operatoren in Python, operator overloading, prioriteit en associativiteit.
· 9 min lezen

Verken met AI

Net als in de wiskunde hebben programmeertalen zoals Python operatoren. Je kunt ze zien als extreem eenvoudige functies die aan de basis liggen van de informatica. Dit zijn de eenvoudigste bewerkingen waarnaar een computerprogramma kan worden herleid. Ze zijn essentiële kennis voor elke beginnende Data Scientist of Software Engineer.

In deze tutorial leer je over

Wil je meer leren over de basis van de programmeertaal Python? Bekijk dan zeker onze gratis cursus Intro to Python for Data Science.

Rekenkundige operatoren

Waarschijnlijk ken je deze al, omdat ze uit de basiswiskunde komen.

De rekenkundige operatoren zijn optellen (+), aftrekken (-), vermenigvuldigen (*), delen (/), machtsverheffen (**), gehele deling (//) en modulus (%). De eerste vier zijn vrij simpel; dat zijn optellen, aftrekken, vermenigvuldigen en delen, en die ken je waarschijnlijk al.

# Addition
print(5 + 2)

# Subtraction
print(5 - 2)

# Multiplication
print(5 * 2)

# Division
print(5 / 2)

7
3
10
2.5

De andere drie zijn iets ingewikkelder. De machtsoperator betekent ‘verheffen tot de macht’. Zo betekent 2 ** 3 dat 2 zichzelf 3 keer vermenigvuldigt, dus 2 ** 3 is hetzelfde als 2 * 2 * 2, wat gelijk is aan 8.

Gehele deling is hetzelfde als normale deling, behalve dat het resultaat altijd naar beneden wordt afgerond. In het onderstaande voorbeeld wordt 5 gedeeld door 2, wat 2,5 oplevert. Maar omdat het om gehele deling gaat, wordt 2,5 afgerond naar 2.

Tot slot is de modulus de rest na deling. In het geval van 5%2 past het getal 2 maar twee keer in 5, wat betekent dat de rest 1 is.

# Exponent
print(5 ** 2)
# This is the same as 5 * 5

# Floor Division
print(5 // 2)

# Modulus
print(5 % 2)

25
2
1

In Python kun je de opteloperator ook gebruiken om strings te concateneren. Dat betekent dat ze aan elkaar worden geplakt tot één string, bijvoorbeeld:

firstName = "Théo"

introduction = "Hi, my name is " + firstName + "."

print(introduction)

Hi, my name is Théo.

Toekenningsoperatoren

Als je al wat programmeerervaring hebt, heb je zeker eerder toekenningsoperatoren gebruikt. Ze wijzen een bepaalde waarde toe aan een variabele. De meest gebruikte is =. Om hem te gebruiken, typ je simpelweg de naam van de variabele waaraan je een nieuwe waarde wilt toekennen, de =, en de waarde die je wilt toekennen. Als je bijvoorbeeld de waarde 100 wilt toekennen aan de variabele balance, kun je het volgende doen:

balance = 100
print(balance)

100

Als je de waarde van balance met 10 wilt verhogen, kun je balance += 10 gebruiken. Dit is gelijk aan balance = balance + 10, maar het is veel korter.

balance += 10
print(balance)

110

Hetzelfde geldt voor -=, balance -= 10 is hetzelfde als balance = balance - 10:

print(balance)
balance -= 10
print(balance)

110
100

De andere toekenningsoperatoren werken exact hetzelfde. Dit zijn:

  • *=
  • /=
  • **=
  • //=
  • %=

Vergelijkingsoperatoren

Je kunt vergelijkingsoperatoren gebruiken om, je raadt het al, de waarden van variabelen te vergelijken. Ze geven altijd een booleaanse waarde terug, die ofwel True of False is. Er zijn er zes:

  • Gelijk aan: ==
  • Ongelijk aan: !=
  • Groter dan: >
  • Kleiner dan: <
  • Groter dan of gelijk aan: >=
  • Kleiner dan of gelijk aan: <=

Hier zijn enkele voorbeeldvergelijkingen:

a = 3
b = 5

print(a == b) # Equal
print(a != b) # Not equal
print(a > b) # Greater than
print(a < b) # Less than
print(a >= b) # Greater than or equal to
print(a <= b) # Less than or equal to

False
True
False
True
False
True

== en != kunnen ook worden gebruikt om strings te vergelijken in plaats van getallen. De andere operatoren zijn niet compatibel met strings, omdat een string niet echt groter kan zijn dan een andere string.

print("Hello" == "World")
print("Python" != "R")

False
True

Logische operatoren

Misschien ken je deze al! In de logica heten ze logische connectieven. Ze worden ook veel gebruikt in de menselijke taal. Het zijn: and, or en not.

and geeft alleen True terug als beide operanden (de twee booleans die je vergelijkt) True zijn. Bijvoorbeeld:

print(True and True)
print(True and False)
print(False and False)

True
False
False

Om het gedrag van deze logische operator te begrijpen, kun je gebruikmaken van een waarheidstabel:

aba and b
TrueTrueTrue
TrueFalseFalse
FalseTrueFalse
FalseFalseFalse

or is True zodra een (één of meer) operand True is.

print(True and True)
print(True and False)

True
False
aba or b
TrueTrueTrue
TrueFalseTrue
FalseTrueTrue
FalseFalseFalse

Let op dat deze ook werken met meer dan twee operanden, bijvoorbeeld:

print(True and True and True and True)
print(True and True and True and False)
print(False or False or False or False)
print(False or False or False or True)

True
False
False
True

not geeft het omgekeerde terug van zijn operand, dus True als False wordt gegeven en omgekeerd.

print(not True)

False
anot a
TrueFalse
FalseTrue

Operator overloading

Weet je nog dat je eerder zag hoe + kan worden gebruikt om getallen op te tellen, maar ook om strings te concatenen of te combineren. + werkt dus anders, afhankelijk van het type object waarop je het gebruikt. Maar dat is niet altijd het geval. Soms ondersteunt de operator waarmee je werkt simpelweg het type object niet waarop je hem wilt toepassen.

Hier is een voorbeeld. Stel, je hebt twee Dog-objecten, ozzy en filou. Deze behoren tot de onderstaande Dog-klasse. Je kunt de klasse zien als een blauwdruk voor hoe de objecten eruit moeten zien en hoe ze zich moeten gedragen. In dit geval hebben de Dog-objecten een naam, leeftijd en hoogte. Nadat de klasse is gedefinieerd, kun je objecten instantiëren. Een van hen is Ozzy, met een leeftijd van 3 en een hoogte van 30 centimeter. De andere is Filou, hij is 5 jaar oud en 65 centimeter lang.

Dit voorbeeld gebruikt het concept van objectgeoriënteerd programmeren. Wil je daar meer over leren, lees dan zeker onze tutorial over Object-Oriented Programming in Python

Stel dat je beide honden wilt vergelijken met ‘groter dan’: >. Dat werkt niet. Je krijgt een foutmelding: '>' not supported between instances of 'Dog' and 'Dog'. Dit betekent dat > niet weet hoe het objecten van de Dog-klasse moet vergelijken.

class Dog:

    def __init__(self, name, age, height):  
        self.name = name
        self.age = age
        self.height = height

ozzy = Dog("Ozzy", 3, 30)
filou = Dog("Filou", 5, 65)

print(filou > ozzy)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-96-428069ab24cc> in <module>()
      9 filou = Dog("Filou", 5, 65)
     10
---> 11 print(filou > ozzy)


TypeError: '>' not supported between instances of 'Dog' and 'Dog'

Gelukkig kun je met operator overloading het gedrag van de operator definiëren voor wanneer deze wordt aangeroepen op Dog-objecten. In dit geval moet een methode met de naam __gt__, wat ‘greater than’ betekent, worden gedefinieerd met twee argumenten. Aangezien we onze honden op hun hoogte willen vergelijken, retourneert de methode self.height > other.height.

class Dog:

    def __init__(self, name, age, height):  
        self.name = name
        self.age = age
        self.height = height

    def __gt__(self,other):
        return self.height > other.height

ozzy = Dog("Ozzy", 3, 30)
filou = Dog("Filou", 5, 65)

print(filou > ozzy)
print(ozzy > filou)

True
False

Prioriteit

Als je veel operatoren combineert, kan het verwarrend worden. Kijk eens naar het onderstaande voorbeeld:

a = 2
b = 3
c = 9

a ** b > 5 and c - a // b >= 9 or b ** 2 == c

True

Hoe weet je welke eerst wordt uitgevoerd? Hoe lees je een regel code met veel van deze symbolen? Wordt het van links naar rechts uitgevoerd of is er een specifieke volgorde?

Hier komt prioriteit om de hoek kijken. Python-operatoren worden in een heel specifieke volgorde uitgevoerd, en sommige hebben voorrang op andere.

In de volgende tabel zie je de prioriteit van operatoren, van boven naar beneden. Deze regels zijn hetzelfde als in de wiskunde, waar bepaalde berekeningen in een formule vóór andere moeten worden uitgevoerd.

PrioriteitOperatorBeschrijving
1**macht
2*, /, %, //vermenigvuldigen, delen, modulo, gehele deling
3+, -plus, min
4>, <, >=, <=vergelijking
5==, !=gelijkheid
6= %= /= //= -= += *= **=toekenning
7and, or, notlogisch

Associativiteit

Je hebt gezien dat prioriteit ertoe doet! Maar hoe zit het met de operatoren die op hetzelfde prioriteitsniveau staan, zoals vermenigvuldigen en delen? Worden die tegelijk uitgevoerd? Nee. *, \, % en \\ worden van links naar rechts uitgevoerd, terwijl ** van rechts naar links wordt uitgevoerd. Dit heet associativiteit.

Kijk eens naar het volgende voorbeeld. In dit geval worden de operatoren van links naar rechts uitgevoerd en is de output 3.

print(5 * 2 // 3)

3

Door echter haakjes toe te voegen, kun je de volgorde waarin de operatoren worden uitgevoerd veranderen. Dat is associativiteit, die op dezelfde manier werkt als in de wiskunde. Wat tussen haakjes staat, wordt eerst berekend. In dit geval wordt eerst de gehele deling uitgevoerd, gevolgd door de vermenigvuldiging.

print(5 * (2 // 3))

Conclusie

Je weet nu wat operatoren zijn, hoe je ze gebruikt en hoe ze werken. Je hebt ook geleerd over overloading, prioriteit en associativiteit. Je bent goed op weg om een Python-meester te worden! Wil je nog meer leren? Bekijk dan zeker onze cursus Intermediate Python for Data Science.

Onderwerpen

PythonData Science

Gerelateerd

Meer bekijken →