Lussen in Python

Een lus herhaalt een codeblok. Elke doorgang door het blok is een iteratie. Een while-lus controleert vóór elke doorgang een voorwaarde en voert de lusinhoud uit zolang die voorwaarde waar is. Dit past bij een taak zoals “blijf optellen totdat het totaal 100 bereikt”.

Startwaarde, toets en bijwerking

Een tellus heeft een startwaarde, een voorwaarde en een bijwerking nodig. De kop eindigt met een dubbele punt. Laat de lusinhoud met vier spaties inspringen:

n = 3
while n > 0:
    print(n)
    n = n - 1
print("Liftoff!")

De uitvoer is:

3
2
1
Liftoff!

Bij de eerste controle is n > 0 waar omdat n gelijk is aan 3. Python toont 3, trekt er 1 van af en gaat terug naar de kop. Dit herhaalt zich met 2 en daarna 1. Door de bijwerking wordt n gelijk aan 0, dus is de volgende controle onwaar. Python slaat de lusinhoud over en voert de laatste print uit.

De inspringing bepaalt wat wordt herhaald. Beide ingesprongen regels horen bij de lusinhoud. De laatste regel springt even ver in als while en wordt dus eenmaal na de lus uitgevoerd. Een if controleert de voorwaarde eenmaal; while gaat na elke voltooide lusinhoud terug om opnieuw te controleren.

De controle gebeurt aan het begin

Een variabele veranderen onderbreekt de rest van de huidige lusinhoud niet:

n = 1
while n > 0:
    n -= 1
    print("Still in this pass")
print(n)

Dit toont Still in this pass en daarna 0, op afzonderlijke regels. De bijwerking maakt de voorwaarde onwaar, maar Python controleert die pas wanneer het teruggaat naar de kop. Als je in plaats daarvan begint met n = 0, wordt de hele lusinhoud overgeslagen: een while-lus kan nul keer worden uitgevoerd.

Korte bijwerkingen en veranderende waarden

n -= 1 betekent n = n - 1. Op dezelfde manier telt count += 1 er 1 bij op, vermenigvuldigt balance *= 1.07 met 1,07 en vervangt n //= 10 de waarde van n door het gehele quotiënt bij deling door 10. Python heeft geen verhogingsoperator: count++ is een syntaxisfout. Als je ++count schrijft, pas je tweemaal de unaire plus toe en blijft het gehele getal ongewijzigd.

Hier verwijdert een lus bij elke doorgang één cijfer:

n = 472
total = 0
while n > 0:
    total += n % 10
    n //= 10
print(total)

De rest n % 10 is het laatste cijfer. Eerst wordt 2 opgeteld en wordt n gelijk aan 47. Daarna wordt 7 opgeteld en wordt n gelijk aan 4. Ten slotte wordt 4 opgeteld en wordt n gelijk aan 0. De uitvoer is 13. De bijwerking bereidt zowel de volgende doorgang voor als de beëindiging van de lus.

Bij een lus met een doelwaarde hoeft het aantal herhalingen niet vooraf bekend te zijn. Als je begint met een saldo van 1000, dit met 1,07 vermenigvuldigt en een jaarteller verhoogt totdat het saldo 2000 bereikt, zijn 11 doorgangen nodig. Na 10 doorgangen is het saldo ongeveer 1967,15; na 11 is het ongeveer 2104,85.

Voorwaarden kunnen vergelijkingen combineren met and, or en not. Waarheidsinterpretatie werkt ook: voor een geheel getal herhaalt while n: zolang n niet nul is. Gebruik een voorwaarde waarvan de betekenis gemakkelijk te volgen is. Spring consequent in met spaties; niet-overeenkomende niveaus kunnen een IndentationError veroorzaken en gemengde tabs en spaties kunnen een TabError veroorzaken.

Een oneindige lus blijft herhalen zonder een uitgang te bereiken. Je ziet mogelijk dezelfde uitvoer voorbij blijven komen of een programma dat niets lijkt te doen. Volg de waarden die in de voorwaarde worden gebruikt en zoek naar een bereikbare uitweg om de oorzaak te vinden.

Zoek de bijwerking

Deze lus blijft 3 tonen:

n = 3
while n > 0:
    print(n)

De toets blijft waar omdat niets n verandert. Voeg n -= 1 toe binnen de lusinhoud om de waarden 3, 2 en 1 te tonen voordat de lus stopt. Het helpt niet om die bijwerking na de lus te plaatsen: het programma kan die niet bereiken zolang de lus nog loopt.

Ook de richting is belangrijk. Bij while n > 0: laat een bijwerking met n += 1 een positieve waarde groeien. Gehele getallen in Python slaan niet bij een vast maximum om en zorgen dus niet per ongeluk voor een uitweg. Benoem de verandering die je verwacht, zoals “één poging minder over”, en controleer of de code die verandering op elk pad door de lusinhoud uitvoert.

Een doel kan worden gemist

Een bijwerking kan de waarde bij elke doorgang veranderen en toch nooit een doel bereiken waarmee op gelijkheid wordt getoetst:

n = 1
while n != 10:
    print(n)
    n += 2

De waarden zijn 1, 3, 5, 7, 9, 11 enzovoort. Ze zijn altijd oneven, dus is geen ervan gelijk aan 10. Gebruik voor de taak “toon oneven waarden onder 10” de voorwaarde while n < 10:. Zodra n gelijk wordt aan 11, is die voorwaarde onwaar. De keuze van de vergelijking moet passen bij de vraag of de taak eindigt bij een waarde of wanneer een grens wordt overschreden.

Decimale stappen en exacte gelijkheid

Veel decimale breuken worden als zwevendekommagetallen bij benadering opgeslagen. Als je tien keer 0.1 bij 0.0 optelt, krijg je 0.9999999999999999. Een lus die op exacte gelijkheid met 1.0 wacht, mist daardoor het bedoelde stoppunt.

Als de taak is om een vaste reeks tienden te doorlopen, tel je met gehele getallen en bereken je elk decimaal getal:

for i in range(11):
    x = i / 10
    print(x)

Dit doorloopt 11 waarden van 0.0 tot en met 1.0. Het gehele aantal bepaalt de herhalingen; het opgeslagen decimale getal bepaalt niet of de lus moet stoppen.

Controleer elke route door de lusinhoud

Zoek voordat je een while-lus uitvoert de startwaarden, de voorwaarde en elke instructie die die waarden verandert. Controleer of de verandering de voorwaarde onwaar kan maken. Als een if een bijwerking overslaat, volg je ook die route. Een tijdelijke regel zoals print("n =", n) binnen de lusinhoud kan een waarde laten zien die vastzit of zich van de grens verwijdert.

