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
exit() exit() er den kommando der får programmet til at afslutte. Det er den korrekte måde at gøre det på og svarer til at lukke en computeren rigtigt ned.

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.

Sådan tæller computere

En af de ting man støder på når man arbejder med programmering er, at computere tæller anderledes end vi gør. Når vi tæller starter vi fra en, og titalssystemet er anvendeligt for os fordi det passer med antallet af fingre på hånden. Når vi har brugt alle fingrene så tæller vi antallet af fulde hænder. 22 kan altså forståes som 2 fulde hænder og 2 fingre. I 10-talssystemet skifter vi altså position (veksler til den næste enhed) når vi kommer til den 10. værdi.

Eller udtrykt ved hjælp af matematik: vi tæller ved hjælp af ℕ = {1, 2, 3 ...}.

Computere arbejder med binære tal - dvs. den tæller ved hjælp af 0 og 1, og den første værdi er 0. Det er fordi den arbejder digitalt ved hjælp af nogle transistorer der enten kan være tændt eller slukkede. Konkret bliver der afsat et vist antal transistorer til at huske tallet, og der vil den første værdi være den hvor alle transistorer er slukkede - dvs. den har værdien 0

Eller udtrykt ved hjælp af matematik: vi tæller ved hjælp af ℕ0 = {0, 1, 2, 3 ...}.

For at vise dette kigger vi på en byte (der består af 8 bit) der tæller:

Computerens bits I 10-tals systemet
1. værdi 0 0 0 0 0 0 0 0 0
2. værdi 0 0 0 0 0 0 0 1 1
3. værdi 0 0 0 0 0 0 1 0 2
4. værdi 0 0 0 0 0 0 1 1 3
5. værdi 0 0 0 0 0 1 0 0 4
6. værdi 0 0 0 0 0 1 0 1 5
7. værdi 0 0 0 0 0 1 1 0 6
8. værdi 0 0 0 0 0 1 1 1 7
9. værdi 0 0 0 0 1 0 0 0 8
10. værdi 0 0 0 0 1 0 0 1 9
2⁷ 2⁶ 2⁵ 2⁴ 2⁰
Værdi 128 64 32 16 8 4 2 1

Af det ovenstående kan vi omregne fra binær til decimal ved at lægge de enkelte værdier sammen:

Binær Udregning Decimal
2⁷ 2⁶ 2⁵ 2⁴ 2⁰
11111111 128 64 32 16 8 4 2 1 255
10101101 128 32 8 4 1 173
10000001 128 1 129
00101101 32 8 4 1 45

Man bliver nød til at holde tungen lige i munden, fordi vi skal holde styr på vores in- og output. Tæller vi f.eks. antallet af tegn (char) i en streng angives det i ℕ (f.eks. Thomas = 6 tegn), men skal vi hente et tegn ud skal vi tænke ℕ0 (o er det 2 tegn i sætningen).

Placering 0 1 2 3 4 5
Tegn T h o m a s

En til eller fra

Ofte har man brug for at lade et tal vokse med en fast størrelse fra gang til gang. Den mest umiddelbare løsning er denne:

	
>>> a=0
>>> a
0
>>> a+1
1
	

Da man gør det så ofte har man en speciel "shorthand" til at løse dette problem med:

	
>>> a=0
>>> a +=1
>>> a
1
>>> a +=1
>>> a
2
	

På samme måde som ovenfor kan man også lægge til, gange og dividere

	
>>> a=1
>>> a+=5
>>> a
6
>>> a -=7
>>> a
-1
>>> a *=7
>>> a
-7
>>> a /=7
>>> a
-1.0
	

Man kan gøre det samme hvis man har lavet variabler. I eksemplet herunder lægger vi variablen alder til a.

	
>>> a=1
>>> alder=15
>>> a+=alder
>>> a
16
	

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.

Fortløbende

Her udskriver vi tal i rækkefølge.

	
>>> for i in range(5):
		print(i)

	
0
1
2
3
4
	

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):
		print(i+1)

	
1
2
3
4
5
	

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

	
>>> for i in range(8,13):
		print(i)

	
8
9
10
11
12
	

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.

Udskriv vandret

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 
	

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 	
	

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)
	

Udskriv baglæns

Dette kan vi også bruge til at tælle baglæs med:

	
>>> for i in range(5,-1,-1):
	print(i)

5
4
3
2
1
0
	

Læg mærke til at startværdien skal være større end slutværdien.

Brug af tælleren

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
		print(trekanttal, end=" - ")

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

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 = (i*(i+1))/2
		trekanttal = int(trekanttal)
		print(trekanttal, end=" - ")

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

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.

	
>>> for char in "Thomas":
		print(char)

	
T
h
o
m
a
s
	

