Løkker

Løkker - et overblik

Ofte har man brug for at et program skal gøre det samme igen og igen. Det kan f.eks. være at skulle udføre den samme beregning, på et stigende tal. Det kan f.eks. være at udskrive kvadrattallene (1,4,9,16,25 ...). På engelsk kaldes dette et loop.

Python arbejder med 2 forskellige loops:

Løkke type Beskrivelse
for ... anvendes når man kender det nøjagtige antal gennemløb. Hvis man f.eks. ved at en funktion skal gennemløbes 10 gange vil man anvende for-løkken.
Herunder er den generelle anvendelsen af løkken vist.

for *tæller* in range(*startværdi*, *slutværdi*,*spring*):
while ... anvendes når man ikke på forhånd kender antallet af gennemløb. Funktionen gennemløbes indtil en betingelse er opfyldt.
Herunder er den generelle anvendelsen af løkken vist.

while *betingelse*:

Derudover gælder der også nogle control statements (kontroludsagn), som kan ændre udførslen af løkker.

Kontroludsagn Beskrivelse
break Bryder løkken og lader programmet fortsætte lige efter løkken
continue Bryder behandlingen af koden, hopper videre til næste værdi og kører løkken derfra
pass pass er hvad man kalder en null operation. Med den kommando kan man indsætte ekstra kode for enkelttilfælde uden at resten af koden ændres

De ovenstående forklaringer er ment som et indblik i hvad det er løkker og kontroludsagn gør. Herunder vil løkkerne blive gennemgået udførligt.

for løkken

Nogle gange skal man have sit program til at udgøre den samme operation flere gange. til at udføre dette anvendes man løkker.

	
for i in range(5): #Udfør for de første 5 værdier
    print (i)
	

0
1
2
3
4

------------------
(program exited with code: 0)
Press return to continue

Læg mærke til at Python starter med at tælle fra 0. Man skal vænne sig til at computere tæller fra 0 og ikke en. Hvis vi skal have computeren til at skrive tallen "menneskeligt" skal vi lægge 1 til hver gang:

	
for i in range(5): #Udfør for de første 5 værdier
    print (i + 1)
	

1
2
3
4
5

------------------
(program exited with code: 0)
Press return to continue

Vi kan også vælge en delmængde f.eks. tallene fra 8-13.

	
for i in range(8,13): #Udfør for værdierne 8-13
    print (i)
	

8
9
10
11
12

------------------
(program exited with code: 0)
Press return to continue

Læg mærke til at 13 ikke udskrives, som vi umiddelbart ville forvente. I range() er den første værdi inkluderet men ikke den sidste. Det giver den fordel at den udskriver præcis 13-8=5 værdier.

Det kan være uhensigtsmæssigt at få talrækker som den ovenstående udskrevet med et linieskift hver gang. Ændr koden til ved at tilføje end=" ":

	
for i in range(0,10):
    print (i, end=" ")
	

0 1 2 3 4 5 6 7 8 9

------------------
(program exited with code: 0)
Press return to continue

Dette får python til at udskrive uden at lave et linieskift hver gang.

Ved hjælp af range kommandoen kan vi også få den til at udskrive hvert x'te tal f.eks. hver andet (lige tal):

	
for i in range(0,10,2):
    print (i, end=" ")		
	

0 2 4 6 8

------------------
(program exited with code: 0)
Press return to continue

En for løkke fungerer altså ved at man sætter alle betingelserne i den efterfølgende parentes. Den fortæller altså startværdien, slutværdien (ikke medtaget) og væksten pr. omgang).

	
for i in range(startværdi, slutværdi, vækst pr. omgang)

Nogle gange skal den samme programlinie køres flere gange. Det kan f.eks. være hvis man gerne vil finde de 12 første trekanttal – altså talrække 1, 3, 6, 10, 15, 21... . Man kan udregne tallene med formlen herunder:

$$ T_n = 1+2+3 ... +n= \frac {n \cdot (n-1)}{2} $$

Ved at lave en løkke der sørger for at n stiger med en hver gang kan vi altså udregne det næste trekanttal. Her anvender vi en for løkke


for i in range(1,12):
	
    trekanttal = ((i*(i+1))/2, end = " - ")
	
    print (trekanttal)
	

