1.3 Løkker: for, while og range

En blokk med kode som kjøres flere ganger. Hver gjennomkjøring kalles en
runde eller en iterasjon.

Python har to løkketyper, og de dekker hver sin situasjon:

- for — når du vet hva du skal gå gjennom: alle tallene fra 1 til 25, alle
tegnene i et navn, alle elementene i en samling.
- while — når du ikke vet hvor mange runder det blir, bare når du skal
stoppe: «så lenge saldoen er positiv».

I praksis dekker for de fleste oppgavene på eksamen. while kommer til sin rett når antallet runder avhenger av noe som skjer underveis.

Kjører blokken én gang for hvert element i sekvensen. Variabelen mellom for og
in — løkkevariabelen — får en ny verdi for hver runde:

for tegn in "sol":
    print(tegn)

Utskrift:

s o l

Formkravene er de samme som for if: kolon på slutten av linja, og innrykk på linjene som hører til.

Løkkevariabelen er et vanlig variabelnavn du velger selv. Kall den noe som sier hva den inneholder — tegn når det er tegn, tall når det er tall.

Lager tallrekka fra 0 og oppover, men ikke med stoppverdien:

for i in range(4):
    print(i)

Utskrift:

0
1
2
3

Fire runder, med verdiene 0, 1, 2 og 3. Tallet i parentesen er antallet runder, ikke den siste verdien.

At stoppverdien ikke er med, er den mest omtalte detaljen i hele Python, og årsaken til feilkode #5 — av-med-én. Til gjengjeld gir den en enkel regel:
range(N) gir alltid nøyaktig N runder.

Tallrekka fra start til og med stopp minus én:

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

Utskrift:

2
3
4
5

Startverdien er med, stoppverdien er ikke. Antall runder er stopp - start, altså fire her.

Vil du telle fra 1 til 25 slik et menneske ville sagt det, skriver du derfor
range(1, 26).

Samme som over, men hopper steg om gangen:

for i in range(0, 10, 3):
    print(i)

Utskrift:

0
3
6
9

Neste verdi ville vært 12, som er forbi stoppverdien, så løkka stopper.

Steget kan være negativt, og da teller løkka nedover. Da må startverdien være den største: range(5, 0, -1) gir 5, 4, 3, 2, 1.

Regelen du skal kunne uten å telle:

Kjører blokken om og om igjen så lenge betingelsen er sann. Betingelsen sjekkes
før hver runde:

n = 8 while n > 1:
    print(n)
    n = n // 2 print("ferdig")

Utskrift:

8
4
2 ferdig

Legg merke til at 1 aldri skrives ut: når n er blitt 1, er betingelsen
1 > 1 usann, og løkka avsluttes før neste runde.

Er betingelsen usann allerede første gang, kjøres blokken null ganger. En
while-løkke er altså ikke garantert å kjøre i det hele tatt.

En while-løkke stopper bare hvis noe inne i den gjør betingelsen usann til slutt. Linja som gjør det, er like viktig som selve betingelsen.

I eksempelet over er det n = n // 2. Uten den ville n vært 8 for alltid, og
8 > 1 ville vært sant for alltid.

Vanen som redder deg: når du har skrevet while, finn med én gang linja som
til slutt gjør betingelsen usann, og skriv den før du skriver resten av kroppen.

En løkke inne i en annen løkke. Den indre kjøres helt ferdig for hver eneste runde i den ytre:

for i in range(2):
    for j in range(3):
        print(i, j)

Utskrift:

0 0
0 1
0 2
1 0
1 1
1 2

Seks linjer: to ytre runder ganger tre indre.

Regelen for sporing: den indre løkka begynner forfra hver gang. Legg merke
til at j starter på 0 igjen når i blir 1.

Med faste grenser er antallet linjer alltid produktet av de to.

Den indre range kan bruke den ytre løkkevariabelen. Da blir antall indre runder forskjellig for hver ytre runde:

for i in range(4):
    for j in range(i):
        print(i, j)

Utskrift:

1 0
2 0
2 1
3 0
3 1
3 2

