If-instructies in Python: voorwaarden en booleaanse logica

Een vergelijking stelt een vraag over waarden. Het resultaat is een booleaanse waarde: True of False. Dit zijn waarden van het type bool, geschreven met een hoofdletter aan het begin en zonder aanhalingstekens. "True" is tekst; true met een kleine letter is een naam en veroorzaakt een NameError als die niet is gedefinieerd.

Kies de operator die bij de regel past

De operatoren met twee tekens blijven bij elkaar, met = achteraan. Schrijf <=, niet =<. Een geheel getal en een zwevendekommagetal kunnen gelijk zijn: 7 == 7.0 geeft True omdat hun getalswaarden overeenkomen.

Een vergelijking is een expressie, dus je kunt het resultaat afdrukken of opslaan:

x = 7
is_big = x > 5
print(is_big)

Python evalueert x > 5, krijgt True en kent die waarde toe aan is_big. De uitvoer is True. Een naam zoals is_big of has_ticket laat een booleaanse variabele lezen als een ja-neevraag.

Houd toekenning en vergelijking uit elkaar

x = 5 slaat een nieuwe waarde op in x. x == 5 controleert de huidige waarde zonder die te veranderen. if x = 5: schrijven is een syntaxisfout. De omgekeerde fout kan moeilijker op te merken zijn:

x = 7
x == 5
print(x)

In een script wordt het resultaat van de vergelijking niet gebruikt. De uitvoer blijft 7; de middelste regel kent nooit 5 toe.

Reken eerst en vergelijk daarna

In 2 + 3 > 4 telt Python eerst op tot 5 en vergelijkt daarna 5 > 4. Het resultaat is True. Een nuttige controle voor gehele getallen is n % 2 == 0: % geeft de rest na deling en even getallen laten rest 0 over bij deling door 2.

Voor n = 10 zijn de stappen 10 % 2 en daarna 0 == 0, wat True geeft. Voor n = -7 is -7 % 2 gelijk aan 1, dus is de controle op een even getal False. Met de positieve deler 2 is de rest in Python voor een oneven geheel getal 1, ook als dat getal negatief is.

Bepaal of de grens meetelt

“Minstens 18” omvat 18: age >= 18. “Ouder dan 18” sluit die leeftijd uit: age > 18. Zo is “jonger dan 13” gelijk aan age < 13 en “niet meer dan 3” aan bags <= 3. Test de grens zelf wanneer je een operator kiest. Bij age = 18 is de eerste leeftijdscontrole waar en de tweede onwaar.

Houd rekening met kleine verschillen tussen zwevendekommagetallen

Veel decimale breuken hebben alleen een binaire benadering. Python slaat 0.1 + 0.2 op als 0.30000000000000004, dus is 0.1 + 0.2 == 0.3 gelijk aan False.

Gebruik voor een vergelijking met een absolute tolerantie van 1e-9:

print(abs((0.1 + 0.2) - 0.3) < 1e-9)

abs() geeft de grootte van het verschil zonder het teken. Dat verschil is kleiner dan een miljardste, dus drukt deze controle True af. De tolerantie geeft aan hoeveel verschil deze controle accepteert; het is geen exacte gelijkheid.

De waarden aan beide kanten van een vergelijking zijn even belangrijk als de operator. Tekst kan eruitzien als een getal, maar toch de regels voor strings volgen.

Vergelijk tekst exact

Bij gelijkheid van strings wordt elk teken gecontroleerd, inclusief hoofdletters, kleine letters en spaties. "yes" == "Yes" is False en "yes" == "yes " is ook False. Vergelijk een opgeschoonde kopie om gewone verschillen in hoofdletters en spaties aan de randen te accepteren:

answer = " Yes "
print(answer.strip().lower() == "yes")

strip() verwijdert witruimte aan beide uiteinden. lower() zet letters om in kleine letters. De opgeschoonde tekst is "yes", dus is het resultaat True. De opgeslagen answer blijft ongewijzigd, tenzij je de opgeschoonde waarde eraan toekent.

Begrijp de volgorde van strings

Python vergelijkt strings van links naar rechts met Unicodecodepunten, de getallen die aan tekens zijn toegekend. Het stopt bij het eerste ongelijke paar. Bij Engelse letters zonder accent en met dezelfde hoofdlettergrootte volgt dit de alfabetische volgorde: "apple" < "banana" is True. Wanneer de ene string het begin van de andere is, komt de kortere eerst: "cat" < "catalog" is True.

Dit is geen volledige sorteervolgorde zoals in een woordenboek. A tot en met Z hebben codepunten 65–90 en a tot en met z hebben 97–122. Daarom is "Zebra" < "apple" gelijk aan True. Ook de é met accent komt na z, dus is "zebra" < "éclair" gelijk aan True.

Cijfers in strings volgen dezelfde tekenregel. "10" < "9" is True: de eerste vergelijking is tussen "1" en "9", niet tussen de getallen tien en negen.