1.0-3.0-6.0-10.0-15.0-21.0-28.0-36.0-45.0-55.0-66.0-

------------------
(program exited with code: 0)
Press return to continue

Python sætter en decimal på, fordi den ser resulater fra divisionsstykker som float. Det fjernes ved at tvinge Python til at se resultatet som et heltal (interger)


for i in range(1,12):
	
    trekanttal = int((i*(i+1))/2)

    print (trekanttal, end=" - ")
	

1 - 3 - 6 - 10 - 15 - 21 - 28 - 36 - 45 - 55 - 66 - 

------------------
(program exited with code: 0)
Press return to continue

For char in ...

Ofte har man brug for at kunne gennemføre en funktion på hver eneste tegn i en tekststreng. Herunder er vist et simpelt eksempel hvor man ved hjælp af en for-løkke printer hver bogstav i navnet.

	
navn = "Thomas"

for char in navn:
	
    print(char)
	

T
h
o
m
a
s


------------------
(program exited with code: 0)
Press return to continue

Dette kan anvendes praktisk, hvis man ønsker at finde bestemte tegn i en tekststreng, f.eks. dots (.) i en IP-adresse. Herunder vil vi finde placeringen af dots i IP-adressen: 192.168.2.100. Se nedestående tabel, hvor IP-adressen sættes ind i et positionsskema:

1 9 2 . 1 6 8 . 2 . 1 0 0
0 1 2 3 4 5 6 7 8 9 10 11 12 
	
ip = "192.168.2.100"

tegn = -1 # Værdien sættes til -1, for at første værdi antager 0

for char in ip:
	
    tegn +=1

    dot = "." in char

    if dot == True:
		
        print ("Here is a dot {0}".format(tegn))
	

Here is a dot 3
Here is a dot 7
Here is a dot 9


------------------
(program exited with code: 0)
Press return to continue

Vi skal senere lære hvordan vi kan arbejde med tekstrenge, sådan at vi f.eks. kan analysere værdierne der står mellem de forskellige dot's.

Opgaver

Opgave - Vinkelsum i polygon

Lav en løkke der beregner den enkelte vinkel og den samlede vinkel i en ligesidet polygon med op til 20 sider. Outputtet skal være som nedenfor:

	
I en 3-kant er vinkelsummen 180° og den enkelte vinkel er 60°
I en 4-kant er vinkelsummen 360° og den enkelte vinkel er 90°
...
I en 20-kant er vinkelsummen ...

Hint:

  • Formlen for en polygons vinkelsum er hvor vinkelsum = 180° · (n-2), og hvor n = antal kanter.
  • Prøvekør løkken ved at udskrive i.
  • For at kunne få outputtet til at skifte linie skal du anvende HTML koden <br>.

Opgave - Fibonacchi tal

Fibonaccitallene er en talrække, som har følgende egenskab. Hvis man dividerer et tal i rækken med det forgående tal, så vil dette tal tilnærme sig værdien φ (1.6180339...) som også bliver kaldt det gyldne snit.

Fibonaccitalrækken er: 1, 1, 2, 3, 5, 8, 13, 21 ...

Man kan udregne φ ud fra følgende formel baseret på fibonaccitallene hvor man tager et fibonaccital og dividerer det med det efterfølgende.

$$ \phi = \frac{n-1}{n} ~~for~ \to \infty$$

Opgaven er at lave en kode der tager talrækken: 0, 1, 2, 3, 4, 5 .... og laver den om til fibonaccital. på følgende måde:

  • 0 + 1 = 1
  • 1 + 2 = 3
  • 2 + 3 = 5
  • 3 + 5 = 8
  • 5 + 8 = 13

Koden skal udregne de første 20 fibonaggital: Her er en forklaring på koden:

  1. Lav to variabler a, b og sæt dem til henholdsvis 0 og 1
  2. lav en forløkke der kører op til 20 gange baseret på i
  3. lad i vokse med en hver gang koden køres
  4. Udskriv a, hvis den er stærre end 0
  5. Gem den gamle værdi for a i en ny variabel (f.eks: old_a)
  6. Sæt a = b
  7. Sæt b = b + den gamle værdi for a

Koden skal give nedestående output

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 

------------------
(program exited with code: 0)
Press return to continue