Druk op Ctrl+C in een terminal om een actief programma te onderbreken, of gebruik de knop Stop of Interrupt van de editor. In een terminal meldt Python normaal gesproken KeyboardInterrupt met een stacktrace.

Bewuste herhaling

while True: houdt de voorwaarde in de kop bewust waar. De lusinhoud gebruikt break om de lus te verlaten wanneer een gebeurtenis optreedt, bijvoorbeeld als de gebruiker “quit” invoert. De uitgang moet bereikbaar zijn. Een invoerlus kan blijven wachten omdat de gebruiker nog niet heeft gevraagd om te stoppen; een lus waarvan de logica de bedoelde uitgang onmogelijk maakt, is een programmeerfout.

Een invoerlus kan een onbekende hoeveelheid gegevens verzamelen of blijven vragen totdat een antwoord aanvaardbaar is. In beide gevallen moet de nieuwe invoer de volgende beslissing om te herhalen beïnvloeden.

Stop bij een stopwaarde

Een stopwaarde is een speciale invoerwaarde die “geen gegevens meer” betekent. Kies een waarde die geen echt gegeven kan zijn. Voor positieve aantallen kan 0 werken; als 0 een geldige meting is, kies je een ander stopsignaal.

De eerste invoer vóór de lus haalt de eerste waarde op voordat de voorwaarde wordt gecontroleerd:

total = 0
number = int(input("Number (0 to stop): "))
while number != 0:
    total += number
    number = int(input("Number (0 to stop): "))
print("Total:", total)

Bij de invoer 4, 7 en 0 telt de lusinhoud eerst 4 op en daarna 7. Door 0 te lezen wordt de volgende voorwaarde onwaar. Het programma toont Total: 11; het verwerkt de stopwaarde nooit. Als de eerste invoer 0 is, wordt de lusinhoud nul keer uitgevoerd en blijft het totaal 0.

De laatste leesinstructie binnen de lusinhoud is essentieel. Zonder die instructie wordt dezelfde eerste waarde eindeloos verwerkt. De toets moet ook plaatsvinden voordat een nieuw gelezen waarde wordt verwerkt: anders kan een stopwaarde als gegeven worden meegeteld.

Houd typen consistent

input() geeft tekst terug. De string "0" is niet gelijk aan het gehele getal 0. Converteer numerieke invoer met int() voordat je die met een numerieke stopwaarde vergelijkt, of houd de invoer als tekst en vergelijk met een string zoals "done". Een numerieke conversie verwacht een geldige numerieke string; een bereikcontrole toetst het resulterende getal.

Houd voor een gemiddelde naast het totaal een teller bij. Met stopwaarde -1 en invoer 8, 6, 10 en -1 is het totaal 24 en het aantal 3. Deel na de lus om 8.0 te krijgen. Als de eerste invoer -1 is, blijft het aantal 0, dus gebruik je if count > 0: vóór de deling. Zo verwerk je een lege gegevensverzameling zonder ZeroDivisionError.

Vraag opnieuw zolang een antwoord ongeldig is

Een validatielus beschrijft de onaanvaardbare antwoorden in haar voorwaarde:

age = int(input("Age (0-120): "))
while age < 0 or age > 120:
    print("Please enter an age from 0 to 120.")
    age = int(input("Age (0-120): "))
print("Thank you.")

Bij 150, -2 en 34 verschijnt de waarschuwing twee keer. De waarde 34 maakt beide vergelijkingen onwaar, dus eindigt de lus. De grenswaarden 0 en 120 worden ook geaccepteerd.

Het woord or is belangrijk: een leeftijd is ongeldig als die onder het minimum of boven het maximum ligt. Met age < 0 and age > 120 zou niets worden afgewezen, omdat één getal niet aan beide voorwaarden kan voldoen.

Voor een ja-neeantwoord is de toets op een ongeldig antwoord answer != "y" and answer != "n". Een antwoord moet van beide geaccepteerde strings verschillen om te worden afgewezen. Met or zou zelfs "y" de lus laten herhalen omdat het verschilt van "n". Volg één aanvaardbaar en één onaanvaardbaar antwoord om zo’n voorwaarde te controleren.

Voor dezelfde taken kun je while True gebruiken met één leesinstructie in de lusinhoud, gevolgd door een stoptoets en break. Daarmee komt de beslissing direct na de invoer en hoef je de leesinstructie niet twee keer te schrijven.

Een for-lus doorloopt de elementen van een sequentie op volgorde. Bij elke doorgang kent Python het volgende element toe aan de lusvariabele en voert het de ingesprongen lusinhoud uit. Een lus over een sequentie heet vaak een lus met een bepaald aantal herhalingen, omdat de elementen bepalen welk werk moet worden uitgevoerd.

Eén element tegelijk

Een string is een sequentie van tekens:

for ch in "cat":
    print(ch)

Dit toont c, a en t op afzonderlijke regels. Spaties en leestekens tellen ook als tekens. De string "hi there" heeft acht tekens, inclusief de spatie, dus kost het acht doorgangen om elk teken te doorlopen.

Een lijst bevat een sequentie van waarden. De letterlijke vorm gebruikt vierkante haken en komma’s:

scores = [3, 41, 12]
for score in scores:
    print(score * 2)

De uitvoer is 6, 82 en 24, elk op een eigen regel. score is steeds één getal, niet de hele lijst en ook niet de positie ervan. Je hoeft geen teller handmatig bij te werken om van 3 naar 41 naar 12 te gaan.

Gebruik een naam die één element beschrijft: name in names of score in scores. Als de lusinhoud de huidige waarde nooit nodig heeft, is _ een gebruikelijke naam voor die ongebruikte lusvariabele.

Een toekenning vervangt geen element

De lusvariabele is een gewone variabele. Als je er een ander getal aan toekent, vervang je het getal in de lijst niet:

numbers = [1, 2, 3]
for n in numbers:
    n = n * 10
    print(n)
print(numbers)

De lusinhoud toont 10, 20 en 30. Bij elke nieuwe iteratie wordt het volgende oorspronkelijke lijstelement aan n toegekend. De laatste uitvoerregel is [1, 2, 3]: de lijst zelf is niet veranderd. Na de lus behoudt n de waarde 30, de laatste waarde die er in de lusinhoud aan is toegekend.

Een lege sequentie geeft de lusinhoud geen werk. Bij for ch in "": zijn er nul doorgangen en kent de lus geen waarde toe aan ch. Ga er niet van uit dat een lus haar variabele aanmaakt als er mogelijk geen elementen zijn.

Lidmaatschap binnen een lus