Zet invoer om voor keuzes op basis van getallen

input() geeft een string terug. Als iemand 5 intypt, geeft "5" == 5 de waarde False; de gelijkheidscontrole zet de tekst niet om. Een vergelijking van de volgorde werkt anders: "5" < 10 veroorzaakt een TypeError, omdat Python die string en dat gehele getal niet samen kan ordenen.

age = int(input("Age: "))
print(age >= 18)

Voor de ingetypte tekst "18" levert int() het gehele getal 18 op en drukt de controle True af. Gebruik float() als de invoer een decimale waarde voorstelt.

Gebruik een keten voor een bereik

0 <= score <= 100 vereist dat beide aangrenzende vergelijkingen waar zijn. Het betekent 0 <= score and score <= 100. Voor score = 105 slaagt de onderste controle, maar niet de bovenste, dus is de hele keten False.

Een keten vergelijkt alleen aangrenzende waarden. 1 < 3 > 2 is True omdat 1 < 3 en 3 > 2 beide waar zijn; de keten vergelijkt 1 niet rechtstreeks met 2.

Kies zo nodig voor lidmaatschap of identiteit

De lidmaatschapsoperatoren controleren of tekst binnen tekst voorkomt. "nan" in "banana" is True; "Ban" in "banana" is False. "x" not in "banana" is True.

None staat voor geen waarde. Controleer erop met result is None of result is not None. De operator is vraagt of het om precies hetzelfde object gaat, terwijl == vraagt of waarden gelijk zijn. Gebruik == voor gelijkheid van getallen en strings: een identiteitscontrole zoals x is 5 is daarvoor onbetrouwbaar en veroorzaakt een SyntaxWarning.

Een if-instructie voert een blok alleen uit als de voorwaarde waar is. De kop begint met if, geeft de voorwaarde en eindigt met een dubbele punt. De regels eronder springen in om te laten zien dat ze bij de inhoud horen.

Volg een keuze met één mogelijke actie

temperature = 31
if temperature > 30:
    print("Hot day")
    print("Drink water")
print("Done")

Bij de kop leest Python de huidige waarde van temperature. De vergelijking 31 > 30 is True, dus worden beide ingesprongen regels uitgevoerd. Daarna bereikt het programma de regel buiten het blok. De uitvoer is:

Hot day
Drink water
Done

Verander de eerste regel in temperature = 25. Nu is 25 > 30 gelijk aan False, dus slaat Python de hele inhoud over. Alleen Done wordt afgedrukt. De voorwaarde wordt één keer gecontroleerd wanneer Python de kop bereikt; een if blijft die niet controleren.

Laat inspringing zien wat bij het blok hoort

Gebruik volgens de conventie 4 spaties voor elk inspringniveau. Regels op hetzelfde niveau horen bij hetzelfde blok. Terugkeren naar het buitenste niveau beëindigt het blok. Als je print("Done") 4 spaties laat inspringen, wordt die regel onderdeel van de if-inhoud en alleen afgedrukt als aan de voorwaarde is voldaan.

Een stroomdiagram toont dezelfde keuze met een ruit. Het pad voor waar gaat de inhoud in, het pad voor onwaar gaat eromheen en de paden komen samen bij de volgende instructie buiten het blok.

Python kan voor deze problemen SyntaxError, IndentationError of TabError melden. Begin bij de kop en de inspringing rond de gemelde regel. Ronde haakjes rond de voorwaarde zijn optioneel; if temperature > 30: is de gebruikelijke vorm.

De inhoud mag niet leeg zijn. Als je ruimte openlaat voor een actie, schrijf dan een ingesprongen pass. Dit is een geldige instructie die niets doet:

if temperature > 30:
    pass

Afzonderlijke controles zijn onafhankelijk

score = 95
if score >= 50:
    print("Pass")
if score >= 90:
    print("Excellent")

Python bereikt beide koppen. Beide voorwaarden zijn waar, dus worden beide meldingen afgedrukt. Afzonderlijke if-instructies passen bij regels waarvan de acties allemaal op dezelfde invoer van toepassing kunnen zijn.

Geef latere code een bruikbare waarde

Een naam waaraan alleen binnen het blok een waarde wordt toegekend, wordt mogelijk nooit aangemaakt:

x = 0
if x > 0:
    message = "positive"
print(message)

In een nieuw script wordt het blok overgeslagen en heeft message geen waarde, dus veroorzaakt de laatste regel een NameError. Een oplossing is vóór de keuze een beginwaarde opgeven:

x = 0
message = "not positive"
if x > 0:
    message = "positive"
print(message)

Nu heeft de latere regel op beide paden een waarde. Voor nul drukt die not positive af; voor een positieve x vervangt het blok die tekst door positive.

