Python-logische operatoren: een praktische introductie

In programmeren moeten we vaak beslissingen nemen op basis van meerdere voorwaarden. Zo willen we misschien een bepaalde actie alleen uitvoeren als verschillende voorwaarden tegelijkertijd gelden. Of we willen een alternatieve actie starten als één van meerdere voorwaarden is vervuld.

Python biedt een set logische operatoren – and, or, not – om deze scenario's aan te pakken.

In deze tutorial leer je hoe Python-logische operatoren werken en hoe je ze gebruikt in programmeren en data science. Let op: we gebruiken de hoofdletters AND, OR en NOT om deze operatoren conceptueel weer te geven. En we verwijzen naar de Python-trefwoorden met deze notatie: and, or en not.

Zoek je een zorgvuldig samengestelde Python-leerroute? Bekijk dan deze cursusreeks Python Programming.

Voordat we de details induiken, beginnen we met een heel kort antwoord voor wie haast heeft.

Kort antwoord: wat zijn Python-logische operatoren?

Python-logische operatoren (and, or, not) zijn speciale trefwoorden die als voegwoorden in je code fungeren. Ze verbinden en evalueren meerdere voorwaarden binnen één expressie.

Bekijk dit voorbeeld:

temperature = 25
is_sunny = True
if temperature > 20 and is_sunny:
    print("It's a perfect day for a picnic!")
Mogelijk gemaakt door

It's a perfect day for a picnic!
Mogelijk gemaakt door

Hier zorgt de and-operator ervoor dat het bericht alleen wordt geprint als beide voorwaarden gelden: de temperatuur is boven de 20 graden en het is zonnig.

Laten we nog een voorbeeld bekijken met de or-operator:

has_umbrella = False

if is_sunny or has_umbrella:
    print("Let's go for a walk!")
Mogelijk gemaakt door

Let's go for a walk!
Mogelijk gemaakt door

In dit geval gaan we een wandeling maken als ofwel de zon schijnt of we een paraplu hebben.

Tot slot keert de not-operator de waarheidswaarde van een voorwaarde om:

if not is_sunny:
    print("Maybe we should stay indoors.")
Mogelijk gemaakt door

Hier wordt het bericht alleen geprint als het niet zonnig is.

Logische operatoren geven ons een beknopte en krachtige manier om complexe voorwaarden uit te drukken, zodat onze programma's beslissingen kunnen nemen op basis van meerdere factoren. Laten we nu dieper ingaan en beginnen met de logische operator and.

Python: de and-operator

In de Booleaanse logica houdt de AND-bewerking in dat je twee waarden of expressies vergelijkt. Ze levert alleen een true-resultaat op als beide waarden true zijn. Als één of beide waarden false zijn, is het resultaat van de AND-bewerking false. Hier is een samenvatting van hoe AND zich gedraagt:

We kunnen deze waarheidstabel nabouwen met Python's and-operator:

options = True, False
for a in options:
    for b in options:
        print(f"{a} and {b} gives {a and b}")
Mogelijk gemaakt door

True and True gives True
True and False gives False
False and True gives False
False and False gives False
Mogelijk gemaakt door

De variabele options bevat de twee Booleaanse waarden. De geneste for-lussen lopen twee keer door options om alle permutaties van True en False te maken.

Vaak bevatten de expressies die als operand voor and worden gebruikt vergelijkings- of gelijkheidsoperatoren:

names = "James", "Bob", "David", "Jane", "Kate", "Mary"
for name in names:
   if len(name) < 5 and name[0] == "J":
      print(name)
Mogelijk gemaakt door

Jane
Mogelijk gemaakt door

De naam wordt alleen geprint als hij minder dan vijf letters bevat en begint met "J". Aan beide eisen moet worden voldaan.

De vergelijkings- en gelijkheidsoperatoren, zoals < en ==, evalueren naar True of False.

De Python-operator and werkt echter op elk gegevenstype en niet alleen op de Booleans True en False. De uitvoerwaarde kan ook elk gegevenstype zijn.

Laten we de and-operator van Python in deze sectie in meer detail verkennen. Eerst bespreken we truthiness.

Python: truthy en falsy

Elk Python-object kan met de ingebouwde functie bool() naar een Booleaans type worden geconverteerd. Een object is truthy als bool(object) True retourneert. Voor een falsy object retourneert bool(object) False.