In de kop van een for-lus introduceert in de sequentie die wordt doorlopen. In een voorwaarde toetst het lidmaatschap en levert het True of False op. Deze toepassingen kunnen samenwerken:

vowels = 0
for ch in "education":
    if ch in "aeiou":
        vowels += 1
print(vowels)

Elk teken wordt doorlopen, maar de teller verandert alleen bij e, u, a, i en o. De uitvoer is 5. De if springt in binnen de lus en de bijwerking van de teller springt in binnen de if.

Deze lus laat ook zien waarom een lusvariabele en een teller verschillende taken hebben. ch bevat het huidige teken; vowels houdt bij hoeveel tekens tot dan toe aan de voorwaarde hebben voldaan. De teller begint vóór de lus, zodat die het resultaat tussen doorgangen bewaart.

Een los geheel getal kan geen elementen leveren: for i in 5: veroorzaakt TypeError. Om een actie vijf keer te herhalen, schrijf je for _ in range(5):. Het bereik levert de stappen, ook als de lusinhoud hun waarden niet gebruikt.

Een getallenbereik beschrijft gehele getallen met gelijke tussenstappen. Het is handig om werk een bepaald aantal keer te herhalen, op of af te tellen en regelmatige stappen te kiezen. De eindgrens is altijd uitgesloten.

Drie vormen

Bij één argument is dat argument de eindgrens. Bij twee zijn het de startwaarde en eindgrens. Bij drie is het laatste argument de stapgrootte die na elke waarde wordt opgeteld. range(0, 10, 3) doorloopt 0, 3, 6 en 9; de volgende stap zou 12 bereiken, dus wordt die niet geleverd.

De eindgrens blijft uitgesloten, ook als een stap er precies op kan uitkomen. range(0, 10, 5) levert alleen 0 en 5. Bij de standaard positieve stapgrootte van 1 en een eindgrens boven de startwaarde is het aantal geleverde waarden de eindgrens min de startwaarde.

Tel terug met een negatieve stapgrootte

range(5, 0, -1) levert 5, 4, 3, 2 en 1. Om 0 mee te nemen, zet je de eindgrens eronder: range(5, -1, -1) levert zes waarden, eindigend bij 0.

De richting moet bij de grenzen passen. range(5, 0) is leeg omdat de standaardstapgrootte positief is. range(1, 5, -1) is ook leeg omdat het bereik onder de eindgrens begint maar naar beneden stapt. Lege getallenbereiken zijn geldig en leiden tot nul iteraties; een stapgrootte van nul veroorzaakt daarentegen een ValueError.

Plaats de laatste benodigde waarde binnen de grens

Om de even gehele getallen van 2 tot en met 20 op te tellen:

total = 0
for n in range(2, 21, 2):
    total += n
print(total)

De eindgrens 21 zorgt ervoor dat 20 wordt doorlopen. De tien waarden tellen op tot 110, dus toont het programma 110. Met eindgrens 20 zou 20 worden weggelaten en zou het resultaat 90 zijn.

Laat voor een tafel van vermenigvuldiging het bereik de factoren leveren:

for i in range(1, 11):
    print(7, "x", i, "=", 7 * i)

De eerste uitvoerregel is 7 x 1 = 7 en de tiende is 7 x 10 = 70. Als het getal zelf niet wordt gebruikt, kan for _ in range(3): een bericht drie keer herhalen.

Inspecteer een getallenbereik en controleer de argumenten

list(range(2, 6)) levert [2, 3, 4, 5] op, wat handig is bij het controleren van de grenzen. len(range(0, 10, 3)) is 4. Een getallenbereik bewaart de grenzen en stapgrootte die het bepalen, in plaats van een lijst met elk geheel getal te maken.

De argumenten zijn gehele getallen, waaronder nul en negatieve gehele getallen: range(-3, 3) doorloopt -3 tot en met 2. Een zwevendekommagetal zoals 3.0 wordt met een TypeError afgewezen, ook al heeft het geen fractioneel deel. Een als tekst ingevoerd aantal kun je eerst converteren met n = int(input("How many? ")) en daarna gebruiken in range(n).

Kies een lus door te vragen wat de herhaling bepaalt. Als er een sequentie van te doorlopen elementen of een aantal herhalingen is, drukt for het werk meestal direct uit. Als de volgende herhaling afhangt van een veranderende voorwaarde of toekomstige invoer, zet while die beslissing in de kop.

Bepaalde elementen of een veranderende voorwaarde

Een aantal hoeft niet als letterlijke waarde in het programma te staan. Nadat je n uit invoer hebt gelezen, geeft range(n) nog steeds een bepaalde reeks stappen. Een lus met een onbepaald aantal herhalingen wacht op een voorwaarde waarvan het stoppunt niet als aantal herhalingen is vastgelegd.

Een groot aantal herhalingen gokken past slecht bij “totdat het klaar is”. Een lus over range(1000) kan haar pogingen opgebruiken voordat de gebruiker klaar is, en een versie zonder stopcontrole gaat door nadat het werk is voltooid.

Herschrijf een tellus

Deze twee lussen tonen 1 tot en met 5, elk getal op een eigen regel:

for i in range(1, 6):
    print(i)

i = 1
while i < 6:
    print(i)
    i += 1

In de while-versie wordt de startwaarde van het bereik de initialisatie, wordt de uitgesloten eindgrens de <-vergelijking en wordt de stapgrootte de bijwerking. De lusinhoud gebruikt i vóór die bijwerking. Als je de bijwerking vóór print(i) zet, verschuiven de getoonde waarden.

Bij terugtellen veranderen zowel de vergelijking als de bijwerking:

i = 10
while i > 0:
    print(i)
    i -= 2

Dit toont 10, 8, 6, 4 en 2, net als for i in range(10, 0, -2):. Het aflopende bereik sluit de eindgrens uit, dus is de bijpassende while-voorwaarde i > 0.

De twee vormen komen overeen voor de taak om de telling te tonen; hun eindwaarden voor de lusvariabele verschillen. De while-versie voert de laatste bijwerking naar 0 uit voordat de lus stopt. De for-versie eindigt na toekenning van de laatst geleverde waarde, 2.

Een getallenbereik behoudt de opgegeven grenzen

n = 3
for i in range(n):
    n = 10
    print(i)

Dit toont nog steeds 0, 1 en 2. Het bereik is gemaakt met 3; als je 10 aan n toekent, wordt het niet opnieuw gemaakt. Een break kan de lus voortijdig beëindigen, maar een verandering van die afzonderlijke variabele verandert de getallen die het bereik levert niet.

