Nøstede løkker

Akkurat som vi kan ha nøstede if-strukturer med en if inni en annen, kan vi nøste løkker. Eksempel 1 skriver ut den lille gangetabellen ved hjelp av to for-løkker inni hverandre.

Eksempel 1:

# Skriver ut en gangetabell
for n in range(1, 11):
    for m in range(1, 11):
        print(n * m, end="\t")
    print()

Når vi i print() har satt inn koden end="\t", er det for at print() skal skrive ut et tabulatortegn i stedet for å sette inn ei ny linje. Det gjør at vi får tallene i gangetabellen pent organisert i kolonner. print() som står på ei linje for seg selv, vil skrive ut et linjeskift etter hvert gjennomløp av den indre løkka.

I eksempel 1 har vi ei ytre løkke med n som løkkevariabel, og ei indre løkke med m som løkkevariabel. Illustrerer vi logikken med et flytskjema, kan det se slik ut:

Her er det viktig å legge merke til at når det ikke er flere m i den indre løkka, sjekkes betingelsen i den ytre løkka på nytt. Og for hver n i den ytre løkka opprettes følgen av m i den indre løkka på nytt.

Her er en steg-for-steg-beskrivelse av hvordan koden virker:

• • I den ytre løkka starter vi med løkkevariabelen n = 1.
     
  • Vi går inn i den indre løkka og starter med løkkevariabelen m = 1.
     
  • Vi beregner og skriver ut produktet n · m = 1 · 1 = 1.
     
  • Vi tar et gjennomløp til i den indre løkka. Nå er m økt til 2, mens n fremdeles er 1. Så vi beregner og skriver ut n · m = 1 · 2 = 2.
     
  • Slik fortsetter vi med å gjennomløpe den indre løkka mens m etter tur blir 3, 4, 5, 6, 7, 8, 9 og 10. Deretter går vi videre og skriver ut et linjeskift.
     
  • Vi tar fatt på neste gjennomløp i den ytre løkka. n økes til 2. Deretter tar vi fatt på den indre løkka igjen. m starter da på nytt å telle fra 1.
     
  • Vi beregner og skriver ut n · m = 2 · 1 = 2.
     
  • Vi tar et gjennomløp til i den indre løkka. Nå er m økt til 2, mens n fremdeles er 2. Så vi beregner og skriver ut n · m = 2 · 2 = 4.

Slik fortsetter det. For hvert gjennomløp i den ytre løkka tar vi 10 gjennomløp i den indre. Til sammen blir den indre løkka gjennomløpt 100 ganger.

Resultatet blir slik:

Vi kan også nøste while-løkker, og nøste for-løkker sammen med while-løkker.

Det er i prinsippet ingen grenser for hvor mange løkker vi kan nøste inni hverandre, men i praksis er det sjelden behov for mer enn 2—3.

Oppgave 1:

Den nøstede løkka under, vist i Python Tutor, har samme struktur som koden for å skrive ut en gangetabell i eksempel 1. Vi har bare erstattet 10 med 4 som sluttverdi i range() for å få færre gjennomløp. Koden vil altså generere m ∈ [1, 2, 3] for hver n ∈ [1, 2, 3].

Gå gjennom koden med penn og papir, og skriv opp rekkefølgen de forskjellige linjene vil bli utført i, altså mønsteret den røde pila vil bevege seg i. Legg så koden inn i Python Tutor, og sjekk om du har rett ved å klikke gjennom den linje for linje.

Vær oppmerksom på at pila går til linjene med range() også idet sluttverdien nås, det vil for eksempel si at når m er 3, vil print() i linje 3 bli utført, deretter vil pila gå til linje 2, før den går direkte til linje 4.

Se løsningsforslag

Se film om nøstede løkker

Kilder

• • Matthes A. (2019). Python Crash Course. no starch press