De and-operator van Python kijkt naar de truthiness van zijn operanden. Als beide operanden truthy zijn, retourneert de and-operator ook een truthy waarde. Als één of beide operanden falsy zijn, retourneert and een falsy waarde. Laten we enkele voorbeelden bekijken:

if 42 and "python":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")Mogelijk gemaakt door

Both operands are truthyMogelijk gemaakt door

Laten we nu dit voorbeeld bekijken:

if 42 and "":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")
Mogelijk gemaakt door

One or both operands are falsyMogelijk gemaakt door

En bekijk ook dit laatste voorbeeld:

if 0 and "python":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")Mogelijk gemaakt door

One or both operands are falsyMogelijk gemaakt door

Numerieke types, zoals integers en floats, zijn truthy als ze niet nul zijn en falsy wanneer ze gelijk zijn aan nul. Reeksen, zoals strings, zijn truthy wanneer ze niet leeg zijn en falsy wanneer ze leeg zijn.

Daarom voldoet alleen het eerste van de drie bovenstaande voorbeelden aan de voorwaarde dat beide operanden truthy moeten zijn voor de and-operator om naar truthy te evalueren.

De and-operator retourneert niet altijd een Booleaanse waarde. Een expressie met and kan ook evalueren naar een van de operanden. Laten we hier dieper op ingaan met dezelfde voorbeelden als zojuist. In plaats van de and-expressies in een if-statement te gebruiken, evalueren we ze direct:

print(42 and "python")
print(42 and "")
print(0 and "python")
Mogelijk gemaakt door

python

0Mogelijk gemaakt door

Zie je wat er gebeurt met deze expressies?

Laten we beginnen met het laatste van de drie voorbeelden, met 0 en "python" als de twee operanden. De and-operator is op zoek naar twee truthy operanden. Omdat de eerste 0 is, is die falsy. Het programma hoeft de tweede operand niet te controleren, aangezien de hele expressie falsy zal zijn, ongeacht de waarde van de tweede operand.

De and-operator retourneert echter niet False. In plaats daarvan retourneert hij de eerste operand direct. Omdat de eerste operand falsy is, evalueert de hele and-expressie naar falsy. Dit veroorzaakt geen problemen in Python, want in situaties waarin Python een true- of false-waarde nodig heeft, kan het de truthiness van een object gebruiken.

In het eerste voorbeeld is de eerste operand 42, wat truthy is. Het programma evalueert de tweede operand en retourneert die. Aangezien de tweede operand de string "python" is, die truthy is, evalueert de hele expressie als truthy.

In het tweede voorbeeld is de eerste operand ook 42. Omdat die truthy is, evalueert en retourneert het programma de tweede operand, de lege string. De lege string is falsy en daarom evalueert de hele and-expressie naar falsy.

Wanneer de eerste operand truthy is, retourneert de and-operator altijd de waarde van de tweede operand, of die tweede operand nu truthy of falsy is.

Wanneer de eerste operand falsy is, evalueert Python de tweede operand niet. Dit heet short-circuiting en is een vorm van luie evaluatie (lazy evaluation). Je kunt dit bevestigen met de volgende code:

0 and 5/0
Mogelijk gemaakt door

0
Mogelijk gemaakt door

De tweede operand is 5/0, wat normaal gesproken een ZeroDivisionError zou veroorzaken. De expressie 5/0 wordt in dit voorbeeld echter niet geëvalueerd omdat de eerste operand falsy is. De uitzondering wordt nooit opgegooid.

Voorbeeld: de online winkel voor programmeurs

Laten we een eenvoudig voorbeeld bekijken dat een realistische toepassing vertegenwoordigt. Transacties in een online winkel die spullen voor programmeurs levert, worden vastgelegd en benaderd via een API. De gegevens worden omgezet in een lijst van dictionaries. Elk item in de lijst vertegenwoordigt een transactie en elke transactie is een dictionary met relevante informatie:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]
Mogelijk gemaakt door

Elke transactie bevat de naam en prijs van het artikel, de hoeveelheid in de bestelling en of de transactie is geslaagd.

Stel dat we geslaagde transacties nodig hebben voor artikelen met een prijs van $100 of meer. We kunnen de and-operator gebruiken om de rijen te filteren die we nodig hebben:

for item in data:
    if item["Success"] and item["Price"] >= 100:
        print(item)Mogelijk gemaakt door

{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}Mogelijk gemaakt door

De uitvoer van deze code laat de enige transactie zien die aan beide eisen voldoet. Voor elk item in de lijst met transacties controleert het if-statement de truthiness van twee expressies:

• De waarden die horen bij de sleutel "Success" in elke dictionary zijn ofwel True of False.
• De groter-dan-of-gelijk-aan-operator in item["Price"] >= 100 retourneert ook True of False.

Het Python-boek en de kabels voldoen niet aan de prijsvoorwaarde, omdat ze onder de $100 liggen. Het koffiezetapparaat ligt boven deze prijsdrempel, maar deze transactie was niet geslaagd, dus die wordt niet geprint.

We komen later in deze tutorial terug op dit voorbeeld van de online winkel.

In de volgende sectie richten we ons op de or-operator.

Python: de or-operator

De OR-logische operator in de Booleaanse logica heeft twee operanden nodig. Hij evalueert naar true als ten minste één van de operanden true is:

We kunnen deze waarheidstabel nabouwen met de or-operator van Python:

options = True, False
for a in options:
    for b in options:
        print(f"{a} or {b} gives {a or b}")
Mogelijk gemaakt door

True or True gives True
True or False gives True
False or True gives True
False or False gives False
Mogelijk gemaakt door

We kunnen ook het voorbeeld met persoonsnamen dat we eerder bekeken opnieuw gebruiken, maar de and-operator vervangen door een or:

names = "James", "Bob", "David", "Jane", "Kate", "Mary"
for name in names:
    if len(name) < 5 or name[0] == "J":
        print(name)
Mogelijk gemaakt door

James
Bob
Jane
Kate
Mary
Mogelijk gemaakt door

Het if-statement bevat nu een or-expressie. De for-lus print daarom alle namen die ofwel minder dan vijf letters hebben of beginnen met de letter "J". De string "Jane" voldoet aan beide eisen. De andere geprinte namen voldoen aan één van de twee eisen.

Python-or-operator: truthy en falsy

De or-operator kijkt ook naar truthy en falsy waarden en niet alleen naar de Booleans True en False. Laten we enkele voorbeelden bekijken:

if 42 or [10, 20, 30]:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")
Mogelijk gemaakt door

At least one operand is truthy
Mogelijk gemaakt door

Beschouw nu dit voorbeeld:

if 42 or []:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")
Mogelijk gemaakt door

At least one operand is truthyMogelijk gemaakt door

En bekijk ook dit laatste voorbeeld:

if 0 or []:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")
Mogelijk gemaakt door

None of the operands is truthy
Mogelijk gemaakt door

In het eerste voorbeeld zijn het geheel getal 42 en de niet-lege lijst [10, 20, 30] truthy. Omdat de or-operator ten minste één truthy operand nodig heeft, evalueert de hele expressie als truthy.

In het tweede voorbeeld is 42 truthy maar de lege lijst [] is falsy omdat het een lege reeks is. Omdat één van de twee operanden truthy is, evalueert de hele or-expressie als truthy.

In het laatste voorbeeld zijn zowel 0 als [] falsy. Daarom evalueert de hele expressie als falsy.

De or-operator gebruikt ook short-circuiting bij het evalueren van de expressie om onnodige evaluaties te vermijden. Laten we enkele voorbeelden bekijken om dit te illustreren:

print(42 or [10, 20, 30])
print(42 or [])
print([] or 42)
print([] or 0)
Mogelijk gemaakt door

42
42
42
0
Mogelijk gemaakt door

In het eerste voorbeeld is de eerste operand 42, wat truthy is. Omdat or slechts één truthy operand nodig heeft om de uiteindelijke truthiness van de hele expressie te bepalen, wordt deze eerste operand meteen geretourneerd. De tweede operand wordt niet geëvalueerd omdat de waarde daarvan geen invloed heeft op het eindresultaat. De or-operator retourneert de eerste operand, 42, niet de Booleaan True. In Python heeft elke truthy waarde hetzelfde effect als de Booleaan True in situaties zoals if- en while-statements.

In het tweede voorbeeld is de eerste operand ook 42, en de expressie retourneert dit geheel getal, zelfs als de tweede operand falsy is.