Een while-kop evalueert daarentegen bij elke terugkeer de expressie opnieuw. Als die expressie n gebruikt, kan een verandering van n in de lusinhoud veranderen wanneer de lus eindigt. Als beide vormen een tellende taak duidelijk uitdrukken, regelt de for-versie het doorlopen zonder een handmatige bijwerking die je kunt vergeten.

break beëindigt onmiddellijk de binnenste lus waarin de instructie staat. Python slaat de rest van die lusinhoud en alle resterende iteraties over en gaat daarna verder na de lus. Een voorwaarde binnen de lusinhoud bepaalt wanneer deze voortijdige beëindiging moet plaatsvinden.

Stop wanneer het eerste resultaat is gevonden

Zoek het eerste veelvoud van 7 boven 50:

for n in range(51, 100):
    if n % 7 == 0:
        print(n)
        break

De lus controleert 51, 52, 53, 54, 55 en 56. Bij 56 is de rest nul, dus toont Python 56 en verlaat het de lus. Dit kost zes iteraties, ook al kan het bereik 49 getallen leveren. Zonder break zou de lus ook latere veelvouden van 7 tonen.

break springt in binnen de if, dus wordt de instructie alleen bij een overeenkomst uitgevoerd. Als die in plaats daarvan even ver zou inspringen als if, zou die bij de allereerste iteratie worden uitgevoerd, ongeacht de toets. Een break binnen een if beëindigt de lus waarin die if staat; niet alleen het voorwaardelijke blok.

Lees eenmaal en beslis daarna of je verwerkt

Een while True-lus plaatst de beslissing om te stoppen na het lezen van invoer:

while True:
    line = input("> ")
    if line == "done":
        break
    print(line)
print("Done!")

Bij de invoer “hello”, “there” en “done” zijn de antwoordregels:

hello
there
Done!

De stopwaarde wordt vóór de verwerkingsregel getoetst. Wanneer die verschijnt, springt break over print(line) heen. De laatste, niet-ingesprongen print wordt na de lus nog uitgevoerd. Er is maar één invoerinstructie, omdat elke doorgang begint met het lezen van een nieuwe regel.

Een numeriek totaal gebruikt dezelfde volgorde: initialiseer total = 0 vóór de lus; lees en converteer een getal; stop met break als het 0 is; tel het anders op. Voor 4, 7 en 0 is het totaal 11. Als je vóór de stoptoets verwerkt, kan de stopwaarde in de berekening terechtkomen. Dat is van belang als de stopwaarde een aantal, product of gemiddelde kan veranderen.

Valideer bij de invoer

while True:
    age = int(input("Age: "))
    if 0 <= age <= 120:
        break
    print("Please enter an age from 0 to 120.")
print("Accepted:", age)

De aaneengeschakelde vergelijking accepteert een leeftijd van 0 tot en met 120. Ze betekent 0 <= age and age <= 120. Bij een geaccepteerd getal wordt de lus vóór de waarschuwing verlaten; een getal buiten dat bereik leidt tot de waarschuwing en daarna tot nieuwe invoer. In deze vorm beschrijft de if een geldig antwoord, terwijl een validatielus waarvan de kop de herhaling bepaalt een ongeldig antwoord beschrijft.

Lees de sprong letterlijk

Een instructie na break in hetzelfde blok kan niet worden uitgevoerd. Plaats een melding of opgeslagen resultaat vóór de break als die bij het succesvolle geval hoort. Zet code na de lus als die zowel na een voortijdige beëindiging als na normale voltooiing moet worden uitgevoerd.

break moet binnen een lus staan; anders veroorzaakt Python een SyntaxError. Meerdere afzonderlijke uitgangen kunnen een lus moeilijker te volgen maken. Als één voorwaarde de stopregel van de taak vanzelfsprekend beschrijft, kan het pad gemakkelijker te volgen zijn als je die voorwaarde in de kop houdt.

continue slaat de rest van de huidige iteratie over. De lus blijft actief: een for-lus neemt het volgende element en een while-lus keert terug naar haar voorwaarde. Dit is handig als een element geen van de verwerkingen moet krijgen die op een controle volgen.

Sla geselecteerde waarden over

total = 0
for n in range(1, 11):
    if n % 3 == 0:
        continue
    total += n
print(total)

Het bereik levert alle tien gehele getallen van 1 tot en met 10. Bij 3, 6 en 9 slaat continue de optelling over. De som van alle tien is 55; door die drie waarden weg te laten, gaat er 18 af, dus toont het programma 37.

Continue verwijdert geen iteratie uit het bereik. De lusinhoud begint nog steeds met elke waarde, ook met de overgeslagen waarden. De instructie verandert welke latere regels bij die doorgang worden uitgevoerd.

Een positief filter kan hetzelfde werk uitdrukken. In een lus over [5, -2, 8, -7, 3] toont if n < 0: continue gevolgd door print(n) de waarden 5, 8 en 3. Als je de print binnen if n >= 0: zet, krijg je dezelfde uitvoer. Continue is vaak handig als er meerdere verwerkingsregels volgen, omdat afgewezen elementen dat deel van de lusinhoud direct kunnen verlaten.

Sla een bijwerking in een while-lus niet over

i = 0
while i < 5:
    if i == 2:
        continue
    print(i)
    i += 1

Dit toont 0 en 1 en blijft dan steken bij 2. Bij 2 springt continue naar de voorwaarde zonder de bijwerking te bereiken. De voorwaarde blijft waar en dezelfde tak wordt opnieuw genomen.

Om het tonen van 2 over te slaan en toch verder te komen, werk je ook in die tak de waarde bij:

i = 0
while i < 5:
    if i == 2:
        i += 1
        continue
    print(i)
    i += 1

Nu is de uitvoer 0, 1, 3 en 4 op afzonderlijke regels. Het pad dat de uitvoer overslaat, gaat van 2 naar 3. Elke route door deze lusinhoud voert precies één bijwerking uit.

Break, continue en pass

Stel dat voor een lus over [1, 2, 3, 4] een if n == 2: een van deze instructies bevat en print(n) op de if volgt. Break toont alleen 1. Continue toont 1, 3 en 4. Pass toont alle vier waarden omdat die de print niet overslaat.

pass kan een lusinhoud vullen waar Python een instructie vereist terwijl de code wordt ontwikkeld. De instructie zorgt niet voor een bijwerking of uitgang: while True: pass blijft doorgaan. Break en continue moeten binnen een lus staan en beïnvloeden alleen de binnenste lus waarin ze staan.

Een else-blok kan bij een for- of while-lus horen. Het wordt eenmaal uitgevoerd wanneer de lus normaal eindigt: een for-lus heeft geen elementen meer of een while-voorwaarde wordt onwaar. Het wordt overgeslagen wanneer die lus door break eindigt. Lees het als het geval zonder break.