Een if–else-instructie kiest één van twee blokken. Als de voorwaarde waar is, voert Python het if-blok uit. Anders voert het het else-blok uit. Wanneer de uitvoering deze keuze bereikt, wordt precies één blok uitgevoerd.

Lijn de alternatieven uit

number = int(input("Enter a whole number: "))
if number % 2 == 0:
    print(number, "is even")
else:
    print(number, "is odd")

Voor invoer 14 is de rest 0, dus is de uitvoer 14 is even. Voor invoer -7 is de rest 1, dus is de uitvoer -7 is odd. De else hoort bij de if op hetzelfde inspringniveau. Het bijbehorende blok heeft een eigen inspringing.

Na else staat geen voorwaarde: het betekent dat de eerdere voorwaarde onwaar was. else number < 0: is een syntaxisfout. Zet de clausule direct na het if-blok; een niet-ingesprongen instructie die er niet bij hoort, verbreekt de structuur als die ertussen staat.

Controleer wat “al het andere” omvat

Bij if answer == "yes": betekent een else niet alleen "no". Die accepteert ook "maybe", "Yes" en "", omdat geen ervan gelijk is aan "yes". Dit is nuttig als alle resterende invoer dezelfde actie vereist. Als meerdere afgewezen invoeren verschillende reacties nodig hebben, zijn verdere controles nodig.

Ken op beide paden een waarde toe

Een verzendregel geeft gratis verzending bij totaalbedragen van minstens € 50 en rekent anders € 5,99:

total = 42.50
if total >= 50:
    shipping = 0
else:
    shipping = 5.99
print(total + shipping)

Eerst geeft 42.50 >= 50 de waarde False. Python slaat de toekenning van 0 over, voert de else uit en slaat 5.99 op. De laatste regel staat buiten beide blokken en drukt 48.49 af. Verander total in 60: het eerste blok slaat 0 op, het andere wordt overgeslagen en de laatste regel drukt 60 af. Beide routes definiëren shipping voordat die wordt gebruikt.

Kies een waarde met een voorwaardelijke expressie

Als alleen de toe te kennen waarde verschilt, kan een voorwaardelijke expressie dit op één regel uitdrukken:

shipping = 0 if total >= 50 else 5.99

De vorm is value_if_true if condition else value_if_false. Hoewel de waarde voor waar op de pagina eerst staat, evalueert Python eerst de voorwaarde. Het evalueert alleen de gekozen waarde en kent het resultaat daarna toe aan shipping.

Een ander voorbeeld is label = "even" if n % 2 == 0 else "odd". Voor n = 14 kiest dit "even". Voor n = -7 kiest dit "odd".

De expressie vereist beide waarden. x = 1 if flag is onvolledig en veroorzaakt een SyntaxError omdat er geen else-waarde is. Een volledige if-instructie mag else weglaten omdat ze op het pad voor onwaar eenvoudig geen actie kan uitvoeren; een expressie moet nog steeds een waarde opleveren.

Gebruik elif, een afkorting van “else if”, om nog een controle aan een keuze toe te voegen. Python probeert de voorwaarden van boven naar beneden. De eerste ware voorwaarde bepaalt welke tak wordt uitgevoerd en de rest van die keten wordt overgeslagen.

Volg een keuze voor een beoordeling

score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"
print(grade)

De eerste controle, 85 >= 90, is onwaar. De tweede, 85 >= 80, is waar, dus slaat Python "B" op. Het controleert de overige voorwaarden niet en gaat de else niet in. De uitvoer is B.

Gebruik wat eerdere mislukte controles je vertellen

Als elif score >= 80: wordt bereikt, weet je al dat de score onder 90 ligt. Voor gehele scores omvat deze tak 80 tot en met 89. Door and score < 90 toe te voegen, herhaal je een controle die het programma al heeft afgehandeld.

De volgorde is belangrijk omdat deze bereiken overlappen. Als score >= 60 eerst komt, vangt die 85 en 95 af voordat de controles voor hun hogere beoordelingen worden bereikt. Zet bij controles op een ondergrens met >= de hoogste drempelwaarde eerst. Begin bij controles op een bovengrens met < met de laagste drempelwaarde.

Houd één keuze in één keten

Als je de gereserveerde woorden elif vervangt door if, verandert het gedrag. Bij een score van 85 kent de controle voor 80 eerst "B" toe, daarna kent de controle voor 70 "C" toe en de controle voor 60 kent "D" toe. De eindwaarde is "D". Elke nieuwe if begint een onafhankelijke keuze.

Dit onderscheid heeft ook gevolgen voor else. In een groep afzonderlijke if-instructies hoort een afsluitende else alleen bij de bijbehorende if, niet bij de hele groep. Houd de takken verbonden als ze samen één indeling voorstellen.

Houd rekening met grenzen en invoer die niet overeenkomt

Een elif-keten mag een willekeurig aantal extra controles hebben en de afsluitende else is optioneel. Zonder resttak wordt mogelijk geen blok uitgevoerd:

temp = 20
if temp < 18:
    print("Cool")
elif temp > 24:
    print("Warm")

Aan geen van beide voorwaarden is voldaan. Voeg else: toe met een ingesprongen print("Comfortable") als elke temperatuur een melding nodig heeft. Zo blijft ook bij t < 18 gevolgd door t > 18 precies 18 zonder overeenkomst. Bij de beoordelingsgrenzen zou score > 90 de waarde 90 naar de "B"-tak sturen.

Tekstmenu’s gebruiken dezelfde structuur: controleer choice == "1", daarna choice == "2" en geef voor al het andere de reactie "Unknown option". Deze controles vergelijken strings omdat input() tekst teruggeeft. Als veel controles één waarde met vaste keuzes vergelijken, biedt match een andere manier om de keuze vorm te geven.

Met de booleaanse operatoren and, or en not kun je een voorwaarde opbouwen uit eenvoudigere voorwaarden. Python schrijft ze als woorden met kleine letters.

Bekijk alle mogelijkheden

Voor booleaanse invoer geeft and alleen True als beide invoeren waar zijn. or geeft True als minstens één ervan waar is, ook als beide waar zijn. Dit is een inclusieve of.

not keert een waarheidswaarde om: not True geeft False en not False geeft True. Een waarheidstabel vermeldt elke combinatie van booleaanse invoer. Voor twee invoeren zijn vier rijen nodig; voor drie zijn er acht nodig. Elke extra onafhankelijke booleaanse invoer verdubbelt het aantal combinaties.

Voor A and not B keer je eerst B om en combineer je het resultaat daarna met A. In de rij A = True, B = False is not B gelijk aan True, dus is het resultaat True. De andere drie rijen geven False.

Vertaal een regel naar volledige controles

Een museum geeft korting op de toegang aan bezoekers jonger dan 12 of van 65 jaar en ouder:

has_discount = age < 12 or age >= 65

Op leeftijd 10 slaagt de eerste vergelijking. Bij 65 slaagt de tweede. De leeftijden 30 en 64 voldoen aan geen van beide. Met and zou dezelfde leeftijd onder 12 en minstens 65 moeten zijn, wat niet kan.

Een attractie vereist een lengte van minstens 120 centimeter en geen hartaandoening:

can_ride = height >= 120 and not has_heart_condition

Aan beide eisen moet tegelijk zijn voldaan. Bij de minimumlengte met has_heart_condition = False slagen beide delen. Als niet aan een van de eisen is voldaan, is can_ride gelijk aan False.

Maak onderscheid tussen binnen en buiten een bereik

De controle voor binnen het bereik heeft beide grenzen nodig. Voor buiten het bereik hoeft slechts aan één grens niet te zijn voldaan. score < 0 and score > 100 kan voor één getal nooit waar zijn.

Elke vergelijking heeft beide kanten nodig. score >= 0 and <= 100 is onvolledige syntaxis. Een minder opvallend probleem wordt zonder fout uitgevoerd:

if answer == "y" or "yes":
    print("Accepted")

Python ziet (answer == "y") or "yes". Wanneer de vergelijking onwaar is, zorgt de niet-lege string "yes" er toch voor dat de voorwaarde als waar wordt beschouwd. Herhaal de vergelijking: answer == "y" or answer == "yes".

Ook bij alledaagse formuleringen moet je opletten. “Gesloten op zaterdag en zondag” betekent day == "Saturday" or day == "Sunday"; één dag hoeft niet beide namen tegelijk te hebben. Ontken een booleaanse variabele rechtstreeks met not is_member. Een ontkende vergelijking zoals not (age >= 18) kan ook eenvoudiger worden geschreven als age < 18. De operatoren van Python zijn hier woorden, geen &&, || of !.

Bij een langere voorwaarde moet je twee vragen beantwoorden: hoe zijn de delen gegroepeerd en welke delen evalueert Python daadwerkelijk? Operatorprioriteit beantwoordt de eerste vraag. Kortsluitevaluatie beantwoordt de tweede.

Bekijk eerst de groepering

Voor de operatoren die hier worden gebruikt, loopt de prioriteit van sterk naar zwak:

1. Machtsverheffen: **.
2. Vermenigvuldiging, deling, gehele deling, rest: *, /, //, %.
3. Optelling en aftrekking: +, -.
4. Vergelijkingen, waaronder in, not in, is en is not.
5. not, dan and, dan or.
6. De voorwaardelijke expressie: a if condition else b.

Ronde haakjes veranderen de groepering. Zo wordt x > 3 or x < 0 and x != 5 gegroepeerd als x > 3 or (x < 0 and x != 5). Bij x = 5 is de linkervergelijking waar en wordt de hele rechtergroep overgeslagen. Het resultaat is True.