Læg mærke til at ordet char blot skal ses som en variabel. Man kan lige så godt anvende et andet variabelnavn f.eks. bogstav (for bogstav in...)

Word word in...

Man kan også printe en tekst ord for ord. Det gøres ved at anvende funktionen split():

	
>>> tekst = "Hej med dig"
>>> for word in tekst.split():
		print(word)

	
Hej
med
dig
	

Opgaver

BUM

Lav funktionen bum(a,b) hvor a er det tal der tælles til og b er den tabel der arbejdes med:

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

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

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.0°
I en 4-kant er vinkelsummen 360° og den enkelte vinkel er 90.0°
I en 5-kant er vinkelsummen 540° og den enkelte vinkel er 108.0°

...

I en 18-kant er vinkelsummen 2880° og den enkelte vinkel er 160.0°
I en 19-kant er vinkelsummen 3060° og den enkelte vinkel er 161.05263157894737°

------------------
(program exited with code: 0)

Press any key to continue . . .

Formlen er:

$$ Vinkelsum = 180 \cdot (i-2) $$

Ændr koden, så den ikke udskriver decimaler på heltal ved hjælp af funktionen is_integer(), og sådan at der kun er to decimaler på værdierne for den enkelte vinkel ved hjælp af round() (se nedefor)

	
>>> pi = 3.14159265
>>> round(pi,3)
3.142
	

Mini Google

Ændr koden i opgaven Ord i tekst 1 (henvisning) fra forrige kapitel så det også tæller antallet af gange ordet optræder:

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.

Variabler i løkker

Ofte har man brug for at lave variabler i løkker. Det kan f.eks. være hvis man vil oprette brugere i løkker. Til dette formål anvender man dictionaries. En dictionary er en lille tabel med to kolonner hvor første kolonne er opslaget og den anden er værdien.

Forestil dig at vi vil oprette en brugerliste og knytte et brugernummer til dem:

  • Anne → 1
  • Bent → 2

Herunder viser jeg hvordan man opretter og udskriver dette dictionary.

	
>>> brugere={"Anne": 1, "Bent": 2}
>>> brugere
{'Bent': 2, 'Anne': 1}
	

Vi har altså nu bundet navnet Anne til tallet 1 og navnet Bent til tallet 2.

Hvis jeg gerne vil udskrive en af værdierne gør jeg følgende:

	
>>> brugere["Anne"]
1
>>> brugere["Bent"]
2
	

Fordelen ved at anvende dictionaries er altså, at vi kan binde et opslag til en værdi/tekststreng. Det er altså reelt en multivariabel, som kan indeholder flere variabler. I ovenstående tilfælde indeholder den altså "Anne" = 1 og "Bent" = 2.

Det betyder også at vi kan ændre på variablerne løbende. Se herinder hvor jeg lægger 1 til "Bent"

	
>>> brugere["Bent"] +=1
>>> brugere
{'Bent': 3, 'Anne': 1}
	

Konstruere dictionaries

Herunder er vist et eksempel hvor jeg jeg opretter en dictionary

	
brugerliste={}

for i in range(3):
	
	brugernavn = input("\nHvad er brugerens navn?: ")
	password = int(input("\n\tIndtast password (kun tal): "))
	
	brugerliste["{0}".format(brugernavn)] = password
	
print("\n\nHer er din brugerliste: {0}".format(brugerliste))
	
	
Hvad er brugerens navn?: Thomas

        Indtast password (kun tal): 123

Hvad er brugerens navn?: Kurt

        Indtast password (kun tal): 234

Hvad er brugerens navn?: Niels

        Indtast password (kun tal): 345


Her er din brugerliste: {'Thomas': 123, 'Niels': 345, 'Kurt': 234}


------------------
(program exited with code: 0)

Press any key to continue . . .

Man kan også skrive et dictionary mere overskueligt:

	
personer = {

		"Hans" : 1,
		"Grethe" : 2,
		"Heks" : 3

	}
	
print (personer)
	
{'Heks': 3, 'Grethe': 2, 'Hans': 1}

------------------
(program exited with code: 0)

Press any key to continue . . .

Opgaver

Terningspil 2

Lav et program der slår med en D6 terning (6 sider) det antal gange brugeren ønsker det, og lav en optælling af hvert terningslag

Hvor mange slag?: 100000

Du slog:

	16678 enere
	16685 toere
	16552 treere
	16758 firere
	16707 femmere
	16620 seksere


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

Terningspil 3

Ændre koden fra opgaven terningspil 1 (henvisning)fra forrige kapitel på følgende måde:

  • Brugeren skal vælge mellem en D4, D6, D10 og D20 terning (antallet af sider)
  • Brugeren vælger antallet af slag
  • Programmet udnævner en vinder og laver en udskrift af hvor mange gange bruger og computer har vundet og antallet af uafgjorte runder.