Meld dat een zoekactie geen overeenkomst heeft gevonden

for n in [4, 9, 15, 22]:
    if n % 5 == 0:
        print("First multiple of 5:", n)
        break
else:
    print("No multiple of 5")

De lus bereikt 15, toont First multiple of 5: 15 en stopt met break. De else wordt overgeslagen. Met [4, 9, 22] gebruikt de lus elk element zonder break en toont ze eenmaal No multiple of 5.

De uitlijning is beslissend. De else springt even ver in als for en hoort dus bij de lus. Een else die even ver inspringt als de binnenste if, zou voor elk element zonder overeenkomst worden uitgevoerd en een mislukte zoekactie melden voordat die is voltooid.

Ook bij een lege lijst wordt de else van de lus bereikt. Er zijn geen elementen, dus wordt de lusinhoud nul keer uitgevoerd en is er geen break. Op dezelfde manier voert een while-lus waarvan de voorwaarde bij de eerste controle onwaar is, direct haar else uit.

Zoek een deler

Een priemgetal is een geheel getal van minstens 2 waarvan de enige positieve delers 1 en het getal zelf zijn. Zoek een deler tussen die grenswaarden:

n = 29
if n < 2:
    print("Not prime")
else:
    for d in range(2, n):
        if n % d == 0:
            print(n, "is divisible by", d)
            break
    else:
        print(n, "is prime")

Voor 29 is elke rest ongelijk aan nul en toont de else van de lus 29 is prime. Voor 21 is de eerste deler 3 en slaat de break de else van de lus over. De buitenste controle handelt getallen onder 2 af. Zonder die controle zou een leeg bereik voor 1 de else bereiken en 1 ten onrechte een priemgetal noemen. Voor 2 is het bereik ook leeg, maar is de conclusie “priemgetal” juist.

Een beperkt aantal pogingen met while-else

attempts = 0
while attempts < 3:
    guess = input("Password: ")
    if guess == "open sesame":
        print("Welcome!")
        break
    attempts += 1
else:
    print("Too many attempts.")

Een juiste gok voert de break uit, ook bij de derde poging. Drie verkeerde gokken verhogen de teller tot 3; de voorwaarde wordt onwaar en de else toont de melding dat het niet is gelukt. Een gewone instructie na de lus zou in beide gevallen worden uitgevoerd en zou dus geen onderscheid maken.

Leg het resultaat vast met een vlagvariabele

Een vlagvariabele is een booleaanse variabele die vastlegt of iets is gebeurd. Begin met found = False, verander de waarde in True wanneer een overeenkomst verschijnt en voer break uit. Na de lus handelt if not found: het geval af waarin niets is gevonden. Dat geeft hetzelfde zoekresultaat als de else van de lus, met een expliciete registratie van de gebeurtenis. Kies een vorm waarvan je de inspringing en de weg naar de uitgang duidelijk kunt uitleggen.

Een accumulator bewaart een resultaat tussen iteraties. Een teller is een bijzondere accumulator die telkens met 1 toeneemt als een gebeurtenis plaatsvindt. Stel de startwaarde vóór de lus in, werk die binnen de lus bij en gebruik het voltooide resultaat daarna.

Tel gebeurtenissen of tel waarden op

count = 0
for n in [4, 15, 22, 8, 11]:
    if n > 10:
        count += 1
print(count)

De toets slaagt voor 15, 22 en 11, dus is de uitvoer 3. De bijwerking telt 1 op voor een element dat voldoet; als je n zou optellen, zou je de waarden van die elementen optellen.

Om elk element op te tellen, initialiseer je total = 0, verwijder je de if-toets, voeg je total += n direct aan de lusinhoud toe en toon je daarna total. De vijf waarden tellen op tot 60. Hun gemiddelde is 60 / 5, wat 12.0 geeft; deling met / geeft voor deze gehele operanden een zwevendekommagetal terug.

Werk voor een gefilterd gemiddelde zowel het totaal als de teller bij onder dezelfde voorwaarde:

total = 0
count = 0
for n in [4, 15, 22, 8, 11]:
    if n > 10:
        total += n
        count += 1
if count > 0:
    print(total / count)
else:
    print("No matching values")

Hier is het totaal van de geselecteerde waarden 48 en het aantal 3, dus is de uitvoer 16.0. Als je door de lengte van de hele lijst zou delen, zou je de verkeerde groep gebruiken. De controle van de teller handelt ook een lege lijst of een lijst zonder overeenkomsten af.

Kies een startwaarde die bij de bewerking past

Een product van de gehele getallen 1 tot en met 5 begint bij 1 en eindigt bij 120. Als je bij 0 begint, blijft elk product 0.

Bij tekst opbouwen is ook de volgorde van belang:

rev = ""
for ch in "stressed":
    rev = ch + rev
print(rev)

Elk nieuw teken komt vóór de opgeslagen tekst, wat desserts oplevert. Als je de bijwerking verandert in rev = rev + ch, voeg je tekens achteraan toe en bouw je stressed opnieuw op.

Bewaar het resultaat tussen iteraties

Als je total = 0 binnen een somlus plaatst, wis je bij elke doorgang het eerdere werk. Bij [4, 15, 22, 8, 11] blijft aan het einde alleen 11 over als je vóór elke optelling opnieuw begint. Initialiseer buiten de lus, zodat de volgende optelling het vorige subtotaal gebruikt.

Een print binnen de lusinhoud toont het lopende totaal na elke bijwerking: in dit voorbeeld 4, 19, 41, 49 en 60. Een print na de lus toont alleen 60. Kies de plaats die past bij de gevraagde uitvoer.

Voor een eenvoudige opgeslagen lijst geeft sum(values) het totaal en len(values) het aantal. Met een expliciete lus kun je waarden filteren, meerdere resultaten tegelijk bijhouden of waarden verwerken zodra ze via invoer binnenkomen.

Om een maximum te vinden, bewaar je de grootste waarde die je tot dan toe hebt gezien. Vergelijk elk nieuw element met die opgeslagen waarde en vervang die alleen als het nieuwe element groter is. Het minimumpatroon werkt op dezelfde manier met de vergelijking omgekeerd.

Begin zonder een gegevenswaarde te verzinnen

None is de waarde van Python voor “nog niets”. Daarmee kan het eerste element op een duidelijke manier de huidige beste waarde worden:

largest = None
for n in [12, -3, 25, 7]:
    if largest is None or n > largest:
        largest = n
print(largest)

De opgeslagen waarden na elk element zijn 12, 12, 25 en 25. Het programma toont 25. Bij het eerste element is largest is None waar. De or van Python stopt daar, dus probeert Python de ongeldige vergelijking van een getal met None niet. Bij latere doorgangen is de opgeslagen waarde een getal en wordt de tweede vergelijking gebruikt.