Seks linjer, ikke seksten. Når i er 0, gir range(0) ingen runder i det hele tatt, og den indre løkka kjøres aldri.

Antallet blir 0 + 1 + 2 + 3, altså 6. Dette mønsteret er en fast kilde til sporingsoppgaver nettopp fordi den første ytre runden ikke gir noe utslag.

Inne i en løkke leses høyre side av en tilordning med de verdiene variablene har
akkurat nå — altså etter alle tidligere linjer i samme runde.

a = 1 b = 2 for i in range(3):
    a = 2 * a + b b = b + 1 print(a, b)

Utskrift:

26 5

Merk at a bruker den gamle b i sin egen linje, fordi b oppdateres etterpå. Byttet du om de to linjene, ville a brukt den nye b, og svaret blitt et helt annet.

Dette er ikke en spissfindighet: det er et fast innslag i Oppgave 1, og fasiten avhenger av at du sporer linjene i den rekkefølgen de står.

Én gjennomkjøring av løkkekroppen. En løkke med fire iterasjoner kjører blokken fire ganger.

Ordet brukes også som verb: «å iterere over noe» betyr å gå gjennom det element for element. Du møter det i oppgavetekster og i fasiter, og det betyr aldri noe mer avansert enn dette.

Variabelen som får en ny verdi for hver runde — i i for i in range(5):.

To ting om den. Den lever videre etter løkka, med verdien fra siste runde, og den verdien kan du bli spurt om. Og navnet er ditt eget valg: bruk i for indekser og tellevariabler, og et beskrivende navn ellers.

Kjørte løkka null ganger, finnes variabelen ikke i det hele tatt.

Linjene som kjøres hver runde, altså de innrykkede linjene under for eller
while.

Å avgjøre hva som er i kroppen og hva som er utenfor, er første steg i enhver sporing. Startverdier hører utenfor, foran løkka; sluttresultatet skrives ut utenfor, etter løkka.

Reglene er de samme som ellers: startverdien er med, stoppverdien er ikke. Med negativt steg må startverdien være størst, ellers blir rekka tom og blokken kjøres aldri.

Antall runder er antall tegn i teksten, mellomrom medregnet. En tom tekst gir null runder.

Dette er inngangen til alle streng-oppgavene i
kap. 3.3, der du bygger opp en ny tekst tegn for tegn.

En sekvens uten elementer: range(0), range(3, 3), eller en tom tekst.

En for-løkke over en tom sekvens kjører blokken null ganger. Det er ikke en feil, og det gir ingen feilmelding — programmet går rett videre til linja etter løkka.

I en sporingsoppgave er dette et fullgodt svar: «løkka kjører aldri, så programmet skriver ingenting».

En while-løkke der betingelsen aldri blir usann. Programmet stopper aldri av seg selv.

Årsaken er nesten alltid den samme: ingen linje inne i løkka endrer variabelen betingelsen spør om. Motmiddelet er å skrive den linja først, før resten av kroppen.

I en sporingsoppgave kan riktig svar være at programmet aldri blir ferdig. Se derfor alltid etter linja som til slutt gjør betingelsen usann.

En tabell der du skriver én rad per runde og én kolonne per variabel som endrer seg, pluss en kolonne for hva som er skrevet ut så langt.

Tavla er bokas standardverktøy for sjanger A, og den er grunnen til at du kan løse en nøstet løkke uten å gjette. Den koster et halvt minutt på eksamen og fjerner nesten hele feilrisikoen.

Metoden står i sin fulle form i kap. 4.1.

Med faste grenser ganges antallet: en ytre løkke med 3 runder og en indre med 2 gir 6 gjennomkjøringer av den indre blokken.

Med en indre grense som avhenger av den ytre må du summere i stedet. for i in range(4): for j in range(i): gir 0 + 1 + 2 + 3, altså 6 — ikke 16.

Regn alltid ut antallet før du sporer. Da vet du hvor mange linjer utskrift du skal ende opp med, og du oppdager med én gang om sporingen sklir ut.