In het derde en vierde voorbeeld is de eerste operand de lege lijst, die falsy is. Daarom wordt in beide gevallen de tweede operand geretourneerd.

Voorbeeld: de online winkel voor programmeurs

Laten we de transacties van de online winkel die goederen aan programmeurs verkoopt opnieuw bekijken. Dit zijn de vier voorbeeldtransacties die we in dit voorbeeld gebruiken:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]
Mogelijk gemaakt door

Je moet enkele transacties identificeren om klantgedrag verder te onderzoeken. Je wilt de transacties vinden die zijn mislukt of een artikel bevatten met een prijs onder $75. Omdat je twee voorwaarden hebt en een transactie slechts aan minstens één van beide hoeft te voldoen, kun je de or-operator gebruiken:

for item in data:
    if item["Success"] == False or item["Price"] < 75:
        print(item)
Mogelijk gemaakt door

{'Item': 'Python Book', 'Price': 50, 'Quantity': 1, 'Success': True}
{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}
Mogelijk gemaakt door

Deze for-lus toont de regels die aan minstens één van de eisen voldoen. Het Python-boek en de kabels zijn inbegrepen omdat hun prijs onder $75 ligt. Het koffiezetapparaat is inbegrepen omdat de transactie niet geslaagd was.

Er is een alternatieve manier om de mislukte transacties te filteren, die we in de volgende sectie verkennen.

Python: de not-operator

De NOT-operator verschilt van AND en OR omdat hij slechts één operand nodig heeft. NOT zet true om naar false en omgekeerd. Hier is de waarheidstabel voor NOT:

We kunnen dit repliceren met de not-operator van Python:

options = True, False
    for a in options:
        print(f"not {a} evaluates to {not a}")
Mogelijk gemaakt door

not True evaluates to False
not False evaluates to True
Mogelijk gemaakt door

Python-not-operator: truthy en falsy

Net als bij and en or hoeft de operand die met not wordt gebruikt geen Booleaan te zijn. Omdat elk object ofwel truthy of falsy is, kan elk object met not worden gebruikt.

if not "python":
    print("The `if` statement evaluated as `True`")
else:
    print("The `if` statement evaluated as `False`")
Mogelijk gemaakt door

The `if` statement evaluated as `False`Mogelijk gemaakt door

Bekijk ook dit voorbeeld:

if not "":
    print("The `if` statement evaluated as `True`")
else:
    print("The `if` statement evaluated as `False`")
Mogelijk gemaakt door

The `if` statement evaluated as `True`
Mogelijk gemaakt door

Truthy waarden worden met de not-operator omgezet naar False en falsy waarden naar True.

In tegenstelling tot and en or retourneert de not-operator altijd een Booleaans object:

print(not "python")
print(not "")
Mogelijk gemaakt door

False
True
Mogelijk gemaakt door

Voorbeeld: de online winkel voor programmeurs

In de vorige secties gebruikten we de transacties van een online winkel. We willen in dit voorbeeld alle mislukte transacties tonen. Eén optie is de gelijkheidsoperator == gebruiken om te controleren of data["Success"] gelijk is aan False. We kunnen echter ook de not-operator gebruiken:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]
for item in data:
    if not item["Success"]:
        print(item)
Mogelijk gemaakt door

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
Mogelijk gemaakt door

Aangezien item["Success"] gelijk is aan False voor de mislukte transacties, retourneert not item["Success"] True. Daarom print de for-lus de mislukte transacties:

In de volgende sectie leren we hoe je meerdere logische operatoren in één expressie combineert.

Python: operatorprioriteit

In de voorbeelden tot nu toe gebruikten we telkens slechts één van de logische operatoren. In deze sectie bekijken we wat er gebeurt als we meer logische operatoren in één expressie combineren.

Python: and heeft voorrang op or

We gaan verder met de transacties uit de online winkel die we eerder gebruikten. Laten we de volgende voorwaardelijke instructie proberen:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]
​
for item in data:
    if item["Price"] > 100 or item["Quantity"] > 2 and item["Success"]:
        print(item)
Mogelijk gemaakt door

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}
Mogelijk gemaakt door

Het if-statement bevat twee logische operatoren. Voordat we onderzoeken hoe Python met deze expressie omgaat, kijken we naar een Engelse parafrase van het if-statement: Als de prijs van het artikel boven $100 ligt of de verkochte hoeveelheid groter is dan twee en de verkoop was geslaagd, print dan het item.