Voor een minimum begin je met smallest = None en gebruik je smallest is None or n < smallest. Dezelfde lijst levert -3 op.

Als je een maximum bij 0 laat beginnen, kan een waarde worden gemeld die nooit voorkwam. Voor -5, -2 en -9 is geen waarde groter dan 0, dus zou die versie ten onrechte 0 bewaren. Het maximum is -2. Een minimum bij 0 laten beginnen heeft het overeenkomstige probleem als elk element positief is.

Als bekend is dat de gegevens een element bevatten, werkt het ook om die eerste waarde als beste startwaarde te gebruiken. Ingebouwde functies verwerken eenvoudige opgeslagen lijsten: max([12, -3, 25, 7]) geeft 25 en min([12, -3, 25, 7]) geeft -3. Een zelfgeschreven lus kan bijbehorende informatie bewaren, zoals waar de waarde voorkwam.

Sla de positie op wanneer de beste waarde verandert

largest = None
best_day = None
day = 0
for temperature in [18, 23, 21, 26, 24]:
    day += 1
    if largest is None or temperature > largest:
        largest = temperature
        best_day = day
print(largest, best_day)

De dagteller gaat voor elk element vooruit. De beste dag verandert alleen wanneer een nieuw maximum verschijnt. De uiteindelijke uitvoer is 26 4, wat een temperatuur van 26 op dag 4 betekent. Als je de dag na de lus zou opslaan, zou je alleen de laatst onderzochte dag bewaren.

Bepaal wat er bij een gelijke beste waarde gebeurt

Voor [5, 8, 8, 3] bewaart de toets n > largest de eerste 8 en de bijbehorende positie, 2 als je vanaf 1 telt. Als je > vervangt door >=, wordt ook bij een gelijke waarde bijgewerkt en blijft de laatste 8 op positie 3 bewaard. Het grootste getal blijft gelijk; de opgeslagen positie verschilt.

Bij een lege lijst blijft een met None geïnitialiseerde beste waarde ongewijzigd. Controleer op die toestand voordat je een getal meldt of ermee rekent. Ze betekent dat geen enkel element een beste waarde heeft geleverd.

De vergelijking kan een eigenschap van een element gebruiken. Om het langste woord van “pear”, “banana” en “fig” te bewaren, vergelijk je len(word) met de lengte van het opgeslagen woord. “Banana” heeft zes tekens en wint dus. Sla het woord zelf op wanneer het de beste waarde wordt, zodat het resultaat het element aangeeft en niet alleen de lengte ervan.

Lineair zoeken controleert elementen op volgorde totdat een overeenkomst is gevonden of er geen elementen meer zijn. Een overeenkomst kan een exacte waarde zijn, het eerste element dat aan een voorwaarde voldoet of een aanwijzing voor een vraag of minstens één of alle elementen voldoen.

Onthoud een gevonden overeenkomst

names = ["Ana", "Ben", "Chen"]
found = False
for name in names:
    if name == "Ben":
        found = True
        break
if found:
    print("Ben is on the list")
else:
    print("Ben is not on the list")

De vlagvariabele begint als onwaar omdat nog niets is gevonden. De eerste controle, Ana, laat haar ongewijzigd. De tweede controle vindt Ben, zet de vlagvariabele op waar en verlaat de lus. De uitvoer is Ben is on the list.

De vlagvariabele legt een gebeurtenis vast voor de hele zoekactie. Zet haar niet opnieuw op onwaar bij elk element zonder overeenkomst. Als een lus doorgaat nadat Ben is gevonden en found = False instelt wanneer Chen wordt bereikt, gaat het gevonden resultaat verloren. Ook hoort “niet gevonden” pas na alle mislukte controles te worden gemeld, niet binnen een else per element die al bij Ana meldt dat niets is gevonden voordat Ben is onderzocht.

Eerste of laatste overeenkomst

Voor [7, 4, 9, 10] is het eerste even getal 4 en het laatste 10. Deze lus bewaart het eerste:

match = None
for n in [7, 4, 9, 10]:
    if n % 2 == 0:
        match = n
        break
print(match)

De uitvoer is 4. Verwijder de break en elke nieuwe overeenkomst overschrijft de vorige, zodat 10 overblijft. Als niets overeenkomt, blijft de opgeslagen waarde None. Bepaal of de taak om het bestaan, het eerste element, het laatste element of een positie vraagt voordat je beslist wat je opslaat.

Om een positie te melden, houd je een teller bij die voor elk onderzocht element vooruitgaat en sla je die bij een overeenkomst op. Vermeld hoe de posities zijn genummerd: als je vanaf 1 telt, staat Chen op positie 3 in de namenlijst; de gebruikelijke positienummering van Python begint bij 0.

Minstens één vraagt één overeenkomst; alle vraagt één tegenvoorbeeld

Een zoekactie naar minstens één overeenkomst begint met onwaar en wordt waar bij het eerste element dat voldoet. De zoekactie kan daar stoppen omdat één overeenkomst de vraag beantwoordt.

Een zoekactie of alle elementen voldoen begint met waar en wordt onwaar bij het eerste element dat niet voldoet:

all_positive = True
for n in [3, 8, -1, 5]:
    if n <= 0:
        all_positive = False
        break
print(all_positive)

De derde waarde, -1, weerlegt “alle waarden zijn positief”, dus is de uitvoer False. Het is niet nodig om 5 te onderzoeken. Ook nul zou niet voldoen omdat positief groter dan nul betekent. Als er geen elementen zijn, blijft de vlagvariabele waar: er is geen tegenvoorbeeld verschenen.

Exact lidmaatschap en eigen voorwaarden

Voor alleen gelijkheid geeft "Ben" in names direct True of False. Een lus maakt de veranderende toestand van de zoekactie zichtbaar en laat de toets een eigen voorwaarde uitdrukken, zoals “het eerste woord langer dan vijf tekens”.

Stringvergelijkingen zijn exact. "ben" verschilt van "Ben" en "Ben " bevat een spatie aan het einde. Een zoekactie naar een van die strings mag de andere niet als gelijk beschouwen.

Een geneste lus is een lus binnen de lusinhoud van een andere lus. Voor elke buitenste iteratie begint de binnenste lus en doorloopt ze haar werk. De buitenste variabele blijft gelijk terwijl de binnenste variabele verandert.

Bouw één rij tegelijk

for row in range(1, 4):
    for col in range(1, 5):
        print(row * col, end=" ")
    print()

De uitvoer heeft deze drie rijen, elk met een spatie na het laatste getal:

1 2 3 4 
2 4 6 8 
3 6 9 12 