Kan du ændre i koden så den også regner φ ud og giver nedestǻende output?

Fibonacci taller er: 1 og φ er: 1.0
Fibonacci taller er: 1 og φ er: 0.5
Fibonacci taller er: 2 og φ er: 0.6666666666666666
Fibonacci taller er: 3 og φ er: 0.6
Fibonacci taller er: 5 og φ er: 0.625
Fibonacci taller er: 8 og φ er: 0.6153846153846154
Fibonacci taller er: 13 og φ er: 0.6190476190476191
Fibonacci taller er: 21 og φ er: 0.6176470588235294
Fibonacci taller er: 34 og φ er: 0.6181818181818182
Fibonacci taller er: 55 og φ er: 0.6179775280898876
Fibonacci taller er: 89 og φ er: 0.6180555555555556
Fibonacci taller er: 144 og φ er: 0.6180257510729614
Fibonacci taller er: 233 og φ er: 0.6180371352785146
Fibonacci taller er: 377 og φ er: 0.6180327868852459
Fibonacci taller er: 610 og φ er: 0.6180344478216818
Fibonacci taller er: 987 og φ er: 0.6180338134001252
Fibonacci taller er: 1597 og φ er: 0.6180340557275542
Fibonacci taller er: 2584 og φ er: 0.6180339631667066
Fibonacci taller er: 4181 og φ er: 0.6180339985218034
Fibonacci taller er: 6765 og φ er: 0.618033985017358


------------------
(program exited with code: 0)
Press return to continue

Lav funktionen fibo(n) hvor n er antallet af fibonaccital.

While

While betingelser angiver noget der skal ske så længe en betingelse er opfyldt. Herunder laver vi en kode, der udskriver tallet a så længe det er under 10

	
a = 0

while a < 10:

    a +=1

    print (a)

print ("\nNu har vi udskrevet de 10 første tal")
	

1
2
3
4
5
6
7
8
9
10

Nu har vi udskrevet de 10 første tal


------------------
(program exited with code: 0)
Press return to continue

Det som koden gør er, at mens (while) betingelsen er opfyldt kører den det som er rykket ind under koden. I dette tilfælde kører koden indtil a ikke længere er mindre en 10.

Opgaver

Beskriv hvad hvad koden gør?

	
print("Gæt på et tal mellem 1 og 9\n")

a = 0

while a != 8:

    a = int(input("Gæt hvilket tal jeg er: "))

print ("\nN I C E")

Udvid koden

  • tallet der skal gættes laves af funktionen randrange()
  • det efter 4 forsøg i input teksten skriver: Kan man virkeligt gætte forkert så mange gange?
  • At koden af afbrydes med beskeden Du er vist useriøs, hvis man ikke skriver et tal mellem 1 og 9.
  • At det skriver "Godt gættet :)!" når du rammer rigtigt

HINT: for at kunne få en kode til at afbryde anvender man kommandoen exit(). Når koden læser denne linie afsluttes kørslen.

Betingede løkker

I de ovenstående kapitler har løkkerne været simple, fordi vi har været helt klar over hvad de skulle. Det hænder dog, at man vil sætte nogle betingelser for løkkerne. Det kan f.eks. være en kode der skal løbe indtil brugeren har valgt rigtigt.

Vi kan betinge løkkerne ved hjælp af følgende metoder:

Metode Beskrivelse
break Bryder den ingangværende løkke
continue Afbryder den konkrete session i løkken og fortsætter med næste gennemkørsel af løkken
pass Gør intet, men lader løkken fortsætte i samme session

break

Forestil dig at vi laver et spørgsmål om et antal brugere, men at vi kun vil acceptere 4. Den lette løsning er, at lave en kode der forventer at brugere svarer rigtigt.

	
antalBrugere = int(input("Indtast antal brugere (1-4): "))

Problemet med denne kode er, at den vil videresende input ligegyldigt om det 17 eller -5 brugere. For at sikre os at brugeren indtaster korrekt kan vi gøre følgende:

	
while True:
	
    antalBrugere = int(input("Indtast antal brugere (1-4): "))

    if antalBrugere >=1 and antalBrugere <=4:
	    print("\nDer er {0} brugere)".format(antalBrugere))
	    break #Hop ud af while løkken
    else:
        print("\n\tDer skal være mellem 1 og 4 brugere. Prøv igen...")			
	

