2.4 Løkker og iterasjon

Hvorfor skrive det ti ganger?

Si at du vil at programmet skal skrive «Hei» ti ganger. Du kan selvsagt skrive print("Hei") ti ganger nedover. Men hva om du vil det tusen ganger? Eller en million? Da blir det fort umulig. Her ligger en av datamaskinens aller største superkrefter gjemt: den blir aldri lei av å gjenta. Den kan gjøre den samme tingen en million ganger uten å klage, og det er nettopp det vi utnytter med løkker.

En løkke er en kontrollstruktur som gjentar en kodeblokk. I stedet for å skrive den samme instruksjonen om og om igjen, skriver du den én gang og forteller maskinen hvor mange ganger -- eller hvor lenge -- den skal gjenta. Det å gjenta på denne måten kalles iterasjon, og det er en av de viktigste teknikkene i hele programmeringen.

I denne fortellingen skal vi temme gjentakelsens kraft. Vi skal møte de to typene løkker -- for-løkken som teller seg gjennom noe, og while-løkken som kjører så lenge en betingelse holder. Vi skal lære å hoppe ut av og over med break og continue, og vi skal se hvordan løkker inni løkker kan bygge tabeller og mønstre. Til slutt skal vi oppdage akkumulatoren, en enkel teknikk for å samle opp resultater.

Løkken som teller

Den første typen er for-løkken, og den er perfekt når du vet hvor mange ganger noe skal skje, eller når du vil gå gjennom en samling av ting ett element av gangen. Skriver du for i in range(5): med en print(i) under, skriver maskinen ut tallene 0, 1, 2, 3 og 4. Legg merke til at den starter på 0 og stopper før 5 -- range(5) gir altså fem tall, men ikke selve 5. Dette er en kilde til mange begynnerfeil, så det er verdt å huske godt.

Du kan også styre range mer presist. Med range(2, 11, 2) sier du «start på 2, stopp før 11, og hopp 2 om gangen», som gir 2, 4, 6, 8, 10. De tre tallene betyr start, stopp og steg. Og det fine er at for-løkken ikke bare kan telle tall -- den kan gå gjennom en hvilken som helst sekvens. Har du en liste med frukter, kan du skrive for frukt in frukter: og behandle hver frukt etter tur. Variabelen frukt peker da på ett element av gangen.

For-løkken er altså en trofast arbeider som går gjennom en bestemt rekke, ett steg om gangen, helt til den er ferdig. Når du på forhånd vet hvor mange runder du trenger, er for-løkken nesten alltid det rette valget.

Løkken som venter på en betingelse

Noen ganger vet du ikke på forhånd hvor mange ganger du må gjenta. Tenk på et gjettespill: du aner ikke hvor mange forsøk spilleren trenger. Til slike situasjoner har vi while-løkken, som gjentar koden så lenge en betingelse er sann.

Du kan lese while som «så lenge». Skriver du while teller <= 5:, vil løkken fortsette å kjøre helt til betingelsen blir usann. Men her lurer en farlig felle. Inni løkken må noe skje som etter hvert gjør betingelsen usann -- ellers kjører den i det uendelige. I eksempelet med telleren må vi øke den for hver runde med teller += 1. Glemmer du den linjen, sitter programmet fast i en evig løkke og fryser. Så hver gang du skriver en while-løkke, bør du spørre deg: hva er det som til slutt får denne til å stoppe?

While-løkken skinner i gjettespill. Vi setter et hemmelig tall, og lar løkken kjøre while gjetting != hemmelig:. For hvert forsøk leser vi spillerens gjetning, gir hint om den er for høy eller for lav, og løkken fortsetter helt til gjetningen stemmer. I det øyeblikket gjetningen er lik det hemmelige tallet, blir betingelsen usann, løkken slutter, og vi roper «Riktig!». For-løkken teller; while-løkken venter.

Å hoppe ut og hoppe over

Noen ganger vil du gripe inn i en løkke mens den kjører. Til det har Python to nyttige kommandoer: break og continue.

break avbryter løkken umiddelbart og helt. Når maskinen treffer en break, slipper den alt og hopper rett ut av løkken. Tenk deg for tall in range(1, 100): med en sjekk inni: if tall == 5: break. Da skriver løkken ut 1, 2, 3, 4 -- og i det øyeblikket tallet blir 5, hopper den ut og avslutter, selv om range egentlig skulle gått helt til 99. break er som en nødbrems.

continue er mildere. Den hopper bare over resten av den nåværende runden og går videre til neste. Resten av løkken kjører som normalt. Med for tall in range(1, 6): og if tall == 3: continue, skrives 1, 2, 4 og 5 ut -- tallet 3 hoppes over, men løkken fortsetter. continue er som å si «denne runden hopper vi over, men vi fortsetter».

En annen viktig teknikk inni løkker er akkumulatormønsteret. Det handler om å samle opp en verdi gjennom løkken. Du starter med en variabel, ofte total = 0, og legger til litt for hver runde. Vil du summere tallene fra 1 til 10, skriver du for tall in range(1, 11): total += tall, og til slutt inneholder total summen 55. Samme mønster kan brukes til å regne ut fakultet, der du i stedet starter med 1 og ganger inn hvert tall: 5! blir 1·2·3·4·5 = 120. Akkumulatoren er en variabel som vokser mens løkken jobber.

Løkker inni løkker

Den siste og mektigste teknikken er nøstede løkker -- en løkke plassert inni en annen. Akkurat som vi nøstet if-setninger, kan vi nøste løkker, og det åpner for å lage tabeller, rutenett og mønstre.

Tenk deg en ytre løkke som styrer rader, og en indre løkke som styrer kolonner. For hver runde i den ytre løkken kjører hele den indre løkken fra start til slutt. Skal du for eksempel lage en liten gangetabell, lar du den ytre løkken gå over tallene 1 til 3, og inni den en løkke som også går 1 til 3, og skriver ut produktet i*j. Resultatet blir et helt rutenett av regnestykker. Et lite triks her er end=" " i print, som gjør at utskriftene havner på samme linje med mellomrom imellom, i stedet for hver på sin linje. En tom print() til slutt på den ytre løkken gir et linjeskift før neste rad.

Med samme prinsipp kan vi tegne mønstre. Vil du ha en trekant der første rad har «1», andre rad «1 2», tredje «1 2 3» og så videre, lar du den ytre løkken telle radnummeret, og den indre løkken skrive tallene fra 1 opp til akkurat dette radnummeret. Den indre løkken blir altså litt lengre for hver rad. Slik bygges et mønster fra to enkle løkker som danser sammen -- og du har fått et glimt av hvordan ganske komplekse ting kan vokse fram fra noen få, klare regler.

Oppsummering

Vi har temmet gjentakelsens kraft. For-løkken teller seg gjennom en sekvens -- gjerne med range() -- og passer når du vet hvor mange runder du trenger, mens while-løkken kjører så lenge en betingelse er sann og passer når antallet er ukjent. Husk at while-løkker må kunne stoppe, ellers kjører de i det uendelige.

Vi lærte å gripe inn med break, som avbryter løkken helt, og continue, som bare hopper over én runde. Med akkumulatormønsteret samlet vi opp resultater i en variabel som vokser, slik vi gjorde da vi summerte tall og regnet fakultet. Til slutt så vi at nøstede løkker -- løkker inni løkker -- lar oss bygge tabeller og mønstre, der den ytre styrer rader og den indre kolonner. Med løkker kan programmene dine nå gjøre tusen ting med noen få linjer kode.