Eerst is row gelijk aan 1, terwijl col de waarden 1 tot en met 4 aanneemt. Daarna wordt row gelijk aan 2 en begint de binnenste lus opnieuw bij kolom 1. Ten slotte krijgt rij 3 dezelfde vier kolommen. De binnenste lusinhoud wordt twaalf keer uitgevoerd.

end=" " vervangt het gebruikelijke regeleinde van print door een spatie. De lege print() beëindigt de rij. Die staat binnen de buitenste lusinhoud maar buiten de binnenste lusinhoud en wordt dus drie keer uitgevoerd. Als je die één niveau verder laat inspringen, komt elk getal op een eigen regel. Als je de inspringing verwijdert, wordt slechts eenmaal een regel beëindigd, na beide lussen.

Geef de lusvariabelen verschillende namen, zoals row en col. Als je de buitenste naam opnieuw gebruikt binnen de binnenste lus, overschrijf je de waarde die nodig is om de huidige rij aan te geven.

Tel het werk

Als elke buitenste doorgang hetzelfde aantal binnenste doorgangen krijgt, vermenigvuldig je de aantallen. Drie rijen en vier kolommen geven twaalf uitvoeringen van de binnenste lusinhoud. Twee lussen met elk 100 doorgangen geven 10.000 binnenste uitvoeringen; drie niveaus geven 1.000.000. Een kleine verhoging van elke grens kan daardoor veel meer herhaald werk opleveren.

Als de binnenste grens met de buitenste variabele verandert, tel je de afzonderlijke aantallen op:

for row in range(1, 5):
    for _ in range(row):
        print("*", end="")
    print()

Dit toont:

*
**
***
****

De rijlengtes zijn 1, 2, 3 en 4, voor in totaal tien sterretjes. Voor een patroon met n van zulke rijen is het totaal $n(n+1)\mathrm{/}2$. Als je vier met vier vermenigvuldigt, ga je er ten onrechte van uit dat elke rij vier sterretjes heeft.

Stel een resultaat voor elke groep opnieuw in

Om elke rij van het vermenigvuldigingsrooster op te tellen, zet je row_total = 0 binnen de buitenste lus, direct vóór de binnenste lus. Tel row * col op binnen de binnenste lusinhoud en toon row_total na de binnenste lus. De uitvoerwaarden zijn 10, 20 en 30.

Als je slechts eenmaal vóór beide lussen initialiseert, blijven ook de totalen van eerdere rijen bewaard. Als je dan na elke rij de waarde toont, krijg je 10, 30 en 60. Beide plaatsen bewaren een resultaat, maar de ene bewaart een rijresultaat en de andere een lopend totaal voor het hele rooster.

Doorloop combinaties

Twee lussen over range(1, 7) doorlopen alle 36 geordende uitkomsten voor twee dobbelstenen. De eerste lus levert de eerste dobbelsteen en de tweede de tweede dobbelsteen. Een voorwaarde binnen de binnenste lusinhoud kan paren tellen waarvan de som 7 is. Zes voldoen: (1, 6), (2, 5), (3, 4), (4, 3), (5, 2) en (6, 1). Een omgekeerd paar beschrijft een andere geordende uitkomst.

Break en continue werken op de binnenste lus waarin ze staan. Zoek in geneste code die lus voordat je voorspelt wat er daarna gebeurt. Een break in de binnenste lusinhoud stopt op zichzelf de buitenste lus niet.

Volg een break in de binnenste lus

for a in range(1, 4):
    for b in range(1, 4):
        if b > a:
            break
        print(a, b)

Bij a = 1 wordt het paar 1 1 getoond. Wanneer b gelijk wordt aan 2, beëindigt de break die binnenste lus. De buitenste lus gaat verder met a = 2 en begint een nieuwe binnenste lus met b gelijk aan 1. Die toont 2 1 en 2 2 en stopt daarna met break bij b gelijk aan 3. Voor a gelijk aan 3 voldoet elke b. De zes uitvoerregels zijn:

1 1
2 1
2 2
3 1
3 2
3 3

Stop beide lussen met een vastgelegd resultaat

Een zoekactie naar een combinatie kan een vlagvariabele en één break op elk niveau gebruiken:

found = False
for a in range(1, 6):
    for b in range(1, 6):
        if a * b == 12:
            found = True
            break
    if found:
        break
if found:
    print(a, b)
else:
    print("No matching pair")

De rijen met a gelijk aan 1 en 2 hebben geen overeenkomst. In rij 3 bereikt b de waarde 4 en is het product 12. De binnenste break beëindigt de b-lus; de vlagvariabele zorgt er vervolgens voor dat de buitenste break wordt uitgevoerd. De uiteindelijke uitvoer is 3 4.

De vlagvariabele wordt vóór beide lussen geïnitialiseerd omdat ze een resultaat voor de hele zoekactie vastlegt. De buitenste if found: hoort na de binnenste lus maar binnen de buitenste lusinhoud. Door die inspringing wordt de toets eenmaal per voltooide of onderbroken rij uitgevoerd.

Bewaar waarden als de zoekactie doorgaat

Als je alleen de buitenste break verwijdert, gaat de zoekactie door naar latere rijen. In dit voorbeeld is een latere overeenkomst 4 3, maar de lus onderzoekt uiteindelijk rij 5 en eindigt met a = 5 en b = 5. Als je dan de lusvariabelen toont, krijg je 5 5, geen opgeslagen overeenkomst.

Als de taak het laatste overeenkomstige paar nodig heeft, sla je best_a = a en best_b = b op wanneer een overeenkomst optreedt. Die afzonderlijke variabelen bewaren een overeenkomst terwijl de lusvariabelen blijven veranderen. Controleer de vlagvariabele voordat je ze toont als een overeenkomst mogelijk ontbreekt.

Sla een paar over en ga verder met de rij

Een continue binnen de binnenste lus gaat naar de volgende binnenste waarde. Bij twee lussen die 1 tot en met 4 doorlopen, slaat if a == b: continue vóór de verwerking vier gelijke paren over. Van de oorspronkelijke zestien blijven twaalf geordende paren over.

Een if kan ook paren selecteren zonder te springen. Twee dobbelstenen hebben drie geordende paren met som 10: (4, 6), (5, 5) en (6, 4). Een voorwaarde binnen de binnenste lusinhoud herkent ze.

Stapsgewijs volgen betekent dat je een programma met de hand uitvoert, één instructie tegelijk, en daarbij de waarden en uitvoer noteert. Een uitvoeringstabel geeft elke relevante variabele een kolom. Geef aan of een waarde vóór of na een bijwerking is genoteerd, zodat de rijen een duidelijke betekenis hebben.