Bij (x > 3 or x < 0) and x != 5 maken de haakjes de eerste groep juist tot één operand van and. Bij x = 5 is die groep waar, maar x != 5 is onwaar, dus is het resultaat False.

Daarom accepteert is_weekend or is_holiday and is_sunny elk weekend, zelfs als het regent. Schrijf voor de regel “een vrije dag waarop het ook zonnig is” (is_weekend or is_holiday) and is_sunny.

Volg de evaluatie van links naar rechts

Bij and heeft een onwaar eerste deel al uitgesloten dat aan de hele voorwaarde wordt voldaan. Bij or heeft een waar eerste deel er al aan voldaan. De prioriteit dwingt Python niet om een overgeslagen operand te berekenen alleen omdat die sterker bindende operatoren bevat.

Je kunt dit gebruiken om een beschermende voorwaarde vóór een bewerking te plaatsen die zou mislukken:

count = 0
total = 50
is_large_average = count != 0 and total / count > 10
print(is_large_average)

count != 0 is onwaar, dus probeert Python 50 / 0 nooit. Het slaat False op en drukt die waarde af. Als je de operanden omdraait, wordt de deling eerst geprobeerd en ontstaat een ZeroDivisionError; de latere controle kan eerder werk niet beschermen.

Werk not door een gegroepeerde controle heen

De wetten van De Morgan herschrijven een ontkenning door elk deel te ontkennen en de verbindende operator te verwisselen:

“Geen tiener” kan worden gecontroleerd als not (age >= 13 and age <= 19). De equivalente directe controle is age < 13 or age > 19. De leeftijden 12 en 20 voldoen; 13, 16 en 19 niet.

Als je and behoudt nadat je beide delen hebt ontkend, verandert de regel. Bij A = True, B = False is not (A and B) waar, maar not A and not B onwaar. Vergelijk elke rij van de waarheidstabel wanneer je controleert of twee booleaanse vormen equivalent zijn.

Schrijf voor een variabele die al een booleaanse waarde bevat if is_valid: of if not is_valid:. Een vergelijking met True of False voegt een controle toe die de voorwaarde niet nodig heeft.

Een geneste voorwaardelijke instructie plaatst één keuze binnen een tak van een andere. De binnenste keuze wordt alleen bereikt als de uitvoering die buitenste tak ingaat. Elk nestingsniveau voegt 4 spaties inspringing toe.

Volg de buitenste keuze vóór de binnenste keuze

has_ticket = True
age = 15
if has_ticket:
    if age >= 13:
        print("Enjoy the movie")
    else:
        print("This movie needs an adult")
else:
    print("Please buy a ticket first")

Eerst is has_ticket waar, dus gaat Python het buitenste blok in. Daarna controleert het 15 >= 13, krijgt waar en drukt Enjoy the movie af. De binnenste en buitenste else-blokken worden beide overgeslagen.

Verander de leeftijd in 10 en behoud het kaartje. Python gaat nog steeds het buitenste blok in, maar aan de binnenste voorwaarde is niet voldaan, dus drukt het This movie needs an adult af. Met has_ticket = False wordt de leeftijdscontrole nooit bereikt; de buitenste else drukt Please buy a ticket first af.

Koppel elke else op basis van inspringing

Een else hoort bij de if op hetzelfde inspringniveau. Verplaatsen kan het gedrag veranderen, ook als het script geldig blijft. Bekijk deze kleinere variant:

if has_ticket:
    if age >= 13:
        print("Enter")
else:
    print("Buy a ticket")

De else hoort bij if has_ticket:. Een 10-jarige met een kaartje krijgt geen melding. Verplaats die else en het bijbehorende blok één niveau naar binnen en ze hoort bij if age >= 13:. Nu krijgt hetzelfde kind Buy a ticket te zien, terwijl iemand zonder kaartje geen melding krijgt. De gewijzigde indeling drukt een andere regel uit.

In het volledige filmvoorbeeld heeft de binnenste if al een else. Als je daar de buitenste else naar binnen verplaatst, ontstaan twee alternatieven voor dezelfde if en een syntaxisfout.

Verminder de nesting bij twee eisen

Als er maar één actie is en geen van beide niveaus een else heeft, verwijdert and vaak een nestingsniveau:

if is_member and total >= 50:
    print("Free shipping")

Dit voert dezelfde actie uit als een buitenste if is_member: met daarin een binnenste if total >= 50:. Aan beide eisen moet zijn voldaan en de tweede wordt pas bereikt nadat aan de eerste is voldaan. Behoud de nesting wanneer de buitenste takken eigen, verschillende acties nodig hebben, zoals bij het kopen van een kaartje.

Een else waarvan de enige actie een andere if–else is, kan een elif-keten worden. Voor positief, negatief en nul is de vorm zonder nesting if x > 0:, dan elif x < 0:, dan else:. Die behoudt dezelfde drie uitkomsten met minder inspringing.

Valideer voordat je indeelt

