2.4 Løkker og gjentakelse

Løkker og gjentakelse

Forestill deg at du skal skrive ut tallene fra 1 til 100. Uten løkker måtte du skrive 100 print-setninger. Med en løkke klarer du det med to linjer kode. Løkker er en av de kraftigste verktøyene i programmering fordi de lar deg gjenta kode så mange ganger du vil, uten å skrive den samme koden om og om igjen.

Python har to typer løkker: for-løkker som itererer over en bestemt sekvens, og while-løkker som gjentar kode så lenge en betingelse er sann. I dette kapittelet skal du lære å bruke begge typene, samt spesielle nøkkelord som break og continue for å kontrollere løkkenes oppførsel.

for-løkker

En for-løkke itererer over en sekvens og kjører kodeblokken én gang for hvert element i sekvensen. Det vanligste er å bruke range() for å generere en tallsekvens:

# Skriv ut tallene 0 til 4
for i in range(5):
    print(i)

Kjøring gir:

0
1
2
3
4

Forklaring: range(5) genererer tallene 0, 1, 2, 3, 4 (5 tall, men starter på 0). For hver iterasjon får variabelen i neste verdi fra sekvensen, og koden inne i løkken kjøres.

range() med forskjellige argumenter

# range(start, stopp) - starter på start, stopper FØR stopp
for i in range(1, 6):
    print(i)     # Skriver ut: 1, 2, 3, 4, 5

# range(start, stopp, steg) - med egendefinert steg
for i in range(0, 20, 5):
    print(i)     # Skriver ut: 0, 5, 10, 15

# Telle nedover
for i in range(10, 0, -1):
    print(i)     # Skriver ut: 10, 9, 8, ..., 2, 1

Iterere over tekst

Du kan også bruke for-løkker til å gå gjennom hver bokstav i en tekststreng:

navn = "Python"
for bokstav in navn:
    print(bokstav)

Kjøring gir:

P
y
t
h
o
n

Iterere over en liste

frukter = ["eple", "banan", "appelsin", "druer"]
for frukt in frukter:
    print(f"Jeg liker {frukt}!")

Kjøring gir:

Jeg liker eple!
Jeg liker banan!
Jeg liker appelsin!
Jeg liker druer!

while-løkker

En while-løkke gjentar kodeblokken så lenge en betingelse er sann (True). Betingelsen sjekkes før hver iterasjon:

# Telle til 5 med while
teller = 1
while teller <= 5:
    print(teller)
    teller += 1

print("Ferdig!")

Kjøring gir:

1
2
3
4
5
Ferdig!

Steg for steg:
1. teller = 1 - variabelen starter på 1
2. while teller <= 5: - er 1 <= 5? Ja (True), kjør blokken
3. Skriv ut 1, øk teller til 2
4. Er 2 <= 5? Ja, kjør blokken...
5. (Fortsetter til teller er 6)
6. Er 6 <= 5? Nei (False), stopp løkken
7. "Ferdig!" skrives ut

Når bruker du while vs. for?

- Bruk for når du vet på forhånd hvor mange ganger løkken skal kjøre
- Bruk while når løkken skal fortsette til en betingelse endrer seg

# while er perfekt for brukerinteraksjon
svar = ""
while svar != "ja":
    svar = input("Vil du avslutte? (ja/nei): ")

print("Ha det bra!")

Her vet vi ikke på forhånd hvor mange ganger brukeren vil svare "nei", så while er det naturlige valget.

break og continue

Python har to spesielle nøkkelord for å kontrollere løkker:

break - Avbryt løkken

break stopper løkken umiddelbart og hopper ut av den:

# Finn det første tallet delelig med 7 mellom 50 og 100
for tall in range(50, 101):
    if tall % 7 == 0:
        print(f"Fant det! {tall} er delelig med 7")
        break

Kjøring gir:

Fant det! 56 er delelig med 7

Uten break ville løkken fortsatt å lete etter flere tall. Med break stopper vi ved det første treffet.

continue - Hopp til neste iterasjon

continue hopper over resten av den aktuelle iterasjonen og går til neste:

# Skriv ut alle tall fra 1 til 10, unntatt tall delelig med 3
for i in range(1, 11):
    if i % 3 == 0:
        continue  # Hopp over dette tallet
    print(i)

Kjøring gir:

1
2
4
5
7
8
10

Tallene 3, 6 og 9 ble hoppet over fordi continue ble utløst.

break i while-løkker

break er spesielt nyttig i while-løkker for å lage kontrollerte utganger:

# Gjette-spill
import random
hemmelig = random.randint(1, 10)

while True:  # Uendelig løkke
    gjett = int(input("Gjett et tall (1-10): "))

    if gjett == hemmelig:
        print("Riktig! Du gjettet det!")
        break  # Avbryt løkken
    elif gjett < hemmelig:
        print("For lavt! Prøv igjen.")
    else:
        print("For høyt! Prøv igjen.")

Her bruker vi while True (som aldri blir False) sammen med break for å avslutte når brukeren gjetter riktig.

Nøstede løkker

Du kan plassere en løkke inne i en annen løkke. Den indre løkken kjøres ferdig for hver iterasjon av den ytre løkken:

# Gangetabell 1-5
for i in range(1, 6):
    for j in range(1, 6):
        print(f"{i} x {j} = {i*j:2d}", end="   ")
    print()  # Ny linje etter hver rad

Kjøring gir:

1 x 1 =  1   1 x 2 =  2   1 x 3 =  3   1 x 4 =  4   1 x 5 =  5
2 x 1 =  2   2 x 2 =  4   2 x 3 =  6   2 x 4 =  8   2 x 5 = 10
3 x 1 =  3   3 x 2 =  6   3 x 3 =  9   3 x 4 = 12   3 x 5 = 15
4 x 1 =  4   4 x 2 =  8   4 x 3 = 12   4 x 4 = 16   4 x 5 = 20
5 x 1 =  5   5 x 2 = 10   5 x 3 = 15   5 x 4 = 20   5 x 5 = 25

Den ytre løkken (i) styrer radene, og den indre løkken (j) styrer kolonnene. For i=1 kjører j gjennom alle verdier 1-5, deretter økes i til 2, og j kjører igjen gjennom 1-5, osv.

end=" " i print() gjør at neste print kommer på samme linje (med tre mellomrom mellom). Den tomme print() lager et linjeskift etter hver rad.

Et enklere eksempel med nøstede løkker:

# Skriv ut et mønster med stjerner
for rad in range(1, 6):
    for stjerne in range(rad):
        print("*", end="")
    print()

Kjøring gir:

*
**
***
****
*****

Oppsummering

I dette kapittelet har du lært:

- Løkke: gjentar en kodeblokk flere ganger.
- for-løkke: itererer over en sekvens eller range().
- range(): lager tallserier med start, stopp og steg.
- while-løkke: gjentar så lenge en betingelse er sann.
- break og continue: avbryter eller hopper over i en løkke.
- Noestede loekker: løkke inne i løkke.

Noekkelbegreper