Volg een while-lus

total = 0
i = 1
while i <= 4:
    total = total + i
    i = i + 1
print(total)

Begin met total = 0 en i = 1. Controleer de voorwaarde voordat je de lusinhoud binnengaat. Voer bij elke ware controle de optelling vóór de verhoging uit:

De volgende controle is 5 <= 4, wat onwaar is. Er is geen vijfde rij voor de lusinhoud. De lusinhoud wordt vier keer uitgevoerd, de voorwaarde wordt vijf keer gecontroleerd en de print na de lus toont eenmaal 10. De eindwaarden zijn i = 5 en total = 10.

Maak onderscheid tussen de onware controle en een iteratie: die controle beëindigt de lus zonder de lusinhoud uit te voeren. Als de beginvoorwaarde al onwaar is, zijn er helemaal geen rijen voor de lusinhoud en behouden de variabelen hun startwaarden.

De volgorde van instructies verandert het resultaat

Als de verhoging boven de optelling komt te staan, gebruikt elke doorgang de nieuwe i. De vier optellingen worden 2, 3, 4 en 5, wat 14 geeft. De voorwaarde toetst i nog steeds aan het begin, vóór die verhoging. Als je alleen de waarden bij de kop volgt, mis je welke waarde de optelling werkelijk gebruikt.

Als een lusinhoud een break of continue bevat, stop je met het volgen van de resterende regels zodra de sprong plaatsvindt. Bij continue keer je terug naar de kop of het volgende element; bij break ga je verder na de lus. Een uitvoeringsoverzicht moet die routes volgen en niet simpelweg alle instructies van de lusinhoud naar elke rij kopiëren.

Volg tekens en geneste lussen

Een for-lus kent aan het begin van haar doorgang het volgende element toe:

rev = ""
for ch in "abc":
    rev = ch + rev
print(rev)

De opgeslagen tekst wordt "a", dan "ba" en dan "cba". De uitvoer is cba. Noteer de werkelijke tekst, inclusief de volgorde, in plaats van alleen op te schrijven dat “een teken is toegevoegd”.

Gebruik bij geneste lussen één rij voor elke binnenste iteratie. Noteer beide lusvariabelen, zodat de buitenste waarde zich herhaalt over de rijen die erbij horen. In een lus met twee rijen en drie kolommen zijn de rijwaarden 1, 1, 1, 2, 2, 2 terwijl de kolomwaarden 1, 2, 3, 1, 2, 3 zijn.

Maak een uitvoeringsoverzicht met print

Een tijdelijke print("i =", i, "total =", total) na beide bijwerkingen in de somlus toont i en total aan het einde van elke doorgang. Als je die vóór de bijwerkingen plaatst, toon je een ander moment. Vergelijk de plaats van de print met de kolomlabels van je tabel. Verwijder diagnostische uitvoerinstructies nadat je de code hebt hersteld, zodat ze geen extra programma-uitvoer worden.

Noteer bij een vraag als “wat wordt getoond?” alleen instructies die werkelijk iets tonen. Een veranderende variabele is op zichzelf geen uitvoer; er kunnen meerdere bijwerkingen plaatsvinden vóór één laatste print.

Een één-ernaast-fout doorloopt één waarde te veel of te weinig, of verschuift de doorlopen waarden met één. De fout komt vaak door de uitgesloten eindgrens van een getallenbereik, een keuze tussen < en <= of de startwaarde van een teller.

Benoem de bedoelde grenswaarden

Om 1 tot en met 10 op te tellen, is range(1, 10) te kort. Het bereik levert alleen 1 tot en met 9, met een totaal van 45. range(1, 11) neemt 10 mee en geeft 55. Gebruik voor een oplopend bereik van gehele getallen met stapgrootte 1 de eindgrens n + 1 om de laatste waarde n mee te nemen.

Bij de standaardstapgrootte 1 levert range(a, b) b - a waarden als b groter is dan a. Een break kan de lus nog steeds beëindigen voordat ze allemaal zijn gebruikt. Schrijf bij andere stapgroottes een klein geval uit of gebruik len(range(...)) om het aantal te controleren.

Het aantal iteraties van een while-lus hangt af van de combinatie van startwaarde, vergelijking en bijwerking. Voor een niet-negatief geheel getal n, met i += 1 aan het einde van elke doorgang en zonder voortijdige beëindiging:

Bij n gelijk aan 0 slaan de eerste twee de lusinhoud over. De derde wordt eenmaal uitgevoerd met i gelijk aan 0. Dit kleine geval maakt de extra doorgang zichtbaar zonder dat je een lange lus hoeft te volgen.

Grenzen bij terugtellen

Als je begint bij 5 en toont vóór n -= 1, toont while n > 0: vijf waarden, eindigend bij 1. Met n >= 0 worden er zes getoond, eindigend bij 0. De overeenkomstige aflopende bereiken zijn range(5, 0, -1) en range(5, -1, -1).

Controleer ook de volgorde. Als je een teller bijwerkt voordat je die gebruikt, kan elke waarde verschuiven, ook als de lus het verwachte aantal doorgangen heeft. Een uitvoeringsoverzicht moet de werkelijke eerste en laatste waarde vastleggen die de berekening gebruikt.

Elementen en de tussenruimtes ertussen

Een hekpalenfout verwart het aantal elementen met het aantal tussenruimtes. Vijf hekdelen hebben zes palen nodig. Vijf getoonde getallen hebben maar vier scheidingstekens ertussen nodig.

for i in range(1, 6):
    print(i, end="-")

Dit toont 1-2-3-4-5-, inclusief een ongewenst laatste streepje. Elke print voegt na een element een streepje toe, ook na het laatste.

Een oplossing is om het eerste element afzonderlijk te tonen en daarna vóór elk volgend element een scheidingsteken te tonen:

print(1, end="")
for i in range(2, 6):
    print("-" + str(i), end="")
print()

De uitvoer is 1-2-3-4-5. De lus toont vier stukken met een streepje en een getal en de laatste lege print beëindigt de regel. Deze versie heeft een bekend eerste element; bij een algemeen geval met lege gegevens moet ook die print van het eerste element worden overgeslagen.

Controleer de oplossing met kleine gevallen

Schrijf de bedoelde eerste waarde, laatste waarde en het aantal op voordat je de code verandert. Kies de grenzen en vergelijking die daarbij passen en volg daarna een korte uitvoering. Controleer naast een gewoon geval ook nul en één element. Nul onthult werk dat moet worden overgeslagen; één onthult een onnodig scheidingsteken of een extra bijwerking. Verander de grens die de fout veroorzaakt, zodat de herhaling van de code bij de taak past.