Een keuze voor een beoordeling moet scores buiten het toegestane bereik afwijzen voordat een letter wordt toegekend:

if 0 <= score <= 100:
    if score >= 90:
        print("A")
    else:
        print("Below A")
else:
    print("Score must be between 0 and 100")

Bij score = 150 mislukt de buitenste controle, dus wordt geen beoordeling toegekend. Nesting maakt ook onmogelijke paden zichtbaar: een binnenste if x < 5: onder if x > 10: kan nooit slagen. Als de inspringing diep wordt, zoek dan naar gecombineerde eisen, een elif-keten of een eerdere validatiecontrole die de resterende paden duidelijker maakt.

Python kan een waarde rechtstreeks in een voorwaarde toetsen. De waarheidsinterpretatie bepaalt of het blok wordt uitgevoerd. Dit bespaart vergelijkingen, maar de waarheidsinterpretatie van de waarde kan verschillen van wat de tekst lijkt te zeggen.

Herken als onwaar beschouwde waarden

Voor de ingebouwde typen hier worden False, None, numerieke nul, lege strings en lege collecties als onwaar beschouwd. Getallen ongelijk aan nul en niet-lege strings of collecties worden als waar beschouwd.

bool() zet een waarde om naar haar booleaanse waarheidswaarde. In een voorwaarde kiest if value: dezelfde tak als if bool(value):. Het verandert de opgeslagen waarde niet in een booleaanse waarde.

Controleer lege invoer zonder die verkeerd te lezen

name = input("Name: ")
if name:
    print("Hello", name)
else:
    print("No name entered")

Als je op Enter drukt zonder iets te typen, levert dat "" op, dus wordt het tweede blok uitgevoerd. Een naam die geheel uit spaties bestaat, is niet leeg en voldoet aan de eerste controle. if name.strip(): controleert daarentegen de tekst nadat witruimte aan de randen is verwijderd, zodat een antwoord met alleen spaties ook niet voldoet.

Een ja-neeantwoord vereist een andere vraag. if answer: wordt uitgevoerd voor "no" en "False" omdat beide tekens bevatten. Vergelijk de tekst om instemming te herkennen, bijvoorbeeld answer == "yes". Waarheidsinterpretatie controleert of een waarde leeg is, niet de betekenis van een woord.

Houd een geldige nul gescheiden van ontbrekende gegevens

Stel dat quantity gelijk is aan None voordat een waarde is opgegeven en terecht 0 mag zijn. if quantity: wijst beide af. Gebruik quantity is not None om te vragen of een waarde aanwezig is; dit accepteert nul.

Voor een echte booleaanse variabele is rechtstreeks toetsen duidelijk. Voor andere waarden doet x == True iets anders dan if x:. Met x = 5 slaagt de controle op waarheidsinterpretatie, maar is 5 == True onwaar; bij numerieke gelijkheid wordt True als gelijk aan 1 behandeld, niet aan elk getal ongelijk aan nul.

and en or geven een waarde terug die ze bekijken

Deze operatoren geven een operand terug, die niet per se een booleaanse waarde is:

Bij or geeft Python de linkerwaarde terug als die als waar wordt beschouwd; anders evalueert het de rechterwaarde en geeft die terug. Bij and geeft het de linkerwaarde terug als die als onwaar wordt beschouwd; anders evalueert het de rechterwaarde en geeft die terug.

display_name = name or "Guest" levert een standaardwaarde voor lege invoer. Hetzelfde patroon met quantity or 1 vervangt een echte nul door 1. Gebruik een standaardwaarde alleen op deze manier als elke als onwaar beschouwde waarde ontbrekend betekent. not gedraagt zich anders: het geeft altijd True of False terug. Als een opgeslagen vlagvariabele booleaans moet zijn, zet has_name = bool(name or nickname) de gekozen tekst om naar een waarheidswaarde.

Een script kan zonder syntaxisfout worden uitgevoerd en toch de verkeerde tak kiezen. Bij stapsgewijs volgen doorloop je één uitvoering met de hand. Bij testen voer je gekozen invoer uit en vergelijk je het waargenomen resultaat met het resultaat dat de regel vereist.

Plan en volg een pad

Leg de keuzes voordat je code schrijft vast in stappen in gewone taal, of pseudocode. Een stroomdiagram plaatst elke voorwaarde in een ruit met pijlen voor waar en onwaar. Beide paden hebben een duidelijke volgende stap of een duidelijk einde nodig.

Om code stap voor stap te volgen, schrijf je de beginwaarden op, evalueer je elke bereikte voorwaarde, noteer je toekenningen en neem je de uitvoer exact over. Voor de cijferketen bij score = 72:

“Niet geëvalueerd” is iets anders dan onwaar. Python heeft al een tak gekozen en heeft de latere vergelijkingen dus niet nodig.

Test elke tak en grens