Indtast antal brugere (1-4): 6

    Der skal være mellem 1 og 4 brugere. Prøv igen...

Indtast antal brugere (1-4): 5

    Der skal være mellem 1 og 4 brugere. Prøv igen...

Indtast antal brugere (1-4): 4

Der er 4 brugere)

------------------
(program exited with code: 0)
Press return to continue

while-løkken kører så længe den ikke modtager et False. D.v.s. den kan køre uendeligt. Det eneste som får løkken til at stoppe er fordi der er indsat en break kommando hvis n er lig med variablen goal. break kommandoen bryder while-løkken og lader programmet køre videre.

Ulempen ved den kode vi har lavet er, at den vil blive ved med at køre indtil der kommer et input som opfylder betingelsen. Vi vil senere kigge på at indsætte en tæller i koden, sådan at den kun kan køre et bestemt antal gange.

continue

Herunder vil vi lave koden til matematiklegen BUM. Programmet skal udskrive tallene fra 1-15, men den må ikke udskrive tal fra 3-tabellen. Det betyder at vi skal undersøge tallene ved hjælp af modulus (se ovenfor):

	
for i in range(1,16):
    if i%3 == 0:
        print("BUM", end="  ")
        continue
    else:
        print(i, end="  ")
	

1  2  BUM  4  5  BUM  7  8  BUM  10  11  BUM  13  14  BUM  

------------------
(program exited with code: 0)
Press return to continue

Det koden undersøger om modulus af i er = 0. Hvis den er så udskriver den XXX og får koden til at køre videre med næste i værdi. Det er netop forskellen mellem break og continue. break afbrød løkken, men continue lader den fortsætte.

pass

pass er umiddelbart en underlig kommando, fordi den gør reelt ingen forskel. Men den er rigtig brugbar. Forestil dig en kode, hvor du vil udskrive tallene fra 1-10, men lige vill gøre opmærksom på at 7 er dit lykketal:

	
for i in range(1,11):
    if i == 7:
        print("Næste tal er mit lykketal")
        pass
    print(i)
	

1
2
3
4
5
6
Næste tal er mit lykketal
7
8
9
10

------------------
(program exited with code: 0)
Press return to continue

pass kan også anvendes til at køre opmærksom på en kodestump der mangler 

	
for i in range(1,11):
    if i%5==0:
        print("Kode for tal i 5 tabellen mangler")
        pass
    print(i)
	

1
2
3
4
Kode for tal i 5 tabellen mangler
5
6
7
8
9
Kode for tal i 5 tabellen mangler
10


------------------
(program exited with code: 0)
Press return to continue

pass er brugbar fordi den ikke ændrer på hvordan løkken køres.

Tællere i løkker

Hvis vi kikker på den første betingede while-løkke vi lavede ovenfor, så vil den køre indtil brugeren taster rigtigt. Herunder vil vi kigge på en metode til at begrænse antallet af forsøg.

Vi indsætter simpelthen en øvre grænse for hvor mange gange koden må løbe og laver et break når grænsen er nået. Jeg har valgt at kommentere direkte i koden.

	
# Den øvre grænse
limit = 3

while True:
	
    antalBrugere = int(input("Indtast antal brugere (1-4): "))
    
    if antalBrugere >=1 and antalBrugere <=4:
        print("\nDer er {0} brugere)".format(antalBrugere))
        break #Hop ud af while løkken
    else:
	
        #Tæller en ned på den øvre grænse når brugeren vælger forkert
        limit -=1 
	
        #Det løkken gør så længe der er forsøg tilbage
        if limit > 0: 
            print("\n\tDer skal være mellem 1 og 4 brugere.")
            print("\n\tDu har nu {0} forsøg tilbage\n".format(limit))

        # Det løkken gør når grænsen er nået
        else: 
            print("\nDu har ikke flere forsøg tilbage - bye bye")
            break #Hop ud af while løkken

Opgaver

Tabeltræner

Lav et program der stiller 5 tilfældige regnestykker fra den lille tabel (1-9). Programmet skal tælle:

  • Antal rigtige
  • Antal forsøg tilbage
  • Udregne antal % rigtige, med en decimal