Deze zin is dubbelzinnig zonder extra leestekens en kan zelfs met meer komma's nog verwarring veroorzaken. Moet bijvoorbeeld de transactie met het koffiezetapparaat worden opgenomen? De prijs van het artikel ligt boven de vereiste drempel, maar de transactie was niet geslaagd.

Python loste deze ambiguïteit op door de and-operator voorrang te geven boven de or-operator. Dit betekent dat de and-expressie eerst wordt geëvalueerd en het resultaat vervolgens wordt gebruikt in de or-expressie.

Daarom wordt de expressie item["Quantity"] > 2 and item["Success"] eerst geëvalueerd. Deze expressie retourneert alleen voor de transactie met kabels een truthy waarde. Voor de overige items evalueert hij als falsy.

De waarde van de and-expressie wordt vervolgens gebruikt met de or-operator. De or-expressie retourneert een truthy waarde voor elk item dat truthy retourneert voor de and-expressie — dat was alleen de transactie met kabels — en voor items met een prijs boven $100. Er zijn twee items met prijzen boven de drempel: het koffiezetapparaat en de koptelefoon.

Python: haakjes en logische operatoren

Maar wat als we transacties nodig hebben met artikelen boven $100 of met een hoeveelheid boven twee, en we ook willen garanderen dat de transactie geslaagd is? In dit geval willen we dat de or-expressie voorrang krijgt op de and, zodat die eerst wordt geëvalueerd. Dat kunnen we bereiken met haakjes om de or-expressie:

for item in data:
    if (item["Price"] > 100 or item["Quantity"] > 2) and item["Success"]:
        print(item)
Mogelijk gemaakt door

{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}
Mogelijk gemaakt door

De extra haakjes geven de or-expressie voorrang. De transactie met het koffiezetapparaat wordt niet langer opgenomen omdat die falsy evalueert voor de tweede and-operand.

Python: not heeft voorrang op and en or

De not-operator heeft voorrang op and en or. not wordt dus geëvalueerd vóór de andere twee logische operatoren.

Beschouw het volgende if-statement, dat zowel not als and bevat:

for item in data:
    if not item["Success"] and item["Price"] > 100:
        print(item)
Mogelijk gemaakt door

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
Mogelijk gemaakt door

Omdat not eerst wordt geëvalueerd, zal deze expressie eerst de not-operator toepassen op item["Success"]. De waarde van de not-expressie wordt vervolgens gebruikt als eerste operand in de and-expressie. Alleen de entry met het koffiezetapparaat voldoet aan deze voorwaarde — dit is de enige transactie die is mislukt en een prijs boven $100 heeft.

We kunnen echter de and-operator voorrang geven door haakjes te gebruiken:

for item in data:
    if not (item["Success"] and item["Price"] > 100):
        print(item)
Mogelijk gemaakt door

{'Item': 'Python Book', 'Price': 50, 'Quantity': 1, 'Success': True}
{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}
Mogelijk gemaakt door

In dit geval wordt de and-expressie eerst geëvalueerd. Alleen de entry met de koptelefoon evalueert naar True, omdat dit de enige geslaagde transactie met een prijs boven $100 is. We plaatsen echter een not-operator vóór de expressie tussen haakjes. Daarom geeft de code de overige drie transacties weer.

In het algemeen, als een expressie te complex wordt omdat er te veel operatoren in staan, kun je die het beste opsplitsen om de leesbaarheid te vergroten.

Conclusie

De Python-logische operatoren and, or en not worden veel gebruikt in een breed scala aan programmeer- en data science-toepassingen. Deze operatoren repliceren het gedrag van de Booleaanse logische operatoren AND, OR en NOT die breed worden gebruikt in logica en wiskunde.

De Python-operatoren kunnen echter elk object accepteren en niet alleen Booleaanse waarden. De operatoren and en or gebruiken short-circuit-evaluatie en retourneren een van de operanden als uitvoer.

De Python-logische operatoren zijn belangrijke hulpmiddelen om gegevens te filteren, kenmerken in data sets te identificeren en complexe regels te maken om de stroom van een programma te sturen. Wil je hier meer over leren? Bekijk dan deze carrièretrack van negen cursussen: Data Analyst With Python.