Een keten met vier takken heeft minstens vier invoeren nodig om elke tak één keer uit te voeren. Kies ze op basis van de bedoelde routes, niet op basis van hoe verschillend de getallen eruitzien. Meerdere hoge scores kunnen allemaal hetzelfde eerste blok doorlopen.

Alleen takdekking kan een verkeerde grens missen. Test voor age >= 18 de waarden 17, 18 en 19. Een onjuiste > geeft bij de twee buitenste controles het verwachte resultaat, maar wijst de exacte grens af. Vergelijk voor een beoordelingsgrens van 90 de waarden 89, 90 en 91; doe hetzelfde bij de andere drempelwaarden. Kies voor decimale invoer nabijgelegen waarden die passen bij de precisie van de meting.

Zoek takken die niet kunnen worden uitgevoerd

if score >= 60:
    print("Pass")
elif score >= 90:
    print("Excellent")

De tweede tak is onbereikbaar. Elke score van minstens 90 voldeed al aan de eerste voorwaarde. Zet de strengere drempelwaarde eerst of verander de bereiken zodat ze bij de bedoelde regel passen.

Een hiaat laat een bedoeld geval onafgehandeld: t < 0 gevolgd door t > 0 slaat nul over. Door een overlapping kunnen meerdere onafhankelijke acties worden uitgevoerd: de afzonderlijke controles t >= 0 en t <= 10 slagen beide voor 5. Een keten voert alleen de eerste tak met een ware voorwaarde uit, maar de volgorde bepaalt nog steeds welke overlappende voorwaarde voorrang krijgt.

Neem lastige invoer mee

Test negatieve waarden, nul, lege tekst en antwoorden met hoofdletters wanneer het script kleine letters verwacht. Als alleen "y" en "n" worden geaccepteerd, geef dan op alle andere tekst een duidelijk antwoord zoals "Please answer y or n".

Wanneer een controle zich onverwacht gedraagt, onderzoek je de waarde en het type voordat je de verdachte vergelijking evalueert:

print(repr(age), type(age))

Voor age = "18" drukt dit '18' <class 'str'> af. Zet de tekst om voordat je age >= 18 probeert; als je de foutieve vergelijking in diezelfde diagnostische print() zou plaatsen, ontstaat een TypeError voordat de diagnostische uitvoer verschijnt. Controleer bij structuurproblemen de inspringing en de syntaxisfoutmelding.

Tot slot kan een vergelijking rechtstreeks een booleaanse vlagvariabele instellen: is_adult = age >= 18. Dit vervangt twee takken die alleen True en False toekennen. Gebruik bool() wanneer de onderliggende expressie een ander soort waarde kan teruggeven.

Een match-instructie, beschikbaar in Python 3.10 en later, toetst één waarde aan een reeks patronen. Die waarde is de te toetsen waarde. Elke case bevat een patroon en een ingesprongen blok.

Volg het eerste overeenkomende geval

command = "stop"
match command:
    case "start":
        print("Starting")
    case "stop":
        print("Stopping")
    case _:
        print("Unknown command")
print("Ready")

De te toetsen waarde is "stop". Die komt niet overeen met "start", dus probeert Python het volgende geval. "stop" komt overeen en het blok drukt Stopping af. Python verlaat dan de hele match-instructie en drukt Ready af. Slechts één gevalblok wordt uitgevoerd; de uitvoering loopt niet door naar het volgende blok en er is geen break nodig.

De te toetsen waarde "jump" bereikt het afsluitende jokerpatroon, _, dat elke waarde accepteert. De uitvoer is Unknown command en daarna Ready. Zonder dat geval wordt bij een waarde die niet overeenkomt gewoon geen gevalblok uitgevoerd en gaat de uitvoering verder na de instructie.

Houd de indeling en resttak op volgorde

De case-koppen springen 4 spaties in onder match en hun blokken nog eens 4 spaties. Elke kop eindigt met een dubbele punt. Een case _: zonder aanvullende voorwaarde moet als laatste komen, omdat die alles accepteert. Als je er meer gevallen achter zet, ontstaat een SyntaxError: die latere patronen kunnen nooit worden bereikt.

Een jokerpatroon met een aanvullende voorwaarde mag eerder staan, omdat niet aan die extra voorwaarde hoeft te zijn voldaan. Een match-instructie in een script dat achtereenvolgens wordt uitgevoerd, kan ook geen break bevatten; die instructie vereist een omvattende lus.

Begrijp hoe letterlijke waarden overeenkomen

Een patroon met een letterlijke waarde gebruikt een vast getal, een vaste string, True, False of None. Stringpatronen zijn exact en hoofdlettergevoelig: "stop" komt niet overeen met "Stop". Numerieke patronen gebruiken gelijkheid, dus case 1: komt overeen met 1, 1.0 en True, dat gelijk is aan 1.