Herunder er et eksempel på en udskrift.

Hvad er dit navn: Thomas  ← Input

Du kan vælge at slå med 4 forskellige terninger, og du kan vælge mellem:

	1) D4	(4 sider)
	2) D6	(6 sider)
	3) D10	(10 sider)
	4) D20	(20 sider)


Hvilken terning vil du spille med?: 3  ← Input

	Du valgte en D10.


Hvor mange slag vil du lave?: 1000  ← Input

	Du valgte 1000 slag.


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

Computeren vandt 438 gange

Thomas vandt 464 gange

Der blev spillet uafgjort 98 gange

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

Thomas vandt.


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

Hvor lang tid tager det at spiller:

  • 10.000 slag
  • 100.000 slag
  • 1.000.000
  • 10.000.000

Er der forskel på om du bruger en D4 eller en D20?

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)

	
1
2
3
4
5
6
7
8
9
10

------------------
(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.

While True

Hvis man gerne vil have at en løkke skal køre uanset hvad, så kan man sætte den til at køre ved at bruge: while True. Se eksemplet herunder hvir koden kører indtil brugeren skriver: Hej:

	
while True:

	valg = input("Skriv 'Hej': ")
	
	if valg == "Hej":
	
		print("Tak!")
		
		break
	
Skriv 'Hej': tak
Skriv 'Hej': nej
Skriv 'Hej': STOP NU
Skriv 'Hej': hej
Skriv 'Hej': SKAL DET VÆRE MED STORT FORBOGSTAV
Skriv 'Hej': Hej
Tak!

------------------
(program exited with code: 0)

Press any key to continue . . .

Husk en computer er meget tålmodig

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

Gæt et tal 1

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

while True:
	gæt = int(input("Gæt hvilket tal jeg er: "))

	if gæt == 8:
		print ("\nN I C E")
		exit()
	

Gæt et tal 2

  • 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.

Dril

Lav en kode der gentager hvad du siger - indtil du siger klorofyl

Skriv noget: Hej

Hej: Hvad sker der

Hvad sker der: STOP DET DER

STOP DET DER: klorofyl

        Du sagde det magiske ord.

------------------
(program exited with code: 0)

Press any key to continue . . .

Stopur

Man kan lave en tidsforsinkelse ved hjælp af funktionen sleep der er i pakken time()

	
from time import sleep

while True:

	for i in range(5,-1,-1):
		
		if i ==0:
			print("Fyr")
			exit()
		
		print(i)
		sleep(1)
	
5
4
3
2
1
Affyr!

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

Ændr koden, så der tælles ned på samme position. For at opnå det skal du anvende escape character'en \r (carrage return).

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

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
exit() exit() er den kommando der får programmet til at afslutte. Det er den korrekte måde at gøre det på og svarer til at lukke en computeren rigtigt ned.

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

continue anvendes når vi gerne vil have at løkket "hopper" videre, uden at udføre det der står efter continue. Se eksemplet herunder

	
for char in 'Thomas':
   if char == 'm':
      continue
   print ('Bogstavet er:', char)
	
Bogstavet er: T
Bogstavet er: h
Bogstavet er: o
Bogstavet er: a
Bogstavet er: s

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

Løkken udskriver bogstaverne i tekststrengen Thomas, men der er en speciel betingelse ved bogstavet m. Vi vil ikke have at bogstavet skal printes, så vi indsætter continue, for ikke at bryde løkken, men at fortsætte ved næste bogstav.

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 er brugbar fordi den ikke ændrer på hvordan løkken køres. Man kan f.eks. lave tomme funktioner ... altså funktioner der ikke er konstrueret endnu. Så kan funktionen indsættes når den er lavet.

	
def tomfunktion():
	pass
	
tomfunktion()
	
			← intet output
------------------
(program exited with code: 0)
Press return to continue

exit()

Denne kommendo bruges når du vil afsluttet programmet helt.

Forestil dig en situation hvor du inde midt i din kode skal give din bruger et valg om at genstarte eller afslutte et program. Se f.eks. nedestående eksempel, hvor vi kaster med en almindelig terning.

	
from random import randrange

kast = randrange(1,7)

while kast !=6:
	
	print("Du slog en {0}'er".format(kast))

	igen = input("\nHar du lyst til at spille igen (j/n)?: ")

	if igen == "j":
		kast = randrange(1,7)
		continue #starter programmet en gang til
	else:
		print("\nTak for spillet")
		exit() #afslutter programmet

print("Du slog en 6'er") # denne linie kommer med
	

Opgaver

Erstat bogstaver

Lav et program der erstatter g med n i det nedestående tekst.

Igennem mange generationer har børn og unge hygget sig med gynger.

Altså så outputtet bliver (på en linje):

Inennem manne nenerationer har børn on unne hynnet sin med nynner.

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