De patronen True, False en None gebruiken daarentegen identiteit. Daarom komt case True: overeen met de booleaanse waarde True, maar niet met het gehele getal 1. De volgorde van patronen is belangrijk als zowel een numeriek als een booleaans geval de te toetsen waarde zou kunnen accepteren.

Verbind vaste alternatieven met een verticale streep

Een of-patroon verbindt alternatieven met |:

day = int(input("Day number: "))
match day:
    case 6 | 7:
        print("Weekend")
    case 1 | 2 | 3 | 4 | 5:
        print("Weekday")
    case _:
        print("Not a day number")

Voor 6 wordt het eerste blok uitgevoerd; voor 3 het tweede; voor 9 het jokerpatroon. Zonder int() blijft de ingetypte "6" een string en komt die niet overeen met het getal 6.

Gebruik het patroonscheidingsteken |, niet het booleaanse woord or. case "y" or "yes": is ongeldig; case "y" | "yes": is geldig.

Voor vaste opdrachten kan een if–elif-keten op basis van gelijkheid dezelfde uitvoer opleveren. Kies de indeling waarin de gevallen het gemakkelijkst te lezen zijn.

Patronen kunnen meer dan een vaste letterlijke waarde controleren. Een patroon kan de te toetsen waarde een naam geven en een aanvullende voorwaarde kan een extra eis controleren voordat het geval wordt geaccepteerd.

Bind eerst de waarde en controleer daarna de aanvullende voorwaarde

Een bindingspatroon is een losse naam zoals n. Het accepteert elke te toetsen waarde en kent die toe aan de naam. Een aanvullende voorwaarde volgt op het patroon met if condition; het blok wordt alleen uitgevoerd als het patroon overeenkomt en de aanvullende voorwaarde waar is.

temperature = -5
match temperature:
    case 0:
        print("Exactly freezing")
    case t if t < 0:
        print("Below freezing by", -t, "degrees")
    case _:
        print("Above freezing")

Bij -5 komt de eerste letterlijke waarde niet overeen. Het volgende patroon bindt -5 aan t en controleert daarna t < 0. De aanvullende voorwaarde is waar, dus is de uitvoer Below freezing by 5 degrees.

Bij 0 wordt het geval met de letterlijke waarde gekozen voordat het bindingspatroon wordt geprobeerd. Bij 12 slaagt het bindingspatroon, maar is de aanvullende voorwaarde onwaar, dus probeert Python het jokerpatroon en drukt Above freezing af. Een onware aanvullende voorwaarde beëindigt het zoeken naar een geval niet.

Een losse naam zoekt geen constante op

Stel dat QUIT = "q". Het is verleidelijk om case QUIT: te schrijven om te controleren of de te toetsen waarde gelijk is aan die waarde. Maar een losse naam is altijd een bindingspatroon, ook als die uit hoofdletters bestaat. Het geval accepteert elke te toetsen waarde en overschrijft QUIT daarmee.

Als er meer gevallen volgen op een bindingspatroon zonder aanvullende voorwaarde, meldt Python een syntaxisfout omdat het bindingspatroon die gevallen onbereikbaar maakt. Als het bindingspatroon als laatste staat, kan de fout ongemerkt worden uitgevoerd. Vergelijk expliciet met een aanvullende voorwaarde:

QUIT = "q"
key = "x"
match key:
    case k if k == QUIT:
        print("Quit")
    case _:
        print("Keep working")

Hier bindt k de waarde "x". De aanvullende voorwaarde vergelijkt die met de bestaande "q", is onwaar en laat het jokerpatroon Keep working afdrukken. Een letterlijke case "q": is eenvoudiger als de vaste waarde rechtstreeks kan worden geschreven.

Herken een waardepatroon met een punt

Een naam met een punt zoals math.pi is een waardepatroon, geen bindingspatroon. Het zoekt een bestaande waarde op en vergelijkt de te toetsen waarde daarmee met ==. Benoemde constanten uit modules of klassen kunnen deze vorm gebruiken. Het onderscheid zit in de punt: case n: kent een waarde toe aan een naam; een patroon met een punt controleert een bestaande waarde.

Geef een specifieke overeenkomst een naam met as

answer = "y"
match answer:
    case "y" | "yes" as accepted:
        print("Accepted:", accepted)
    case _:
        print("Please answer y or yes")

Het of-patroon controleert de toegestane strings en as slaat de overeenkomende te toetsen waarde op in accepted. Voor "y" is de uitvoer Accepted: y. Het vervangt de invoer niet door een standaardwoord: "yes" zou "yes" opslaan. "Yes" komt met geen van beide strings overeen, omdat hoofdletters nog steeds van belang zijn.

Een of twee aanvullende voorwaarden kunnen goed tussen vaste gevallen passen. Wanneer bijna elk geval een bereikcontrole is of verschillende variabelen gebruikt, is een if–elif-keten meestal duidelijker. Beide structuren hebben een afsluitende resttak nodig als elke invoer een antwoord moet krijgen.