Skip to main content

2  Repetisjon av programmering

Du har programmert før, i IT1 eller på ungdomsskolen. Dette kapittelet repeterer det du trenger for å følge resten av boka: variabler, valg, løkker, lister, ordbøker, funksjoner og hvordan du planlegger en løsning før du koder. Hvert delkapittel har oppgaver på flere nivåer. Har du god kontroll, kan du starte på oppgavene og gå tilbake til teorien når du står fast.

Du kan gjøre oppgavene på tre måter: i boka (kodeoppgavene rettes automatisk), i notatboka i nettleseren (lenkene under), eller i VS Code. I kapittel 1 satte du opp VS Code, og fra og med kapittel 4 jobber du mest der.

Læringsmål

Etter å ha arbeidet med kapittelet skal du kunne

  • skrive små programmer med variabler, operatorer og typekonvertering,
  • bruke if, elif, else, for og while til å styre hva programmet gjør,
  • lagre og bearbeide data i lister, tupler og ordbøker,
  • dele opp koden i funksjoner med parametere og returverdi,
  • planlegge en løsning med algoritmer, flytdiagram og pseudokode,
  • lese, rette og teste din egen kode.

2.1 Variabler, datatyper og operatorer

Alle programmer jobber med verdier: tall, tekst og sant eller usant. I denne delen ser du hvordan du lagrer verdier i variabler, hvilke typer de kan ha, og hvordan du regner med dem og sammenligner dem.

2.1.1 Variabler og datatyper

Du står i kassa og kjøper tre brus til \(29\) kroner stykket. Kassa regner ut \(3 \cdot 29 = 87\) kroner. For at et program skal gjøre det samme, må det huske tallene underveis. Det gjør det med variabler:

pris = 29
antall = 3
total = pris * antall
print(total)
87

Hver av de tre første linjene setter et navn på en verdi. Programmet kan så bruke navnene i stedet for tallene, og det gjør koden lettere å lese og lettere å endre: kjøper du fire brus, endrer du bare én linje.

Læringsmål

Etter dette delkapittelet skal du kunne

  • lage variabler, gi dem nye verdier og følge hva som skjer med dem linje for linje,
  • velge gode variabelnavn etter reglene i Python,
  • kjenne igjen datatypene int, float, str og bool, og sjekke dem med type(),
  • skrive ut verdier med print og f-strenger, og lese inn tekst med input.

Variabler

Tegnet = betyr ikke «er lik» i Python. Det betyr «får verdien». Linja pris = 29 leses «pris får verdien \(29\)». Høyresiden regnes alltid ut først, og resultatet lagres i variabelen til venstre.

DefinisjonVariabel

En variabel er et navn som peker på en verdi i programmet. Med navn = verdi lager vi variabelen eller gir den en ny verdi. Verdien kan endres så mange ganger vi vil:

antall = 3
antall = antall + 1

Her regnes antall + 1 ut med den gamle verdien (\(3\)), og resultatet (\(4\)) blir den nye verdien til antall.

En variabel som endres, endrer ikke andre variabler som ble regnet ut av den tidligere. Det er det vanligste å misforstå, så følg med i eksemplet under.

Hva er verdiene til a og b etter at programmet har kjørt?

a = 5
b = a * 2
a = 1
b = b + a

Lag en tabell med én kolonne for a og én for b, og fyll ut en rad for hver linje.

Linje a b
a = 5 \(5\) –
b = a * 2 \(5\) \(10\)
a = 1 \(1\) \(10\)
b = b + a \(1\) \(11\)

Etter programmet er a lik \(1\) og b lik \(11\). Linja b = a * 2 regnet ut \(10\) med den gamle verdien av a, og b endret seg ikke da a ble satt til \(1\).

RegelNavn på variabler
  • Navnet kan inneholde bokstaver, tall og understrek, men ikke starte med et tall og ikke ha mellomrom.
  • Store og små bokstaver er forskjellige: pris og Pris er to ulike variabler.
  • Vi skriver navn med små bokstaver og understrek mellom ordene (snake_case), og velger navn som sier hva verdien er: antall_elever, ikke x.
  • I denne boka skriver vi navn på norsk, uten æ, ø og å: hoyde, maned.

Datatyper

Alle verdier i Python har en type. Typen bestemmer hva vi kan gjøre med verdien. Du kan regne med tall, men ikke med tekst, og tekst kan settes sammen, men ikke gjøres om til sann eller usann.

RegelDe fire grunntypene
  • int: heltall, for eksempel 7 og -3.
  • float: desimaltall, for eksempel 3.14. Husk punktum, ikke komma.
  • str: tekst, skrevet mellom anførselstegn, for eksempel "hei".
  • bool: True eller False. Svaret på et spørsmål som 7 > 3.

Med type() ser vi hvilken type en verdi har:

print(type(42))
print(type("42"))
print(type(4.2))
print(type(42 > 7))
<class 'int'>
<class 'str'>
<class 'float'>
<class 'bool'>

42 og "42" ser like ut, men de er ikke det samme. Det første er et tall vi kan regne med, det andre er tekst. Med tekst betyr + å sette sammen, og * å gjenta:

print("5" + "3")
print(5 + 3)
print("ha" * 3)
53
8
hahaha

Hvilken type har verdiene, og hva skriver print ut?

  1. 7 / 2
  2. "7" + "2"
  3. 7 > 2
  4. "True"

Se etter anførselstegn og regneoperasjoner. Divisjon med / gir alltid et desimaltall.

print(7 / 2, type(7 / 2))
print("7" + "2", type("7" + "2"))
print(7 > 2, type(7 > 2))
print("True", type("True"))
3.5 <class 'float'>
72 <class 'str'>
True <class 'bool'>
True <class 'str'>
  1. 3.5 er en float. Divisjon med / gir alltid float, også når svaret går opp: 6 / 3 er 2.0.

  2. "72" er en str. Tekster settes sammen, de legges ikke sammen som tall.

  3. True er en bool.

  4. "True" er en str. Anførselstegnene gjør den til tekst, ikke til en bool.

Skrive ut og lese inn

Med print skriver programmet til skjermen. Du kan gi den flere verdier, skilt med komma. Mer fleksibelt er en f-streng: en tekst med f foran, der verdier i {} settes inn. Etter kolon kan du bestemme formatet, for eksempel antall desimaler med :.2f.

navn = "Kari"
poeng = 87
print(f"{navn} fikk {poeng} poeng")
print(f"Andel: {poeng / 100:.0%}")
Kari fikk 87 poeng
Andel: 87%

Med input spør programmet brukeren om noe. Svaret blir alltid en tekst, også når brukeren skriver et tall. Vil du regne med det, må du gjøre det om til et tall (mer om det i neste delkapittel):

navn = input("Hva heter du? ")
alder = int(input("Hvor gammel er du? "))
neste = alder + 1
print(f"Hei {navn}! Du blir {neste} år.")

Denne koden venter på brukeren, så den kan ikke kjøres i kodecellene i boka. Prøv den i VS Code.

Lag en kvittering for \(3\) brus til \(29{,}90\) kroner. Skriv ut antall og pris, og summen med to desimaler.

Lag variabler for pris og antall, og regn ut total. I f-strengen skriver du {pris:.2f} for to desimaler.

pris = 29.9
antall = 3
total = pris * antall
print(f"{antall} brus à {pris:.2f} kr")
print(f"Sum: {total:.2f} kr")
3 brus à 29.90 kr
Sum: 89.70 kr

:.2f runder av til to desimaler. Uten det hadde Python skrevet 89.69999999999999, fordi desimaltall lagres med liten unøyaktighet.

AdvarselVanlige feil
  • = betyr «får verdien», ikke «er lik». For å sammenligne bruker vi ==.
  • input gir alltid tekst. alder = input("Alder: ") gir "16", ikke \(16\), og alder + 1 gir en feilmelding.
  • "5" + 3 gir en feilmelding. Tekst og tall kan ikke settes sammen uten å gjøre om det ene.
  • Desimaltall skrives med punktum: 3.5, ikke 3,5.
  • Store og små bokstaver teller: Navn og navn er to variabler.
  • Et variabelnavn kan ikke starte med et tall og ikke ha mellomrom (2navn og mitt navn gir syntaksfeil).

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hva er verdiene til variablene etter at programmet har kjørt?

a = 4
b = a + 3
a = a * 2
c = a + b
Verdien av b
Verdien av a
Verdien av c

Hvilken datatype har hver av verdiene?

12

Se etter anførselstegn og desimalpunktum. Divisjon med / gir alltid float.

int

"12"

Se etter anførselstegn og desimalpunktum. Divisjon med / gir alltid float.

str (anførselstegn)

1.2

Se etter anførselstegn og desimalpunktum. Divisjon med / gir alltid float.

float

12 > 5

Se etter anførselstegn og desimalpunktum. Divisjon med / gir alltid float.

bool (True)

"ja" + "nei"

Se etter anførselstegn og desimalpunktum. Divisjon med / gir alltid float.

str ("janei")

10 / 5

Se etter anførselstegn og desimalpunktum. Divisjon med / gir alltid float.

float (2.0)

Nivå 2

Programmet har flere feil. Finn dem og forklar hva som er galt.

2navn = "Ola"
mitt navn = "Kari"
alder = 17
print(f"{Alder} år")

Gå linje for linje. Hva sier reglene for variabelnavn? Og hva med store og små bokstaver?

  • 2navn: et variabelnavn kan ikke starte med et tall. Bruk for eksempel navn_2.
  • mitt navn: navnet kan ikke ha mellomrom. Bruk mitt_navn.
  • {Alder}: variabelen heter alder med liten a. Alder finnes ikke, og gir NameError.

Programmet skal fortelle brukeren hvor gammel hen er neste år, men gir en feilmelding.

alder = input("Hvor gammel er du? ")
neste = alder + 1
print(f"Neste år er du {neste}.")

Hvilken feilmelding får du, og hvorfor?

Hva er datatypen til alder? Hva skjer når du prøver å legge \(1\) til en tekst?

TypeError: can only concatenate str (not "int") to str. input gir alltid tekst, og en tekst og et tall kan ikke legges sammen.

Rett programmet.

Hva er datatypen til alder? Hva skjer når du prøver å legge \(1\) til en tekst?

Gjør svaret om til et heltall med int:

alder = int(input("Hvor gammel er du? "))
neste = alder + 1
print(f"Neste år er du {neste}.")
alder = int(input("Hvor gammel er du? "))
neste = alder + 1
print(f"Neste år er du {neste}.")
Kodeoppgaver

Disse oppgavene rettes automatisk. Skriv koden i editoren og trykk Kjør. Står du fast, kan du trykke Vis hint.

En vare koster \(45\) kroner, og du kjøper \(4\) stykker. Regn ut totalprisen og lagre den i variabelen total.

Skriv total = pris * antall.

Variablene navn og poeng er laget. Skriv ut teksten Kari fikk 87 poeng med en f-streng.

En f-streng starter med f foran anførselstegnet. Variablene settes inn med {}.

Programmet skal regne ut hvor gammel Ola er neste år, men gir en feilmelding. Rett det slik at neste_ar blir \(17\).

"16" er tekst. Gjør den om til et heltall med int("16"), eller skriv 16 uten anførselstegn.

Utfordringer

Variablene a og b har verdiene \(3\) og \(8\). Bytt om slik at a blir \(8\) og b blir \(3\). Du skal bare bruke vanlige tilordninger, og trenger en ekstra variabel.

Skriver du a = b med en gang, mister du den gamle verdien av a. Lagre den først i en tredje variabel.

Temperaturen er \(25\) grader celsius. Regn ut temperaturen i fahrenheit med formelen \(F = C \cdot \frac{9}{5} + 32\), og lagre den i fahrenheit. Skriv ut 25 °C er 77.0 °F med en f-streng med én desimal.

Skriv fahrenheit = celsius * 9 / 5 + 32. I f-strengen gir :.1f én desimal.

Oppsummering

Variabler

antall = 3
antall = antall + 1

Datatyper

7          # int
3.14       # float
"hei"      # str
True       # bool
type(7)    # <class 'int'>

Skrive ut

print(f"{navn} er {alder} år")
print(f"{pris:.2f} kr")

Lese inn (alltid tekst)

tekst = input("Navn: ")
tall = int(input("Alder: "))
  • = betyr «får verdien». Sammenligning skrives ==.
  • input gir alltid tekst. Bruk int() eller float() for å regne med svaret.
  • Desimaltall skrives med punktum.

2.1.2 Operatorer og typekonvertering

Klassen har \(47\) elever, og du skal dele dem i grupper på \(5\). Hvor mange fulle grupper blir det, og hvor mange elever er til overs? Du kan regne det ut i hodet: \(9\) grupper, og \(2\) til overs. Python har egne operatorer for akkurat dette:

elever = 47
print(elever // 5)
print(elever % 5)
9
2

Her får vi \(9\) og \(2\). I dette delkapittelet ser vi på alle operatorene du trenger for å regne og sammenligne, og hvordan du gjør om en verdi fra én type til en annen.

Læringsmål

Etter dette delkapittelet skal du kunne

  • bruke de aritmetiske operatorene +, -, *, /, //, % og **, og vite hvilken som regnes ut først,
  • bruke += og de andre kortformene,
  • sammenligne verdier med ==, !=, <, >, <= og >=, og kombinere dem med and, or og not,
  • gjøre om mellom int, float og str, og forstå feilmeldingen når det går galt.

Regneoperatorer

Du kjenner +, - og * fra matematikken. Divisjon har tre varianter i Python:

RegelAritmetiske operatorer
Operator Betyr Eksempel
+ - * pluss, minus, ganger 3 * 4 gir 12
/ divisjon 7 / 2 gir 3.5
// heltallsdivisjon 7 // 2 gir 3
% rest 7 % 2 gir 1
** potens 2 ** 3 gir 8

Rekkefølgen er som i matematikken: først parenteser, så **, så * / // %, til slutt + og -.

Heltallsdivisjon // gir hvor mange ganger tallet går opp, og % gir resten. Sammen henger de slik: \(47 = 9 \cdot 5 + 2\). % er også en rask måte å sjekke om et tall er delelig på noe: er tall % 2 == 0, er tallet et partall.

For å legge til noe i en variabel finnes en kortform: antall += 1 betyr det samme som antall = antall + 1. Det samme gjelder -=, *= og /=.

Gjør \(135\) sekunder om til minutter og sekunder.

Antall hele minutter er \(135\) delt på \(60\) med heltallsdivisjon. Det som er til overs, er resten.

sekunder = 135
minutter = sekunder // 60
rest = sekunder % 60
print(f"{minutter} min og {rest} s")
2 min og 15 s

\(135 = 2 \cdot 60 + 15\), så svaret er \(2\) minutter og \(15\) sekunder.

Hva skriver programmet ut?

print(2 + 3 * 4)
print((2 + 3) * 4)
print(2 ** 3 ** 2)
print(10 - 4 - 3)

Gang går foran pluss, og parenteser går foran alt. For ** gjelder: det som står til høyre, regnes ut først.

print(2 + 3 * 4)
print((2 + 3) * 4)
print(2 ** 3 ** 2)
print(10 - 4 - 3)
14
20
512
3

2 + 3 * 4 er \(2 + 12 = 14\), og med parentes får vi \(5 \cdot 4 = 20\). 2 ** 3 ** 2 regnes fra høyre: \(3^2 = 9\), så \(2^9 = 512\). Minus regnes fra venstre mot høyre: \((10 - 4) - 3 = 3\).

Sammenligne og kombinere

En sammenligning gir svaret True eller False. Vi bruker dem til å la programmet velge, som du skal se i neste delkapittel.

RegelSammenligning og logiske operatorer
  • == lik, != ulik, < mindre enn, > større enn, <= mindre eller lik, >= større eller lik.
  • a and b er True bare når begge er sanne.
  • a or b er True når minst én er sann.
  • not a snur sant og usant.
alder = 17
print(alder >= 18)
print(alder > 12 and alder < 20)
print(not alder == 17)
False
True
False

Du kan skrive 12 < alder < 20 i stedet for alder > 12 and alder < 20. Python godtar kjeding av sammenligninger.

Skriv et uttrykk som er True når tall er et partall mellom \(10\) og \(50\), og sjekk for \(tall = 24\) og \(tall = 51\).

Du trenger tre betingelser som alle må være sanne: tallet er over \(10\), under \(50\), og delelig med \(2\).

for tall in [24, 51]:
    svar = 10 < tall < 50 and tall % 2 == 0
    print(tall, svar)
24 True
51 False

\(24\) er et partall mellom \(10\) og \(50\), så svaret er True. \(51\) er over \(50\) og et oddetall, så svaret er False.

Typekonvertering

Av og til har vi en verdi av én type, men trenger en annen. Med int(), float() og str() kan vi gjøre om verdien:

print(int("12") + 1)
print(float("3.5") * 2)
print(str(7) + " dager")
print(int(3.9))
13
7.0
7 dager
3

Merk at int(3.9) gir 3: desimalene kuttes bort, tallet rundes ikke av. For å runde av bruker vi round(): round(3.9) gir 4.

Ikke alt lar seg gjøre om. int("abc") og int("3.5") gir feilmeldingen ValueError, fordi teksten ikke ser ut som et heltall.

En bruker har skrevet inn "12" og "30" som tekst. Regn ut summen, og skriv den ut som tall.

Gjør begge tekstene om til heltall før du legger dem sammen. Hva ville "12" + "30" gitt?

a = "12"
b = "30"
print(a + b)
print(int(a) + int(b))
1230
42

"12" + "30" setter tekstene sammen til "1230". Etter int regner Python med tall, og vi får \(42\).

AdvarselVanlige feil
  • 7 / 2 gir 3.5, ikke 3. For heltallsdivisjon bruker vi //.
  • int(3.9) gir 3, ikke 4. Bruk round() for å runde av.
  • int("3.5") gir feilmelding. Gå via float: int(float("3.5")).
  • a = b setter verdien. a == b sammenligner.
  • x > 3 or 5 betyr ikke «x er større enn \(3\) eller \(5\)». Skriv x > 3 or x > 5.
  • Desimaltall kan gi små avvik. Sammenlign dem med round() i stedet for ==.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hva er verdien av uttrykkene?

17 // 5
17 % 5
2 + 3 * 4
(2 + 3) * 4
2 ** 5
20 / 8

Hvilke av uttrykkene er True?

7 > 3 and 2 > 5

Regn ut hver sammenligning for seg, og bruk så and, or og not. Husk at store og små bokstaver er ulike.

False. 7 > 3 er sant, men 2 > 5 er usant, og and krever begge.

7 > 3 or 2 > 5

Regn ut hver sammenligning for seg, og bruk så and, or og not. Husk at store og små bokstaver er ulike.

True. Det holder at én er sann.

not 7 > 3

Regn ut hver sammenligning for seg, og bruk så and, or og not. Husk at store og små bokstaver er ulike.

False. not snur True til False.

10 % 3 == 1

Regn ut hver sammenligning for seg, og bruk så and, or og not. Husk at store og små bokstaver er ulike.

True. \(10 = 3 \cdot 3 + 1\).

"a" == "A"

Regn ut hver sammenligning for seg, og bruk så and, or og not. Husk at store og små bokstaver er ulike.

False. Store og små bokstaver er ulike tegn.

Nivå 2
a = "4"
b = 4
print(a * 2)
print(b * 2)
print(int(a) + b)
print(str(b) + a)

a er en tekst og b er et tall. Hva betyr * for tekst?

44
8
8
44

"4" * 2 gjentar teksten og gir 44. 4 * 2 er \(8\). int("4") + 4 er \(8\). str(4) + "4" setter sammen to tekster og gir 44.

Programmet skal regne ut gjennomsnittet av to tall, men gir feil svar.

a = 8
b = 5
snitt = a + b / 2
print(snitt)

Hva skriver programmet ut, og hva burde det skrevet ut?

Se på rekkefølgen på regneoperasjonene. Hva regnes ut først, + eller /?

Programmet skriver 10.5, men gjennomsnittet av \(8\) og \(5\) er \(6{,}5\). Divisjon regnes ut før pluss, så b / 2 blir \(2{,}5\) og legges til \(8\).

Rett programmet.

Se på rekkefølgen på regneoperasjonene. Hva regnes ut først, + eller /?

Bruk parentes:

snitt = (a + b) / 2
snitt = (a + b) / 2
Kodeoppgaver

Disse oppgavene rettes automatisk. Skriv koden i editoren og trykk Kjør. Står du fast, kan du trykke Vis hint.

\(47\) elever skal deles i grupper på \(5\). Lagre antall fulle grupper i grupper og antall elever til overs i rest.

// gir antall hele ganger, og % gir resten.

Gjør \(4000\) sekunder om til timer, minutter og sekunder. Lagre svarene i timer, minutter og sekunder_igjen.

Start med timene: sekunder // 3600. Resten, sekunder % 3600, deler du videre i minutter og sekunder.

Rett programmet slik at snitt blir \(6{,}5\).

Du vil legge sammen først og så dele. Sett parentes rundt a + b.

Variabelen aar er \(2024\). Lagre True i skuddaar hvis det er et skuddår, ellers False. Et år er skuddår hvis det er delelig med \(4\), men ikke med \(100\), med mindre det er delelig med \(400\).

Skriv (aar % 4 == 0 and aar % 100 != 0) or aar % 400 == 0.

Utfordringer

Tallet n er \(5731\). Lagre siste siffer i siste og tallet uten siste siffer i resten_av_tallet. Du skal ikke gjøre tallet om til tekst.

n % 10 gir det siste sifferet, og n // 10 fjerner det.

Hvorfor er det lurt å være forsiktig med == mellom desimaltall? Prøv 0.1 + 0.2 == 0.3, og foreslå en bedre måte å sammenligne på.

0.1 + 0.2 == 0.3 er False, fordi 0.1 + 0.2 er 0.30000000000000004. Datamaskiner lagrer desimaltall som totall, og \(0{,}1\) kan ikke skrives nøyaktig som et endelig totall, på samme måte som \(\frac{1}{3}\) ikke kan skrives nøyaktig som et endelig desimaltall. En bedre måte er å runde av begge sider til ønsket antall desimaler før vi sammenligner: round(0.1 + 0.2, 2) == round(0.3, 2) er True. Alternativt kan vi sjekke at differansen er veldig liten: abs(a - b) < 0.000001.

Oppsummering

Regneoperatorer

7 / 2    # 3.5
7 // 2   # 3
7 % 2    # 1
2 ** 3   # 8
x += 1   # x = x + 1

Sammenligning

a == b    a != b
a < b     a <= b
a > b     a >= b

Logiske operatorer

a and b    # begge sanne
a or b     # minst én sann
not a      # snur

Typekonvertering

int("12")     # 12
float("3.5")  # 3.5
str(7)        # "7"
round(3.7)    # 4
  • // gir hvor mange ganger det går opp, og % gir resten. tall % 2 == 0 betyr partall.
  • int(3.9) gir 3. Bruk round() for å runde av.
  • Sammenlign ikke desimaltall med ==.

2.2 Valg og løkker

Et program som alltid gjør det samme, er lite nyttig. Her lærer du å la programmet velge hva det skal gjøre, og å gjenta noe mange ganger.

2.2.1 Valg med if

På kinoen koster en billett \(60\) kroner for barn under \(12\) år og \(120\) kroner for alle andre. Kassa må velge pris ut fra alderen. Slike valg er det alle programmer gjør hele tiden: Er passordet riktig? Traff skuddet? Er det flere liv igjen? I Python gjør vi det med if:

alder = 10
if alder < 12:
    pris = 60
else:
    pris = 120
print(pris)
60

Endrer du alder til \(30\), skriver programmet ut \(120\) i stedet. Koden er den samme, men programmet velger ulikt etter hva som er sant.

Læringsmål

Etter dette delkapittelet skal du kunne

  • bruke if, elif og else til å la programmet velge mellom flere veier,
  • skrive betingelser med sammenligninger og and, or og not,
  • forklare hvorfor rekkefølgen på elif har betydning,
  • finne og rette vanlige feil i valgsetninger.

if og else

En if-setning har en betingelse, et uttrykk som er True eller False, og en kodeblokk som bare kjøres hvis betingelsen er sann. Blokken er de linjene som har innrykk (fire mellomrom) under if. else er kodeblokken som kjøres når betingelsen er usann.

Definisjonif og else
if betingelse:
    # kjøres hvis betingelsen er sann
else:
    # kjøres ellers

Husk kolon etter betingelsen og etter else. Innrykket bestemmer hva som hører til. else er valgfri.

Programmet skal skrive Velkommen hvis svar er lik "hemmelig", og Feil passord ellers.

Sammenligningen skrives med ==, ikke =.

svar = "hemmelig"
if svar == "hemmelig":
    print("Velkommen")
else:
    print("Feil passord")
Velkommen

Prøv å endre svar til noe annet. Da kjøres else-blokken i stedet.

Flere valg med elif

Trenger vi flere enn to veier, bruker vi elif (kort for «else if»). Python sjekker betingelsene ovenfra og ned, og kjører den første blokken der betingelsen er sann. Resten hoppes over.

poeng = 78
if poeng >= 90:
    print("A")
elif poeng >= 75:
    print("B")
elif poeng >= 60:
    print("C")
else:
    print("D")
B

Siden \(78 \geq 90\) er usant, men \(78 \geq 75\) er sant, skriver programmet ut B. Python ser aldri på poeng >= 60, selv om den også er sann. Derfor må vi sette de strengeste betingelsene først.

RegelRekkefølgen på elif

Betingelsene sjekkes ovenfra og ned, og bare den første blokken som passer, kjøres. Sett derfor den mest spesifikke betingelsen først.

Hva skriver programmet ut for \(poeng = 78\), når betingelsene står i omvendt rekkefølge?

poeng = 78
if poeng >= 60:
    print("C")
elif poeng >= 75:
    print("B")
elif poeng >= 90:
    print("A")

Hvilken betingelse sjekkes først, og er den sann?

poeng = 78
if poeng >= 60:
    print("C")
elif poeng >= 75:
    print("B")
elif poeng >= 90:
    print("A")
C

Programmet skriver C. Første betingelse, poeng >= 60, er sann, så den blokken kjøres, og de andre sjekkes aldri. Slik blir også \(95\) og \(80\) gitt C.

Kombinere betingelser

Med and, or og not kan vi sette sammen flere betingelser. Du kan også la en if ligge inni en annen, men da blir koden fort uoversiktlig. Oftest er det enklere å bruke and.

alder = 70
student = False
if alder < 12 or alder >= 67 or student:
    print("Rabatt")
else:
    print("Full pris")
Rabatt

Her får du rabatt hvis du er under \(12\), minst \(67\) eller student. Siden student allerede er True eller False, trenger vi ikke skrive student == True.

Du kan ta sertifikat på personbil fra du er \(18\), og på moped fra du er \(16\). Skriv et program som skriver ut Bil, Moped eller Ingen ut fra alder.

Sjekk den strengeste betingelsen først. En som er \(20\), oppfyller også kravet til moped.

alder = 17
if alder >= 18:
    print("Bil")
elif alder >= 16:
    print("Moped")
else:
    print("Ingen")
Moped

For \(alder = 17\) skriver programmet Moped. Hadde vi sjekket alder >= 16 først, ville en \(20\)-åring fått Moped i stedet for Bil.

AdvarselVanlige feil
  • if x = 5: er en syntaksfeil. Sammenligning skrives ==.
  • Glemt kolon etter if, elif eller else gir syntaksfeil.
  • Glemt innrykk, eller ulikt innrykk, gir IndentationError.
  • if x == 1 or 2: betyr ikke «x er \(1\) eller \(2\)». Skriv if x == 1 or x == 2:.
  • Rekkefølgen på elif er viktig. Den første sanne betingelsen vinner.
  • To if etter hverandre er uavhengige valg. Bare elif og else hører sammen med if-en over.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hva skriver programmet ut for hver verdi av x?

if x > 20:
    print("A")
elif x > 10:
    print("B")
elif x > 5:
    print("C")
else:
    print("D")
\(x = 15\)

Gå ovenfra og ned, og stopp ved den første betingelsen som er sann. Husk at \(10 > 10\) er usant.

B

\(x = 7\)

Gå ovenfra og ned, og stopp ved den første betingelsen som er sann. Husk at \(10 > 10\) er usant.

C

\(x = 3\)

Gå ovenfra og ned, og stopp ved den første betingelsen som er sann. Husk at \(10 > 10\) er usant.

D

\(x = 25\)

Gå ovenfra og ned, og stopp ved den første betingelsen som er sann. Husk at \(10 > 10\) er usant.

A

\(x = 10\)

Gå ovenfra og ned, og stopp ved den første betingelsen som er sann. Husk at \(10 > 10\) er usant.

C. \(10 > 20\) og \(10 > 10\) er usanne, men \(10 > 5\) er sann.

Hvor mange linjer skriver programmet ut?

tall = 12
if tall % 2 == 0:
    print("partall")
if tall > 10:
    print("stort")
if tall > 20:
    print("veldig stort")
else:
    print("ikke veldig stort")
Nivå 2

Programmet skal gi A fra \(80\) poeng, B fra \(60\), C fra \(40\) og D ellers. Men for \(poeng = 85\) skriver det C.

poeng = 85
if poeng >= 40:
    print("C")
elif poeng >= 60:
    print("B")
elif poeng >= 80:
    print("A")
else:
    print("D")

Forklar hvorfor programmet skriver C.

Hvilken betingelse sjekkes først? Er den sann for \(85\)?

Den første betingelsen poeng >= 40 er sann for \(85\), så C skrives ut. De andre betingelsene sjekkes aldri.

Rett programmet.

Hvilken betingelse sjekkes først? Er den sann for \(85\)?

Sett den strengeste betingelsen først:

if poeng >= 80:
    print("A")
elif poeng >= 60:
    print("B")
elif poeng >= 40:
    print("C")
else:
    print("D")
if poeng >= 80:
    print("A")
elif poeng >= 60:
    print("B")
elif poeng >= 40:
    print("C")
else:
    print("D")

Programmet skal skrive Valg ok hvis svar er "a" eller "b", men skriver det alltid.

svar = "x"
if svar == "a" or "b":
    print("Valg ok")

Forklar feilen og rett den.

Hva er betingelsen på hver side av or? Er "b" alene sann eller usann?

"b" alene er en tekst som ikke er tom, og slike tekster regnes som sanne. Derfor er hele betingelsen alltid sann. Riktig er å sammenligne begge sider:

if svar == "a" or svar == "b":
    print("Valg ok")

Det finnes også en kortere måte: if svar in ["a", "b"]:.

Kodeoppgaver

Disse oppgavene rettes automatisk. Skriv koden i editoren og trykk Kjør. Programmene kjøres for flere verdier, slik at du kan teste grensetilfellene.

Billetten koster \(60\) kroner for barn under \(12\), \(80\) kroner for dem som er \(67\) eller eldre, og \(120\) kroner for alle andre. Programmet går gjennom flere aldre. Skriv if-setningene som skriver ut alder og pris.

Lag en variabel pris i hver gren. Betingelsene er alder < 12, alder >= 67 og ellers.

Gi bokstavkarakter: A fra \(90\) poeng, B fra \(75\), C fra \(60\), D fra \(50\) og E ellers. Skriv ut karakteren for hver poengsum.

Start med if poeng >= 90:, fortsett med elif nedover, og avslutt med else.

Programmet skal skrive Bil for \(18\) år og eldre, Moped fra \(16\), og Ingen ellers. Rett rekkefølgen.

En \(40\)-åring oppfyller begge betingelsene. Hvilken skal vinne?

Utfordringer

Skriv ut tallene fra \(1\) til \(15\), ett på hver linje, men skriv Fizz i stedet for tall som er delelige med \(3\), Buzz for tall delelige med \(5\), og FizzBuzz for tall delelige med begge.

Tallet \(15\) skal gi FizzBuzz, ikke bare Fizz. Sjekk derfor betingelsen for både \(3\) og \(5\) først.

Er det mulig å bestemme hvilket av tre tall som er størst uten å bruke max? Forklar hvordan du ville skrevet en if-kjede som finner det største av a, b og c.

Hvis a er større enn eller lik både b og c, er a størst. Ellers, hvis b er større enn eller lik c, er b størst. Ellers er c størst:

if a >= b and a >= c:
    storst = a
elif b >= c:
    storst = b
else:
    storst = c

Det andre valget trenger ikke å sjekke a igjen, for vi vet allerede at a ikke er størst. Dette blir tungvint for mange tall. Med en liste og en løkke (neste delkapittel) er det enklere.

Oppsummering

if og else

if alder < 12:
    pris = 60
else:
    pris = 120

elif

if poeng >= 90:
    print("A")
elif poeng >= 60:
    print("B")
else:
    print("C")

Kombinere betingelser

if a > 0 and b > 0:
if a > 0 or b > 0:
if not a > 0:

Tilhører en av to

if svar in ["a", "b"]:
  • Kolon etter if, elif og else, og innrykk på blokken.
  • Første sanne betingelse vinner. Sett den strengeste først.
  • Sammenligning er ==. = gir en variabel en verdi.

2.2.2 Løkker med for og while

Skal du skrive ut gangetabellen til 7 med det du kan fra før, må du skrive ti nesten like linjer:

print(1 * 7)
print(2 * 7)
print(3 * 7)
# ... og sju linjer til

Med en løkke skriver du linja én gang og ber Python gjenta den:

for i in range(1, 11):
    print(i * 7)

Det er ikke bare mindre å skrive. Vil du ha gangetabellen til 100 i stedet for til 10, endrer du ett tall.

Noen ganger vet vi ikke på forhånd hvor mange ganger noe skal gjentas. Sparer du 350 kroner i måneden til en PC, sparer du til du har nok, ikke et bestemt antall måneder. Spillet i prosjekt P1 er et annet eksempel: det tegner skjermen på nytt igjen og igjen så lenge spillet er i gang. Python har to løkker for de to situasjonene: for og while.

Læringsmål

Etter dette delkapittelet skal du kunne

  • bruke for-løkker over range og tekststrenger, og forklare hvilke tall range(start, stopp, steg) gir,
  • telle og summere i en løkke med en tellervariabel,
  • bruke while-løkker når antall runder ikke er kjent, og unngå uendelige løkker,
  • avbryte en løkke med break og hoppe over en runde med continue,
  • velge mellom for og while, og lese, rette og skrive programmer med løkker.

for-løkker og range

En for-løkke går gjennom en sekvens, ett element om gangen, og kjører den samme koden for hvert element. En tekststreng er en sekvens av tegn:

for bokstav in "IT2":
    print(bokstav)
I
T
2

Linja print(bokstav) kjøres tre ganger. I første runde er bokstav lik "I", i andre runde "T" og i tredje runde "2". Det er innrykket som bestemmer hva som hører til løkka. Alt som står med innrykk under for-linja, kjøres i hver runde, og koden etter løkka kjøres én gang når løkka er ferdig.

Definisjonfor-løkke
for element in sekvens:
    # kode som kjøres for hvert element

Løkkevariabelen (her element) får verdien til neste element i sekvensen i hver runde. Koden med innrykk under for-linja kalles løkkekroppen.

Oftest vil vi gjenta noe et bestemt antall ganger, eller gå gjennom en tallrekke. Da bruker vi range. range(5) gir tallene \(0, 1, 2, 3, 4\). Tallrekka starter på \(0\) og stopper før \(5\). Det kan virke rart, men gjør det lett å telle: range(5) gir nøyaktig \(5\) tall. På samme måte gir range(1, 6) tallene \(1, 2, 3, 4, 5\), altså \(6 - 1 = 5\) tall.

Med et tredje tall bestemmer vi steget, hvor mye tallet øker for hver runde. Et negativt steg teller nedover:

for tall in range(10, 0, -2):
    print(tall)
10
8
6
4
2

Også her er stoppverdien \(0\) ikke med.

Regelrange
Kode Tallene
range(stopp) \(0, 1, \ldots, \text{stopp} - 1\)
range(start, stopp) \(\text{start}, \ldots, \text{stopp} - 1\)
range(start, stopp, steg) \(\text{start}, \text{start} + \text{steg}, \ldots\)

Stoppverdien er aldri med. Med negativt steg teller range nedover.

Skriv et program som skriver ut gangetabellen til 7 fra \(1 \cdot 7\) til \(10 \cdot 7\), på formen 3 · 7 = 21.

Bruk range(1, 11), siden stoppverdien ikke er med. En f-streng lar deg sette verdiene inn i teksten.

for i in range(1, 11):
    print(f"{i} · 7 = {i * 7}")
1 · 7 = 7
2 · 7 = 14
3 · 7 = 21
4 · 7 = 28
5 · 7 = 35
6 · 7 = 42
7 · 7 = 49
8 · 7 = 56
9 · 7 = 63
10 · 7 = 70

Skal tabellen gå til \(100 \cdot 7\), endrer vi bare 11 til 101.

Skriv opp tallene, og hvor mange ganger en for-løkke over tallrekka kjører.

  1. range(2, 15, 4)
  2. range(5, 0, -1)
  3. range(3, 3)

Start på startverdien og legg til steget til du kommer til stoppverdien. Stoppverdien er ikke med.

  1. \(2, 6, 10, 14\). Neste tall ville vært \(18\), som er forbi \(15\). Løkka kjører \(4\) ganger.

  2. \(5, 4, 3, 2, 1\). Stoppverdien \(0\) er ikke med. Løkka kjører \(5\) ganger.

  3. Ingen tall. Tallrekka stopper før \(3\), så den er tom, og løkka kjører \(0\) ganger.

Du kan sjekke med print(list(range(2, 15, 4))).

Telle og summere

Hva er summen \(1 + 2 + 3 + \ldots + 100\)? Vi kan la en løkke legge sammen tallene, ett om gangen, i en variabel som holder delsummen. Variabelen må ha en startverdi før løkka, ellers har vi ingenting å legge til:

summen = 0
for tall in range(1, 101):
    summen += tall
print(summen)
5050

summen += tall er en kortform for summen = summen + tall. For å se hva som skjer, kan vi følge variablene runde for runde i en sporingstabell:

Runde tall summen etter runden
før løkka – \(0\)
1 \(1\) \(1\)
2 \(2\) \(3\)
3 \(3\) \(6\)
… … …
100 \(100\) \(5050\)

print(summen) står uten innrykk, så den kjøres én gang, etter at løkka er ferdig.

RegelTelle og summere i en løkke
antall = 0
summen = 0
for x in sekvens:
    antall += 1
    summen += x
print(antall, summen)

Start før løkka, oppdater i løkka, bruk resultatet etter løkka.

Skriv et program som teller hvor mange vokaler det er i ordet "programmering".

Gå gjennom ordet bokstav for bokstav. bokstav in "aeiouyæøå" er True når bokstaven er en vokal.

tekst = "programmering"
antall = 0
for bokstav in tekst:
    if bokstav in "aeiouyæøå":
        antall += 1
print(antall)
4

Vokalene er o, a, e og i. if-setningen står inne i løkka, så den sjekkes for hver bokstav, og antall øker bare når bokstaven er en vokal.

while-løkker

En while-løkke kjører så lenge en betingelse er sann. Den passer når vi ikke vet hvor mange runder det blir. Sett at du har \(1000\) kroner i banken med \(5\) % rente i året. Hvor mange år tar det før pengene er doblet?

belop = 1000
ar = 0
while belop < 2000:
    belop = belop * 1.05
    ar += 1
print(ar)
15

Før hver runde sjekker Python om belop < 2000. Er betingelsen sann, kjøres løkkekroppen, og så sjekkes betingelsen på nytt. Når beløpet har passert \(2000\), er betingelsen usann, og programmet fortsetter etter løkka.

Det er viktig at løkkekroppen endrer noe i betingelsen. Glemmer vi linja belop = belop * 1.05, er belop < 2000 alltid sann, og løkka går for alltid. Det kalles en uendelig løkke. Programmet ser ut til å henge, og i terminalen i VS Code stopper du det med Ctrl+C.

Definisjonwhile-løkke
while betingelse:
    # kode som kjøres så lenge
    # betingelsen er sann

Betingelsen sjekkes før hver runde. Løkkekroppen må endre noe som betingelsen avhenger av, ellers stopper løkka aldri.

Alt en for-løkke over range gjør, kan også gjøres med while. Disse to skriver ut det samme:

for i in range(1, 4):
    print(i)
i = 1
while i < 4:
    print(i)
    i += 1

for-løkka er kortere og kan ikke bli uendelig. Derfor velger vi for når vi kan.

Regelfor eller while?
  • for når du vet hvor mange runder det blir, eller skal gå gjennom en sekvens.
  • while når løkka skal gå til noe skjer, og du ikke vet når.

Du deler tallet \(1000\) på \(2\) igjen og igjen. Hvor mange ganger må du dele før tallet blir mindre enn \(1\)? Skriv et program som finner svaret.

Vi vet ikke hvor mange ganger, så bruk while. Hva skal betingelsen være så lenge vi fortsetter å dele?

tall = 1000
antall = 0
while tall >= 1:
    tall = tall / 2
    antall += 1
print(antall, tall)
10 0.9765625

Etter \(10\) halveringer er tallet \(0{,}977\), som er mindre enn \(1\). Vi fortsetter så lenge tall >= 1, altså det motsatte av når vi skal stoppe.

break og continue

Noen ganger vil vi avslutte en løkke før den er ferdig. break avslutter løkka med en gang, og programmet fortsetter etter løkka. Programmet under finner det første tallet over \(100\) som er delelig med \(7\):

for tall in range(101, 1000):
    if tall % 7 == 0:
        print(tall)
        break
105

Uten break ville løkka fortsatt og skrevet ut alle tallene i sjutabellen mellom \(100\) og \(1000\).

continue hopper over resten av løkkekroppen og går rett til neste runde. Her hopper vi over tallene som er delelige med \(3\):

for tall in range(1, 8):
    if tall % 3 == 0:
        continue
    print(tall)
1
2
4
5
7
Notewhile True

while True er en løkke som bare stopper med break. Den er vanlig når programmet skal spørre brukeren til svaret er gyldig:

while True:
    tekst = input("Alder: ")
    if tekst.isdigit():
        break
    print("Skriv et heltall.")
alder = int(tekst)

tekst.isdigit() er True når teksten bare består av sifre.

Spillløkka i P1 virker på samme måte: den går til spilleren lukker vinduet.

Finn det første kvadrattallet (\(1, 4, 9, 16, \ldots\)) som er større enn \(500\), med en for-løkke og break.

Gå gjennom \(n = 1, 2, 3, \ldots\) og regn ut n * n. Stopp når kvadratet er større enn \(500\). Velg en stoppverdi for range som er stor nok.

for n in range(1, 100):
    if n * n > 500:
        print(n, n * n)
        break
23 529

\(22^2 = 484\) er for lite, så svaret er \(23^2 = 529\). Oppgaven kan også løses med while n * n <= 500, uten break.

AdvarselVanlige feil
  • Stoppverdien er ikke med: range(1, 10) går fra \(1\) til \(9\).
  • En while-løkke som ikke endrer variabelen i betingelsen, stopper aldri.
  • Startverdien skal stå før løkka. summen = 0 inne i løkka nullstiller summen i hver runde.
  • Innrykket bestemmer hva som hører til løkka. En print med innrykk kjøres i hver runde, en print uten innrykk én gang etterpå.
  • = gir variabelen en ny verdi, += legger til. antall = 1 i en løkke teller ikke.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hvor mange ganger kjører en for-løkke over tallrekka?

range(10)
range(1, 10)
range(0, 20, 5)
range(10, 0, -1)
range(5, 5)

Hva blir utskriften fra hvert av programmene?

Bokstaver

for tegn in "Hei!":
    print(tegn)

Lag en liste over verdiene løkkevariabelen får, og hva som skrives ut i hver runde. Det som står uten innrykk etter løkka, kjøres én gang.

H
e
i
!
H
e
i
!

Doble tall

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

Lag en liste over verdiene løkkevariabelen får, og hva som skrives ut i hver runde. Det som står uten innrykk etter løkka, kjøres én gang.

0
2
4
6
0
2
4
6

Nedtelling

for i in range(9, 0, -3):
    print(i)
print("Ferdig")

Lag en liste over verdiene løkkevariabelen får, og hva som skrives ut i hver runde. Det som står uten innrykk etter løkka, kjøres én gang.

9
6
3
Ferdig

I c) stopper tallrekka før \(0\), og "Ferdig" skrives ut én gang etter løkka.

9
6
3
Ferdig

I c) stopper tallrekka før \(0\), og "Ferdig" skrives ut én gang etter løkka.

Hva er verdien av variabelen etter at programmet har kjørt?

Verdien av total

total = 0
for i in range(1, 5):
    total += i

Verdien av produkt

produkt = 1
for i in range(1, 5):
    produkt *= i

Verdien av n

n = 1
while n < 50:
    n = n * 3
Nivå 2

Programmet skal regne ut \(1 + 2 + 3 + 4 + 5 = 15\).

for tall in range(1, 6):
    summen = 0
    summen += tall
print(summen)

Hva skriver programmet ut?

Forklar feilen og rett programmet.

Programmet skal telle ned fra \(10\) til \(1\) og så skrive Takeoff!. Men det stopper aldri.

teller = 10
while teller > 0:
    print(teller)
print("Takeoff!")

Forklar hvorfor, og rett programmet.

Hva er verdien av teller i andre runde? Og i tredje?

teller endres aldri i løkka, så teller > 0 er alltid sann, og programmet skriver ut 10 igjen og igjen. Løkka må gjøre teller mindre i hver runde:

teller = 10
while teller > 0:
    print(teller)
    teller -= 1
print("Takeoff!")

Her passer også en for-løkke, siden vi vet hvor mange runder det blir: for teller in range(10, 0, -1).

Skriv om programmet med en while-løkke, slik at utskriften blir den samme.

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

Du trenger en variabel med startverdien, en betingelse som sier når løkka skal fortsette, og en linje som legger til steget.

i = 2
while i < 11:
    print(i)
    i += 2

Begge skriver ut \(2, 4, 6, 8, 10\). Betingelsen kan også være i <= 10.

Hva blir utskriften?

for rad in range(1, 4):
    linje = ""
    for kol in range(rad):
        linje += "*"
    print(linje)

Den indre løkka kjører helt ferdig i hver runde av den ytre løkka. Hvor mange ganger kjører den indre løkka når rad er \(1\), \(2\) og \(3\)?

*
**
***

For hver verdi av rad starter linje som en tom tekst, og den indre løkka legger til rad stjerner. Så skrives linja ut.

Hva blir utskriften?

for tall in range(1, 10):
    if tall % 3 == 0:
        continue
    if tall > 7:
        break
    print(tall)

Gå gjennom tallene \(1, 2, \ldots\) ett om gangen. Hva skjer når tallet er delelig med \(3\)? Hva skjer med \(8\)?

1
2
4
5
7

\(3\) og \(6\) hoppes over med continue. Når tall er \(8\), er tall > 7 sann, og break avslutter løkka, så \(8\) og \(9\) skrives ikke ut.

Kodeoppgaver

Disse oppgavene rettes automatisk. Skriv koden i editoren og trykk Kjør. Står du fast, kan du trykke Vis hint.

Skriv et program som skriver ut partallene fra \(100\) ned til og med \(80\) på én linje, med mellomrom mellom:

100 98 96 94 92 90 88 86 84 82 80

print(tall, end=" ") skriver ut et tall uten å gå til ny linje.

Bruk range(100, ?, -2). Stoppverdien er ikke med, så den må være litt mindre enn \(80\).

Regn ut summen \(1^2 + 2^2 + 3^2 + \ldots + 10^2\) med en løkke, og lagre den i variabelen summen. Du skal ikke bruke sum().

Gå gjennom tallene \(1\) til \(10\) med range(1, 11), og legg til tall * tall i hver runde.

Programmet skal telle vokalene i "programmering", men skriver ut 1. Finn feilen og rett den.

Hva er forskjellen på antall = 1 og antall += 1?

Du har \(2000\) kroner og sparer \(350\) kroner i måneden. PC-en du vil ha, koster \(8999\) kroner. Skriv et program som finner hvor mange måneder det tar før du har råd. Lagre antall måneder i maneder og pengene du har da, i penger. Bruk en while-løkke.

Betingelsen er penger < 8999. I hver runde legger du til \(350\) i penger og \(1\) i maneder.

Utfordringer

Start med et positivt heltall \(n\). Er \(n\) et partall, deler du det på \(2\). Er det et oddetall, ganger du med \(3\) og legger til \(1\). Gjenta til du kommer til \(1\). Starter du med \(6\), får du

\[ 6 \to 3 \to 10 \to 5 \to 16 \to 8 \to 4 \to 2 \to 1, \]

som er \(8\) steg. Ingen har klart å bevise at følgen alltid ender på \(1\), men det er sjekket for alle tall opp til over \(10^{20}\).

Skriv et program som finner hvor mange steg det tar fra \(n = 27\) til \(1\). Lagre svaret i steg.

Bruk while n != 1. Med n % 2 == 0 sjekker du om n er et partall, og n // 2 deler uten å gi desimaltall.

Fibonaccitallene starter med \(0\) og \(1\), og hvert nye tall er summen av de to foregående: \(0, 1, 1, 2, 3, 5, 8, \ldots\) Skriv et program som skriver ut alle Fibonaccitallene under \(1000\) på én linje, med mellomrom mellom.

Ha to variabler, a = 0 og b = 1, for de to siste tallene. Skriv ut a så lenge a < 1000, og flytt så begge ett steg fram: a, b = b, a + b.

Forklar hvorfor alle for-løkker over range kan skrives om til while-løkker.

En for-løkke over range(start, stopp, steg) kan skrives med en tellervariabel som starter på start, en betingelse i < stopp (eller i > stopp med negativt steg), og i += steg sist i løkka.

Kan alle while-løkker skrives om til for-løkker over range? Bruk Collatz-følgen som eksempel.

Nei, ikke uten videre. range trenger en stoppverdi, og for en while-løkke vet vi ofte ikke på forhånd hvor mange runder det blir. For Collatz-følgen vet vi ikke hvor mange steg det tar før vi har regnet det ut, og ingen vet engang om følgen alltid ender. Vi kan bruke en for-løkke med en stor stoppverdi og break, men da må vi gjette en grense som er stor nok. Derfor er while det naturlige valget.

Oppsummering

for-løkke over en sekvens

for bokstav in "IT2":
    print(bokstav)

range

range(5)         # 0–4
range(1, 6)      # 1–5
range(9, 0, -3)  # 9, 6, 3

Telle og summere

summen = 0
for tall in range(1, 101):
    summen += tall

while-løkke

while belop < 2000:
    belop = belop * 1.05
    ar += 1

break og continue

for tall in range(1, 100):
    if tall % 3 == 0:
        continue  # neste runde
    if tall > 50:
        break     # avslutt løkka

for eller while?

for: kjent antall runder eller en sekvens.

while: til noe skjer.

  • Stoppverdien i range er aldri med.
  • En while-løkke må endre noe i betingelsen, ellers stopper den aldri.
  • Startverdien til en sum eller teller settes før løkka.

2.3 Lister, tupler og ordbøker

Så langt har hver variabel hatt én verdi. Ofte trenger vi å holde styr på mange verdier samtidig: alle karakterene dine, alle elevene i klassen. Da bruker vi samlinger.

2.3.1 Lister

Du vil regne ut gjennomsnittet av karakterene dine i fem fag. Med variabler måtte du laget karakter1, karakter2 og så videre. Det går for fem, men ikke for hundre. En liste samler verdiene under ett navn:

karakterer = [4, 5, 3, 6, 4]
print(len(karakterer))
print(sum(karakterer) / len(karakterer))
5
4.4

Lista kan ha like mange elementer som du vil, og de samme linjene regner ut gjennomsnittet uansett hvor mange det er.

Læringsmål

Etter dette delkapittelet skal du kunne

  • lage lister, hente ut og endre elementer med indekser (også negative), og skjære ut deler av en liste,
  • legge til, fjerne og sortere elementer med listemetodene,
  • gå gjennom en liste med for, og bruke len, sum, min og max,
  • unngå de vanligste feilene: IndexError, sort som gir None, og to navn på samme liste.

Lage lister og hente ut elementer

En liste skrives med hakeparenteser og komma mellom elementene. Hvert element har en indeks, en plass i lista. Indeksene starter på \(0\).

DefinisjonListe

En liste er en ordnet samling av verdier som kan endres. Elementene kan ha ulike typer, men oftest har de samme type.

navn = ["Ola", "Kari", "Per"]

Med navn[0] får vi "Ola", og len(navn) er antall elementer.

Indekser kan også være negative: navn[-1] er det siste elementet, navn[-2] det nest siste.

tall = [4, 8, 15, 16, 23, 42]
print(tall[0], tall[2], tall[-1])
tall[1] = 80
print(tall)
4 15 42
[4, 80, 15, 16, 23, 42]

Med skjæring henter vi ut en del av lista: tall[a:b] gir elementene fra indeks a til, men ikke med, indeks b.

tall = [4, 8, 15, 16, 23, 42]
print(tall[1:4])
print(tall[:2])
print(tall[::2])
print(tall[::-1])
[8, 15, 16]
[4, 8]
[4, 15, 23]
[42, 23, 16, 15, 8, 4]

Utelater du a, starter den på begynnelsen, og utelater du b, går den til slutten. Tredje tall er steget, og et negativt steg snur lista.

La tall = [10, 20, 30, 40, 50]. Hva er verdien av uttrykkene?

  1. tall[1]
  2. tall[-2]
  3. tall[1:3]
  4. tall[3:]
  5. len(tall)

Tell fra \(0\). Ved skjæring er den siste indeksen ikke med.

tall = [10, 20, 30, 40, 50]
print(tall[1], tall[-2], len(tall))
print(tall[1:3], tall[3:])
20 40 5
[20, 30] [40, 50]
  1. 20

  2. 40, det nest siste elementet

  3. [20, 30]. Indeks \(1\) og \(2\), men ikke \(3\).

  4. [40, 50]. Fra indeks \(3\) til slutten.

  5. 5

Endre lister

Lister kan endres underveis. Disse metodene bruker du mest:

RegelListemetoder
  • liste.append(x) legger x til sist.
  • liste.insert(i, x) setter x inn på plass i.
  • liste.remove(x) fjerner første x.
  • liste.pop(i) fjerner og gir tilbake elementet på plass i (uten i: det siste).
  • liste.sort() sorterer lista på plass, og sorted(liste) gir en ny, sortert liste.
  • liste.reverse() snur lista.
  • x in liste er True hvis x finnes i lista.
handleliste = ["melk", "brød"]
handleliste.append("egg")
handleliste.insert(0, "ost")
handleliste.remove("brød")
print(handleliste)
print("egg" in handleliste)
['ost', 'melk', 'egg']
True

Du kan også bruke len, sum, min og max på tall:

tall = [3, 17, 8, 42, 5]
print(len(tall), sum(tall))
print(min(tall), max(tall))
5 75
3 42

Følg lista gjennom programmet.

liste = [5, 3, 8]
liste.append(1)
liste.insert(1, 9)
liste.remove(3)
liste.sort()

Skriv opp lista etter hver linje.

liste = [5, 3, 8]
liste.append(1)
print(liste)
liste.insert(1, 9)
print(liste)
liste.remove(3)
print(liste)
liste.sort()
print(liste)
[5, 3, 8, 1]
[5, 9, 3, 8, 1]
[5, 9, 8, 1]
[1, 5, 8, 9]

Til slutt er lista [1, 5, 8, 9].

Gå gjennom lister

En for-løkke går gjennom elementene i en liste, ett om gangen:

tall = [3, 17, 8, 42, 5]
storste = tall[0]
for x in tall:
    if x > storste:
        storste = x
print(storste)
42

Programmet starter med det første elementet som det største så langt, og bytter ut verdien hver gang det finner et større. Dette er det samme som max(tall), men viser hva max gjør.

Vi kan også bygge en ny liste mens vi går gjennom en annen. Start med en tom liste, og legg til elementer med append:

tall = [1, 2, 3, 4, 5, 6]
partall = []
for x in tall:
    if x % 2 == 0:
        partall.append(x)
print(partall)
[2, 4, 6]

Lista poeng = [60, 85, 70, 95, 40] har poengene til fem elever. Finn gjennomsnittet, og lag en liste med dem som ligger over snittet.

Gjennomsnittet er summen delt på antallet. Gå så gjennom lista og legg til dem som er større enn gjennomsnittet.

poeng = [60, 85, 70, 95, 40]
snitt = sum(poeng) / len(poeng)
over = []
for p in poeng:
    if p > snitt:
        over.append(p)
print(snitt, over)
70.0 [85, 95]

Gjennomsnittet er \(\frac{350}{5} = 70\). Elevene med \(85\) og \(95\) ligger over snittet. Eleven med \(70\) ligger akkurat på snittet, og tas ikke med siden vi bruker >.

AdvarselVanlige feil
  • tall[len(tall)] gir IndexError. Den siste indeksen er len(tall) - 1, eller -1.
  • liste = liste.sort() gir None. sort endrer lista på plass og gir ingenting tilbake. Skriv bare liste.sort(), eller ny = sorted(liste).
  • b = a kopierer ikke lista. Begge navnene peker på samme liste, og endrer du den ene, endres den andre. Lag en kopi med b = a.copy().
  • liste.remove(x) fjerner bare den første x-en, og gir ValueError hvis den ikke finnes.
  • Endre ikke en liste mens du går gjennom den med for. Lag heller en ny liste.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

La liste = [4, 8, 15, 16, 23, 42]. Hva er verdien av uttrykkene?

liste[2]
liste[-1]
len(liste)
liste[1] + liste[4]
sum(liste[1:4])
tall = [5, 2, 9, 1]
tall.append(7)
tall.remove(2)
print(tall)
print(tall[1:3])
print(tall[::-1])
print(len(tall))

Følg lista gjennom append og remove først, og bruk så den nye lista i print-linjene.

[5, 9, 1, 7]
[9, 1]
[7, 1, 9, 5]
4

Etter append(7) er lista [5, 2, 9, 1, 7], og etter remove(2) er den [5, 9, 1, 7].

Nivå 2

Programmet har tre feil. Finn dem og rett dem.

tall = [4, 8, 15]
print(tall[3])

navn = ["Per", "Ola", "Kari"]
navn = navn.sort()

a = [1, 2, 3]
b = a
b.append(4)
# a skal fortsatt være [1, 2, 3]

Se på hvilken indeks som er den siste, hva sort gir tilbake, og hva b = a gjør.

  • tall[3] gir IndexError, siden lista bare har indeks \(0\), \(1\) og \(2\). Det siste elementet er tall[2] eller tall[-1].
  • navn = navn.sort() setter navn til None. Skriv bare navn.sort().
  • b = a gir to navn på samme liste, så a blir også [1, 2, 3, 4]. Bruk b = a.copy().

Programmet skal telle hvor mange tall i lista som er større enn gjennomsnittet. Forklar hva som er galt, og rett det.

tall = [2, 4, 6, 8]
snitt = sum(tall) / len(tall)
antall = 0
for x in tall:
    if x > snitt:
        antall = 1
print(antall)

Hva er forskjellen på antall = 1 og antall += 1? Hvilke tall er større enn snittet?

antall = 1 setter antall til \(1\) hver gang. Det skal øke med \(1\): antall += 1. Snittet er \(5\), og tallene \(6\) og \(8\) er større, så riktig svar er \(2\).

Kodeoppgaver

Disse oppgavene rettes automatisk. Skriv koden i editoren og trykk Kjør. Står du fast, kan du trykke Vis hint.

Gjør de tre endringene i handlelista: legg til "ost", fjern "brød", og sorter lista alfabetisk.

Bruk append, remove og sort. Sorter til slutt.

Regn ut gjennomsnittet av karakterene med en løkke, uten å bruke sum. Lagre svaret i snitt.

Lag summen = 0 før løkka, legg til hvert tall i løkka, og del til slutt på len(karakterer).

Finn det største tallet i lista med en løkke. Lagre svaret i storste. Du skal ikke bruke max, sorted eller sort.

Sett storste = tall[0], og oppdater den inne i løkka med en if.

Lag en ny liste partall med bare partallene fra tall, i samme rekkefølge.

Start med partall = []. Gå gjennom tall, og legg til de som har x % 2 == 0.

Programmet skal sortere lista, men skriver None. Rett det.

Skriv bare navn.sort() uten navn = foran.

Utfordringer

Lag en ny liste unike med hvert tall bare én gang, i den rekkefølgen de først forekommer. Du skal ikke bruke set.

Gå gjennom tall. Er tallet ikke allerede i unike (x not in unike), legger du det til.

Flytt det første elementet bakerst i lista, slik at [1, 2, 3, 4, 5] blir [2, 3, 4, 5, 1].

liste.pop(0) fjerner det første elementet og gir det tilbake. Det kan du legge til med append.

Oppsummering

Lage og hente ut

tall = [4, 8, 15, 16]
tall[0]      # 4
tall[-1]     # 16
tall[1:3]    # [8, 15]
len(tall)    # 4

Endre

tall.append(x)
tall.insert(i, x)
tall.remove(x)
tall.pop(i)
tall.sort()

Gå gjennom

for x in tall:
    print(x)

Bygge en ny liste

ny = []
for x in tall:
    if x > 5:
        ny.append(x)

Samlede mål

sum(tall)  min(tall)
max(tall)  sorted(tall)
  • Indeksene starter på \(0\). Den siste er len(liste) - 1, eller -1.
  • sort() gir None. Bruk sorted() for å få en ny liste.
  • b = a gir ikke en kopi. Bruk a.copy().

2.3.2 Tupler og ordbøker

Skal du finne telefonnummeret til Kari i en liste, må du lete gjennom hele lista til du finner henne. I en telefonkatalog slår du i stedet opp på navnet, og får nummeret med en gang. Python har en egen type til dette, ordboken:

telefon = {"Ola": 91234567, "Kari": 98765432}
print(telefon["Kari"])
98765432

Du bruker navnet som nøkkel og får verdien tilbake. I dette delkapittelet ser vi på ordbøker og på tupler, som er lister som ikke kan endres.

Læringsmål

Etter dette delkapittelet skal du kunne

  • lage tupler, hente ut verdier og pakke dem ut i variabler,
  • lage ordbøker, slå opp, legge til, endre og fjerne verdier, og gå gjennom dem,
  • bruke .get() for å unngå KeyError,
  • bygge nøstede strukturer, som en liste med ordbøker, og hente ut data fra dem.

Tupler

Et tuppel ser ut som en liste, men skrives med vanlige parenteser, og det kan ikke endres etter at det er laget. Det passer for verdier som hører sammen og ikke skal endres, for eksempel et punkt \((x, y)\) eller en dato.

punkt = (3, 4)
print(punkt[0], punkt[1])
x, y = punkt
print(x, y)
3 4
3 4

Linja x, y = punkt pakker ut tuppelet: første verdi går til x, andre til y. Det virker også uten parenteser, og gir en enkel måte å bytte verdier på:

a = 3
b = 8
a, b = b, a
print(a, b)
8 3

Denne linja gjør det du måtte bruke en hjelpevariabel til i 2.1.1. Tupler brukes også når en funksjon skal gi flere verdier tilbake (se 2.4.1).

AdvarselMerk deg
  • Et tuppel kan ikke endres: punkt[0] = 5 gir TypeError.
  • Et tuppel med ett element skrives med komma: (5,). Uten komma er (5) bare et tall i parentes.

Punktet \((6, 8)\) er lagret som et tuppel. Pakk det ut og regn ut avstanden fra origo, \(\sqrt{x^2 + y^2}\).

Pakk ut med x, y = punkt. Kvadratroten er det samme som ** 0.5.

punkt = (6, 8)
x, y = punkt
avstand = (x ** 2 + y ** 2) ** 0.5
print(avstand)
10.0

Avstanden er \(\sqrt{36 + 64} = 10\).

Ordbøker

En ordbok (på engelsk dictionary, dict) er en samling av nøkkel–verdi-par. Nøklene må være unike, og vi slår opp på nøkkelen for å få verdien. Ordbøker skrives med krøllparenteser.

DefinisjonOrdbok
telefon = {"Ola": 91234567, "Kari": 98765432}
  • telefon["Kari"] gir verdien til nøkkelen "Kari".
  • telefon["Per"] = 95555555 legger til et nytt par, eller endrer verdien hvis nøkkelen finnes.
  • "Ola" in telefon er True hvis nøkkelen finnes.
  • del telefon["Ola"] fjerner et par.
  • len(telefon) er antall par.
telefon = {"Ola": 91234567, "Kari": 98765432}
telefon["Per"] = 95555555
telefon["Ola"] = 90000000
del telefon["Kari"]
print(telefon)
print("Per" in telefon)
{'Ola': 90000000, 'Per': 95555555}
True

Slår du opp en nøkkel som ikke finnes, får du KeyError. Med .get(nøkkel, standard) får du en standardverdi i stedet:

telefon = {"Ola": 91234567}
print(telefon.get("Kari", "ukjent"))
ukjent

En for-løkke går gjennom nøklene. Med .items() får du nøkkel og verdi samtidig:

alder = {"Ola": 17, "Kari": 18, "Per": 16}
for navn in alder:
    print(navn)
for navn, a in alder.items():
    print(f"{navn} er {a} år")
Ola
Kari
Per
Ola er 17 år
Kari er 18 år
Per er 16 år

Lag en ordbok som teller hvor mange ganger hvert ord forekommer i "en to en tre to en".

Gå gjennom ordene med .split(). For hvert ord legger du til \(1\) på tallet i ordboken. Bruk .get(ord, 0) for ord du ikke har sett før.

tekst = "en to en tre to en"
antall = {}
for ord in tekst.split():
    antall[ord] = antall.get(ord, 0) + 1
print(antall)
{'en': 3, 'to': 2, 'tre': 1}

For første "en" gir .get verdien \(0\), og vi lagrer \(1\). For neste "en" er verdien \(1\), og vi lagrer \(2\). Slik teller vi opp, uten å lage en variabel per ord.

Nøstede strukturer

Verdiene i en liste eller ordbok kan selv være lister og ordbøker. En liste med ordbøker er en enkel måte å lagre en tabell på, der hver ordbok er én rad:

elever = [
    {"navn": "Ola", "poeng": 72},
    {"navn": "Kari", "poeng": 88},
    {"navn": "Per", "poeng": 65},
]
print(elever[1]["navn"])
for elev in elever:
    print(elev["navn"], elev["poeng"])
Kari
Ola 72
Kari 88
Per 65

Først henter elever[1] den andre ordboken, og så henter ["navn"] verdien. Strukturen ligner JSON, et filformat vi skal bruke i kapittel 8.

Finn navnet til eleven med flest poeng i lista elever over.

Gå gjennom lista. Husk den høyeste poengsummen og navnet til eleven som har den, på samme måte som når du finner det største tallet.

elever = [
    {"navn": "Ola", "poeng": 72},
    {"navn": "Kari", "poeng": 88},
    {"navn": "Per", "poeng": 65},
]
beste = elever[0]["navn"]
hoyeste = elever[0]["poeng"]
for elev in elever:
    if elev["poeng"] > hoyeste:
        hoyeste = elev["poeng"]
        beste = elev["navn"]
print(beste, hoyeste)
Kari 88

Kari har \(88\) poeng, flest av alle.

AdvarselVanlige feil
  • telefon["Per"] gir KeyError hvis nøkkelen ikke finnes. Sjekk med in, eller bruk .get().
  • En nøkkel finnes bare én gang. Legger du til en nøkkel som finnes, erstatter den verdien.
  • Nøkler må være av en type som ikke kan endres: tekst, tall og tupler går, lister gjør det ikke.
  • liste[0] og ordbok["a"] ser like ut, men indeksen i en liste er et tall, mens nøkkelen i en ordbok kan være hva som helst.
  • Ordboken har ingen append. Du legger til med ordbok[nøkkel] = verdi.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

La pris = {"brød": 35, "melk": 20, "ost": 80}. Hva er verdien av uttrykkene?

pris["melk"]
pris["brød"] + pris["ost"]
len(pris)
pris.get("egg", 0)
pris["ost"] - pris.get("melk", 0)
person = {"navn": "Kari", "alder": 17}
person["alder"] = 18
person["by"] = "Oslo"
del person["navn"]
print(person)
print(len(person))
print("navn" in person)

Følg ordboken gjennom hver linje.

{'alder': 18, 'by': 'Oslo'}
2
False

alder endres til \(18\), by legges til, og navn fjernes.

Nivå 2

Programmet gir en feilmelding. Forklar hva som er galt, og foreslå to måter å rette det på.

karakterer = {"Ola": 4, "Kari": 5}
print(karakterer["Per"])

Finnes nøkkelen "Per" i ordboken?

"Per" finnes ikke som nøkkel, så Python gir KeyError: 'Per'. To måter å rette det på:

print(karakterer.get("Per", "ukjent"))

eller sjekke først:

if "Per" in karakterer:
    print(karakterer["Per"])
else:
    print("ingen karakter")

Hva skriver programmet ut?

punkt = (2, 5)
x, y = punkt
x, y = y, x
print(x, y)
print(punkt)

x, y = y, x bytter verdiene til variablene, men endrer ikke tuppelet.

5 2
(2, 5)

x og y er først \(2\) og \(5\), og byttes så. Tuppelet punkt er uendret, siden et tuppel ikke kan endres.

Kodeoppgaver

Disse oppgavene rettes automatisk. Skriv koden i editoren og trykk Kjør. Står du fast, kan du trykke Vis hint.

Punktene a og b er lagret som tupler. Pakk dem ut og regn ut avstanden mellom dem, \(\sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}\). Lagre svaret i avstand.

Pakk ut med x1, y1 = a og x2, y2 = b. Bruk ** 0.5 for kvadratrot.

Gjør tre endringer i ordboken: legg til "Per" med nummer \(95555555\), endre nummeret til "Ola" til \(90000000\), og fjern "Kari".

Bruk telefon["Per"] = ... til å legge til og endre, og del telefon["Kari"] til å fjerne.

Lag en ordbok antall som teller hvor mange ganger hver bokstav forekommer i "banana". Du skal ikke bruke count eller Counter.

Gå gjennom hver bokstav (tegn) i tekst, og sett antall[tegn] = antall.get(tegn, 0) + 1.

Finn navnet til eleven med flest poeng, og lagre det i beste.

Start med første elev som den beste, og bytt hvis du finner en med flere poeng.

Programmet krasjer. Rett det slik at snitt blir 0 for en elev som ikke finnes i ordboken.

karakterer.get("Per", 0) gir \(0\) når "Per" ikke finnes.

Utfordringer

Lag en ny ordbok omvendt der nøklene og verdiene er byttet om, slik at {"a": 1, "b": 2} blir {1: "a", 2: "b"}.

Gå gjennom original.items(), og sett omvendt[verdi] = nokkel.

Lag en ordbok grupper der nøklene er ordlengder og verdiene er lister med ordene som har den lengden.

Finnes lengden ikke som nøkkel (lengde not in grupper), lager du grupper[lengde] = []. Så legger du ordet til med append.

Oppsummering

Tuppel

punkt = (3, 4)
x, y = punkt
a, b = b, a

Lage og slå opp

d = {"a": 1, "b": 2}
d["a"]
d.get("c", 0)

Endre

d["c"] = 3
del d["a"]
"b" in d

Gå gjennom

for nokkel in d:
    ...
for nokkel, verdi in d.items():
    ...

Liste med ordbøker

elever = [{"navn": "Ola"}]
elever[0]["navn"]
  • Et tuppel kan ikke endres. Et tuppel med ett element skrives (5,).
  • d[nokkel] gir KeyError hvis nøkkelen ikke finnes. Bruk .get() eller in.

2.4 Funksjoner

Med funksjoner pakker du inn kode du bruker flere ganger, og gir den et navn. Det gjør programmer kortere, lettere å lese og lettere å teste.

2.4.1 Funksjoner med parametere og returverdi

Skal du regne ut arealet av tre sirkler, kan du skrive formelen \(\pi r^2\) tre ganger:

print(3.14 * 2 ** 2)
print(3.14 * 5 ** 2)
print(3.14 * 10 ** 2)
12.56
78.5
314.0

Det fungerer, men gjør koden lang, og finner du en feil i formelen, må du rette den på tre steder. Med en funksjon skriver du formelen én gang og gir den et navn:

def sirkelareal(r):
    return 3.14 * r ** 2

print(sirkelareal(2))
print(sirkelareal(5))
print(sirkelareal(10))
12.56
78.5
314.0

Du har brukt funksjoner hele tiden: print, len og range er funksjoner andre har laget. Nå lager du dine egne.

Læringsmål

Etter dette delkapittelet skal du kunne

  • lage funksjoner med def, og kalle dem med verdier (argumenter),
  • forklare forskjellen på print og return,
  • lage funksjoner med flere parametere, og som gir flere verdier tilbake,
  • forklare hva en lokal variabel er, og hvorfor funksjoner ikke ser variablene utenfor uten at du sender dem inn.

Lage og kalle funksjoner

En funksjon lages med def, et navn, parenteser med parametere og kolon. Koden i funksjonen har innrykk. Funksjonen kjøres når vi kaller den, og verdiene vi sender inn, kalles argumenter.

DefinisjonFunksjon
def navn(parameter1, parameter2):
    # kode
    return resultat
  • Parametrene er variabler som får verdi når funksjonen kalles.
  • return avslutter funksjonen og gir en verdi tilbake til stedet den ble kalt fra.
  • def lager bare funksjonen. Den kjøres ikke før den kalles: navn(a, b).
def kvadrat(x):
    return x * x

a = kvadrat(4)
print(a)
print(kvadrat(3) + kvadrat(4))
16
25

Kallet kvadrat(4) gir verdien \(16\), som vi kan lagre i en variabel eller bruke videre i et uttrykk.

Lag en funksjon er_partall(n) som gir True hvis n er et partall, og False ellers.

Et tall er et partall hvis resten ved divisjon med \(2\) er \(0\). En sammenligning gir allerede True eller False.

def er_partall(n):
    return n % 2 == 0

print(er_partall(4))
print(er_partall(7))
True
False

Uttrykket n % 2 == 0 er selv True eller False, så vi kan returnere det direkte i stedet for å skrive en if.

Flere parametere og lokale variabler

En funksjon kan ha flere parametere, skilt med komma. Rekkefølgen på argumentene bestemmer hvilken parameter som får hvilken verdi.

def rektangelareal(bredde, hoyde):
    return bredde * hoyde

print(rektangelareal(3, 5))
15

Funksjoner kan bruke lister og løkker, og kalle andre funksjoner:

def gjennomsnitt(tall):
    summen = 0
    for x in tall:
        summen += x
    return summen / len(tall)

print(gjennomsnitt([4, 5, 3, 6, 4]))
4.4

Variabelen summen er lokal: den finnes bare mens funksjonen kjører, og er borte etterpå. Det betyr at to funksjoner kan bruke samme variabelnavn uten å påvirke hverandre, og at en funksjon bare ser det du sender inn.

Vil du ha flere verdier tilbake, kan du returnere et tuppel og pakke det ut:

def min_og_maks(tall):
    return min(tall), max(tall)

lav, hoy = min_og_maks([3, 17, 8, 42, 5])
print(lav, hoy)
3 42

Lag funksjonen finn_storste(tall) som gir det største tallet i lista, eller None hvis lista er tom. Ikke bruk max.

Sjekk først om lista er tom. Gå så gjennom lista og husk det største tallet så langt, som i forrige delkapittel.

def finn_storste(tall):
    if len(tall) == 0:
        return None
    storste = tall[0]
    for x in tall:
        if x > storste:
            storste = x
    return storste

print(finn_storste([3, 17, 8, 42, 5]))
print(finn_storste([-5, -2, -8]))
print(finn_storste([]))
42
-2
None

Funksjonen virker for alle lister, også med bare negative tall og for en tom liste. Det er styrken til funksjoner: du skriver koden én gang og tester den på mange verdier.

AdvarselVanlige feil
  • Glemt return. Funksjonen gir da None, og et senere regnestykke gir TypeError.
  • print i stedet for return. Verdien vises, men kan ikke brukes videre.
  • Funksjonen er laget, men aldri kalt. def gjør ingenting før du skriver navn(...).
  • Glemt parenteser ved kallet: kvadrat er funksjonen selv, mens kvadrat(4) er resultatet.
  • return inne i en løkke avslutter hele funksjonen med én gang. Står return i første runde, blir bare første element sjekket.
  • Parametere i feil rekkefølge, når funksjonen ikke gir samme svar begge veier.
  • En variabel som er laget inne i funksjonen, finnes ikke utenfor den (NameError).

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hva er verdien av kallene?

def f(x):
    return 2 * x + 1

def g(a, b):
    return a - b
f(3)
g(10, 4)
g(4, 10)
f(g(5, 2))
f(f(1))

Hva skriver programmet ut?

def a(x):
    print(x + 1)

def b(x):
    return x + 1

y = a(1)
z = b(1)
print(y)
print(z)

Funksjon a skriver ut, men gir den noe tilbake? Hva er verdien til y?

2
None
2

Kallet a(1) skriver ut 2 inne fra funksjonen. Siden a ikke har return, blir y lik None, og print(y) skriver None. b(1) gir \(2\) tilbake, og print(z) skriver 2.

Nivå 2

Funksjonen skal gi arealet av en sirkel, men gir en feilmelding når den brukes.

def sirkelareal(r):
    areal = 3.14 * r ** 2

print(sirkelareal(2) + 1)

Hva er feilen, og hvilken feilmelding gir programmet?

Hva gir funksjonen tilbake? Hva skjer når du prøver å legge \(1\) til det?

Funksjonen har ingen return, så den gir None. Da blir sirkelareal(2) + 1 til None + 1, som gir TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'.

Rett programmet.

Hva gir funksjonen tilbake? Hva skjer når du prøver å legge \(1\) til det?

Legg til return:

def sirkelareal(r):
    areal = 3.14 * r ** 2
    return areal

Eller korte det ned til return 3.14 * r ** 2.

def sirkelareal(r):
    areal = 3.14 * r ** 2
    return areal

Eller korte det ned til return 3.14 * r ** 2.

Funksjonen skal gi summen av tallene, men gir bare det første tallet.

def summer(tall):
    summen = 0
    for x in tall:
        summen += x
        return summen

Forklar feilen og rett den.

Hva skjer når Python kommer til return? Hvor mange runder kjører løkka?

return står inne i løkka og avslutter funksjonen i første runde. Funksjonen gir derfor bare det første tallet. Flytt return ut av løkka, slik at den står på samme nivå som for:

def summer(tall):
    summen = 0
    for x in tall:
        summen += x
    return summen
Kodeoppgaver

Disse oppgavene rettes automatisk. Skriv funksjonen i editoren og trykk Kjør. Testene kaller funksjonen din med flere verdier.

Lag funksjonen kvadrat(x) som gir \(x^2\).

Start med def kvadrat(x): og avslutt med return x * x.

Lag funksjonen er_partall(n) som gir True for partall og False ellers.

n % 2 == 0 er allerede True eller False. Returner det direkte.

Lag funksjonen gjennomsnitt(tall) som gir gjennomsnittet av en liste med tall. Du skal ikke bruke sum.

Lag summen = 0, legg til hvert tall i en løkke, og returner summen / len(tall).

Lag funksjonen finn_storste(tall) som gir det største tallet i lista, eller None hvis lista er tom. Du skal ikke bruke max, sorted eller sort.

Sjekk først om lista er tom. Start så med storste = tall[0] og bytt ut hvis du finner et større.

Funksjonen skriver ut det doble, men gir ingenting tilbake. Rett den slik at dobbel(4) gir \(8\).

Bytt print med return.

Lag funksjonen tell_vokaler(tekst) som gir antall vokaler (aeiouyæøå) i teksten.

Lag antall = 0, gå gjennom bokstavene, og øk antall når bokstaven er i "aeiouyæøå".

Utfordringer

\(n!\) (\(n\) fakultet) er produktet \(1 \cdot 2 \cdot \ldots \cdot n\), og \(0! = 1\). Lag funksjonen fakultet(n).

Start med produkt = 1 og gang med alle tallene fra \(1\) til \(n\). For \(n = 0\) går løkka aldri, og svaret blir \(1\).

Et primtall er et helt tall større enn \(1\) som bare er delelig med \(1\) og seg selv. Lag funksjonen er_primtall(n).

Hvis \(n < 2\), er svaret False. Ellers prøver du å dele på alle tall fra \(2\) til \(n - 1\). Finner du en deler, er svaret False.

Oppsummering

Lage og kalle

def kvadrat(x):
    return x * x

svar = kvadrat(4)

Flere parametere

def areal(b, h):
    return b * h

areal(3, 5)

Flere verdier tilbake

def min_maks(tall):
    return min(tall), max(tall)

lav, hoy = min_maks(liste)

print eller return

print(x)    # viser
return x    # gir tilbake
  • En funksjon uten return gir None.
  • return avslutter funksjonen med én gang.
  • Variabler inne i funksjonen er lokale og finnes ikke utenfor.
  • def kjører ikke funksjonen. Du må kalle den.

2.5 Algoritmisk tenkning og flytdiagram

Før du skriver koden, må du vite hva løsningen er. Her ser du hvordan du går fra et problem til en plan, og hvordan du tegner og skriver ned planen.

2.5.1 Fra problem til algoritme

Jeg tenker på et tall mellom \(1\) og \(100\). Du skal gjette det, og for hvert gjett sier jeg «høyere» eller «lavere». Hvor mange gjett trenger du? Gjetter du \(1, 2, 3, \ldots\) kan det ta \(100\) gjett. Men gjetter du alltid midt i det som er igjen, trenger du høyst \(7\).

Det siste er en algoritme: en nøyaktig oppskrift som alltid fører til målet. Før du skriver kode, bør du vite hva oppskriften er. Å finne den er ofte vanskeligere enn å skrive koden.

Læringsmål

Etter dette delkapittelet skal du kunne

  • forklare hva en algoritme er, og hvilke krav vi stiller til den,
  • dele et problem i trinn: forstå, lage eksempler, lage en plan, kode og teste,
  • følge en algoritme for hånd med en sporingstabell,
  • finne grensetilfeller som kan få en algoritme til å feile.

Hva er en algoritme?

DefinisjonAlgoritme

En algoritme er en endelig rekke av nøyaktige trinn som løser et problem. Den må

  • være entydig: hvert trinn er så presist at det ikke er tvil om hva som skal gjøres,
  • stoppe etter et endelig antall trinn,
  • gi riktig svar for alle gyldige inndata.

En kakeoppskrift er nesten en algoritme, men «kok til den er ferdig» er ikke entydig for en datamaskin. En datamaskin gjør nøyaktig det vi sier, og ingenting annet. Derfor må vi først finne ut hva som skal gjøres, og skrive det ned.

Algoritmen for «gjett tallet» er:

  1. La nedre grense være \(1\) og øvre grense være \(100\).
  2. Gjett tallet midt mellom grensene.
  3. Er gjettet for lavt, flytt nedre grense til gjettet pluss \(1\). Er det for høyt, flytt øvre grense til gjettet minus \(1\).
  4. Gjenta fra trinn 2 til gjettet er riktig.

Hver gang halveres antall tall som er igjen: \(100\), \(50\), \(25\), \(12\), \(6\), \(3\), \(1\). Det er derfor det aldri tar mer enn \(7\) gjett.

Det hemmelige tallet er \(63\). Lag et program som gjetter med algoritmen over, og skriv ut hvert gjett og antall gjett.

Du vet ikke hvor mange gjett det blir, så bruk while. Midten av to tall regnes ut med (nedre + ovre) // 2.

hemmelig = 63
nedre = 1
ovre = 100
forsok = 0
while True:
    gjett = (nedre + ovre) // 2
    forsok += 1
    print(gjett)
    if gjett == hemmelig:
        break
    elif gjett < hemmelig:
        nedre = gjett + 1
    else:
        ovre = gjett - 1
print("Fant det på", forsok, "gjett")
50
75
62
68
65
63
Fant det på 6 gjett

Programmet bruker \(6\) gjett: \(50, 75, 62, 68, 65, 63\). Prøv med andre hemmelige tall og se at det aldri blir mer enn \(7\).

Fra problem til program

Når du får et problem du ikke har løst før, kan du gå frem i fem trinn:

RegelFem trinn fra problem til program
  1. Forstå. Hva er inndata, og hva skal ut? Skriv det med egne ord.
  2. Eksempler. Lag noen små eksempler for hånd, også spesielle tilfeller (tom liste, ett element, negative tall).
  3. Plan. Beskriv løsningen i vanlige ord eller pseudokode, uten å tenke på Python.
  4. Kode. Oversett planen til Python.
  5. Test. Kjør eksemplene fra trinn 2. Stemmer svarene?

La oss gå gjennom trinnene med et problem: Er et ord et palindrom? Et palindrom er et ord som er likt forfra og bakfra, som «radar».

  1. Forstå. Inn: et ord. Ut: True hvis ordet er et palindrom, ellers False.
  2. Eksempler. «radar» gir True, «hei» gir False. Spesielle tilfeller: «a» (ett tegn), «» (tomt) og «Aha» (store og små bokstaver).
  3. Plan. Gjør alle bokstavene små. Snu ordet. Er det snudde ordet likt det opprinnelige, er det et palindrom.
  4. Kode.
def er_palindrom(ord):
    liten = ord.lower()
    return liten == liten[::-1]

print(er_palindrom("radar"))
print(er_palindrom("hei"))
print(er_palindrom("Aha"))
print(er_palindrom(""))
True
False
True
True
  1. Test. Alle fire eksemplene gir riktig svar. Merk at vi kom på «Aha» før vi skrev koden. Uten .lower() ville den feilet.

Hvordan kan du dele problemet «skriv ut alle primtall under \(30\)» i mindre deler?

Hvilket enkeltspørsmål må du kunne svare på for hvert tall? Og hvilke tall skal du spørre om?

Vi deler det i to:

  1. Er et enkelt tall n et primtall? Det kan vi svare på ved å prøve å dele n på alle tall fra \(2\) til \(n - 1\). Hvis ingen går opp, er n et primtall.
  2. Gå gjennom tallene fra \(2\) til \(29\) og skriv ut dem der svaret på 1 er ja.
def er_primtall(n):
    if n < 2:
        return False
    for deler in range(2, n):
        if n % deler == 0:
            return False
    return True

for tall in range(2, 30):
    if er_primtall(tall):
        print(tall, end=" ")
2 3 5 7 11 13 17 19 23 29 

Når vi deler et stort problem i små biter og gir hver bit et navn (her er_primtall), kan vi løse og teste hver bit for seg.

Følge en algoritme for hånd

Før du kjører koden, kan du følge algoritmen for hånd i en sporingstabell, med én rad per runde og én kolonne per variabel. Da ser du hva som skjer, og finner feil som er vanskelige å se i koden.

Algoritmen for å finne det minste tallet i lista \([7, 3, 9, 3, 5]\):

  1. La minste være det første tallet.
  2. For hvert tall i lista: er tallet mindre enn minste, la minste være tallet.
Tall minste etterpå
(start) \(7\)
\(7\) \(7\)
\(3\) \(3\)
\(9\) \(3\)
\(3\) \(3\)
\(5\) \(3\)

Svaret er \(3\). Hva ville skjedd med en tom liste? Det er ikke noe første tall å starte på, så algoritmen feiler. Det er et grensetilfelle vi bør tenke på før vi koder.

Algoritmen under starter med s = 0, og for hvert tall x i lista: er x et partall, legges x til s. Hva er s etter lista \([4, 7, 10, 3, 6]\)?

Lag en sporingstabell med kolonnene x, «partall?» og s.

x Partall? s etterpå
(start) – \(0\)
\(4\) ja \(4\)
\(7\) nei \(4\)
\(10\) ja \(14\)
\(3\) nei \(14\)
\(6\) ja \(20\)

Svaret er \(20\): summen av partallene \(4 + 10 + 6\).

AdvarselVanlige feil
  • Å begynne å kode før du har forstått problemet. Skriv først ned hva som kommer inn og hva som skal ut.
  • Å bare teste det vanlige tilfellet. Test også tom liste, ett element, negative tall og like tall.
  • Å lage en algoritme som ikke stopper. En while-løkke må alltid nærme seg slutten.
  • Å løse problemet i hodet og glemme at maskinen må få hvert trinn forklart.
  • Å tro at en algoritme som virker for ett eksempel, virker for alle. Test flere eksempler.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hvilke av disse er gode nok som algoritmer? Begrunn.

«Finn det største tallet ved å se på lista og velge det som ser størst ut.»

Tenk på de tre kravene: entydig, stopper og riktig svar.

Nei. «Det som ser størst ut» er ikke entydig. En datamaskin trenger nøyaktige trinn.

«Start med det første tallet som største. For hvert tall: er det større enn største, bytt.»

Tenk på de tre kravene: entydig, stopper og riktig svar.

Ja. Hvert trinn er presist, den stopper når lista er ferdig, og den gir det største tallet.

«Gjenta å legge til \(1\) til tallet er \(0\)», med start på \(5\).

Tenk på de tre kravene: entydig, stopper og riktig svar.

Nei. Tallet øker fra \(5\) og passerer aldri \(0\), så algoritmen stopper aldri.

Du gjetter et tall mellom \(1\) og \(100\) med halveringsalgoritmen, og det hemmelige tallet er \(30\). Hva er de tre første gjettene dine?

Nivå 2

Algoritmen under er Collatz-følgen fra 2.2.2. Den starter med n = 6 og antall = 0. Hva er antall når den stopper?

while n != 1:
    if n % 2 == 0:
        n = n // 2
    else:
        n = 3 * n + 1
    antall += 1

Lag en sporingstabell.

Lag en tabell med kolonnene n og antall, og skriv ned verdiene etter hver runde.

Runde n antall
start \(6\) \(0\)
1 \(3\) \(1\)
2 \(10\) \(2\)
3 \(5\) \(3\)
4 \(16\) \(4\)
5 \(8\) \(5\)
6 \(4\) \(6\)
7 \(2\) \(7\)
8 \(1\) \(8\)

For \(n = 6\) er antall \(8\) når algoritmen stopper.

Algoritmen skal gi gjennomsnittet av tallene i en liste:

  1. Legg sammen alle tallene.
  2. Del summen på antall tall.

Hvilke lister kan få algoritmen til å feile, eller gi et rart svar?

Hva er antall tall i en tom liste? Hva skjer når du deler på det?

Med en tom liste er antallet \(0\), og divisjon på \(0\) gir ZeroDivisionError. Algoritmen må avgjøre hva som skal skje, for eksempel returnere None eller gi en feilmelding. Med bare ett tall virker algoritmen fint. Er lista full av store tall, virker den også, men svaret kan bli et desimaltall selv om alle tallene er heltall.

Kodeoppgaver

Disse oppgavene rettes automatisk. Skriv koden i editoren og trykk Kjør. Står du fast, kan du trykke Vis hint.

Lag funksjonen er_palindrom(ord) som gir True hvis ordet er det samme forfra og bakfra, uansett store og små bokstaver.

Gjør ordet om til små bokstaver med .lower(). Du kan snu en tekst med [::-1].

Skriv algoritmen for «gjett tallet» med halvering. Det hemmelige tallet er \(63\). Lagre antall gjett i forsok.

Gjenta så lenge du ikke har funnet tallet. Gjettet er (nedre + ovre) // 2. Er det for lavt, sett nedre = gjett + 1, ellers ovre = gjett - 1.

Funksjonen skal gi det minste tallet i lista, men gir feil svar for lister med bare positive tall.

Starter du med minste = 0, kan ingen positive tall bli mindre. Start med det første tallet i lista.

Utfordringer

Lag funksjonen finn_indeks(liste, tall) som gir indeksen til tall i en sortert liste, eller -1 hvis tallet ikke finnes. Bruk halvering, som i «gjett tallet».

Hold styr på nedre og ovre som indekser. Se på elementet i midten: er det for lite, flytter du nedre, er det for stort, flytter du ovre. Stopp når nedre er større enn ovre.

I «gjett tallet» halveres intervallet for hvert gjett. Forklar hvorfor algoritmen alltid stopper, og hvorfor det maksimalt trengs \(7\) gjett for tall fra \(1\) til \(100\).

For hvert gjett som er feil, blir intervallet av mulige tall minst halvert. Etter \(k\) gjett er det høyst \(100 / 2^k\) tall igjen. Siden \(2^7 = 128 \geq 100\), er det etter \(7\) gjett høyst ett tall igjen, og det må være riktig. Antall mulige tall blir mindre for hver runde, så til slutt er det bare ett igjen. Derfor stopper algoritmen alltid, og vi trenger aldri mer enn \(7\) gjett.

Oppsummering

Algoritme

Endelig rekke av nøyaktige trinn som løser et problem.

Entydig, stopper og gir riktig svar.

Fem trinn

  1. Forstå problemet
  2. Lag eksempler
  3. Lag en plan
  4. Skriv koden
  5. Test

Midten av to tall

midt = (nedre + ovre) // 2

Gjett tallet

while gjett != hemmelig:
    gjett = (nedre + ovre) // 2
    if gjett < hemmelig:
        nedre = gjett + 1
    else:
        ovre = gjett - 1
  • Test grensetilfeller: tom liste, ett element, negative tall.
  • Følg algoritmen for hånd i en sporingstabell før du koder.
  • Del store problemer i små biter, og gi hver bit et navn (en funksjon).

2.5.2 Flytdiagram og pseudokode

Skal du forklare noen veien til skolen, tegner du kanskje et kart. Du kan også skrive: «Gå rett fram til krysset. Er lyskrysset grønt, gå over. Ellers vent». Når en algoritme skal forklares, bruker vi to slike hjelpemidler: flytdiagrammer, som tegner veien, og pseudokode, som beskriver den med ord. Begge lar oss planlegge løsningen uten å bekymre oss for Python-reglene.

Læringsmål

Etter dette delkapittelet skal du kunne

  • lese og tegne flytdiagrammer med start, handling, inn/ut og valg,
  • vise valg og løkker i et flytdiagram,
  • skrive en algoritme som pseudokode,
  • oversette mellom flytdiagram, pseudokode og Python.

Flytdiagram

Et flytdiagram viser stegene i en algoritme som figurer forbundet med piler. Pilene viser rekkefølgen. Hver figur har sin betydning:

RegelSymboler i et flytdiagram
  • Oval: start og slutt.
  • Rektangel: en handling, for eksempel pris = 120.
  • Parallellogram: inn- eller utdata, for eksempel «les alder» og «skriv ut pris».
  • Rombe: et valg med to utganger, «ja» og «nei».

Diagrammet under viser billettprisen fra 2.2.1: barn under \(12\) betaler \(60\) kroner, og alle andre \(120\).

flowchart TD
    A([Start]) --> B[/Les alder/]
    B --> C{alder < 12?}
    C -- Ja --> D[pris = 60]
    C -- Nei --> E[pris = 120]
    D --> F[/Skriv ut pris/]
    E --> F
    F --> G([Slutt])

Rombene er if-setninger. De to veiene ut er if-blokken og else-blokken, og de samles igjen etterpå. Koden blir slik:

alder = int(input("Alder: "))
if alder < 12:
    pris = 60
else:
    pris = 120
print(pris)

Løkker i flytdiagram

En løkke vises ved at en pil går tilbake til et tidligere punkt. Diagrammet under legger sammen tallene fra \(1\) til \(5\):

flowchart TD
    A([Start]) --> B[summen = 0<br/>tall = 1]
    B --> C{tall <= 5?}
    C -- Ja --> D[summen = summen + tall]
    D --> E[tall = tall + 1]
    E --> C
    C -- Nei --> F[/Skriv ut summen/]
    F --> G([Slutt])

Rombet sjekker betingelsen hver gang vi kommer dit. Er den sann, går vi gjennom løkka og tilbake til rombet. Er den usann, går vi videre. Dette er en while-løkke:

summen = 0
tall = 1
while tall <= 5:
    summen = summen + tall
    tall = tall + 1
print(summen)
15

Oversett diagrammet til Python, og si hva programmet skriver ut.

flowchart TD
    A([Start]) --> B[n = 100<br/>steg = 0]
    B --> C{n > 1?}
    C -- Ja --> D[n = n // 2]
    D --> E[steg = steg + 1]
    E --> C
    C -- Nei --> F[/Skriv ut steg/]
    F --> G([Slutt])

Rombet er betingelsen i en while-løkke. Det som ligger mellom rombet og pilen tilbake, er løkkekroppen.

n = 100
steg = 0
while n > 1:
    n = n // 2
    steg += 1
print(steg)
6

Programmet skriver 6. Tallet halveres \(100 \to 50 \to 25 \to 12 \to 6 \to 3 \to 1\), og det tar seks steg. Her teller programmet hvor mange ganger vi må halvere \(100\) før vi kommer til \(1\).

Pseudokode

Pseudokode er en algoritme skrevet med korte, nøyaktige setninger, som ligger mellom vanlig språk og programkode. Det finnes ingen fast skrivemåte. Det viktige er at du er nøyaktig og at den som leser, forstår det samme som deg.

RegelPseudokode

En vanlig, norsk skrivemåte:

les alder
hvis alder < 12
    pris = 60
ellers
    pris = 120
skriv pris
  • hvis ... ellers for valg.
  • gjenta mens betingelse for løkker med en betingelse.
  • for hvert tall i liste for å gå gjennom en liste.
  • Bruk innrykk for å vise hva som hører sammen.

Pseudokode er nyttig fordi den ligger så nær Python at oversettelsen blir enkel, men likevel er fri for krav til kolon og parenteser. Du kan bruke den til å planlegge, og la kommentarene i Python-koden følge pseudokoden.

Oversett pseudokoden til Python.

tall = liste
summen = 0
for hvert x i tall
    hvis x er et partall
        legg x til summen
skriv summen

Hvert linjepar har en Python-form: «for hvert» blir for, «hvis» blir if, og «er et partall» blir % 2 == 0.

tall = [4, 7, 10, 3, 6]
summen = 0
for x in tall:
    if x % 2 == 0:
        summen += x
print(summen)
20

Programmet skriver 20, summen av partallene \(4 + 10 + 6\).

AdvarselVanlige feil
  • Å tegne piler uten retning eller med flere utganger fra en handling. Hver figur unntatt rombet har én utgang.
  • Å glemme å merke utgangene fra rombet med «Ja» og «Nei».
  • Å lage en løkke som ikke har noen vei ut.
  • Å skrive pseudokode som egentlig er Python med feil. Pseudokode skal være lett å lese for en som ikke kan Python.
  • Å lage et flytdiagram etter at koden er skrevet. Flytdiagrammet er mest nyttig før, når du planlegger.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hvilket symbol i et flytdiagram bruker du til hver av disse?

pris = 120

Tenk på hva som er en handling, et valg, utdata og en start.

Rektangel (en handling).

«Er alder < 12?»

Tenk på hva som er en handling, et valg, utdata og en start.

Rombe (et valg med «Ja» og «Nei»).

«Skriv ut svaret»

Tenk på hva som er en handling, et valg, utdata og en start.

Parallellogram (utdata).

Starten på algoritmen

Tenk på hva som er en handling, et valg, utdata og en start.

Oval (start).

flowchart TD
    A([Start]) --> B[x = 5]
    B --> C{x > 3?}
    C -- Ja --> D[x = x - 2]
    D --> C
    C -- Nei --> E[/Skriv ut x/]
    E --> F([Slutt])

Nivå 2

Tegn et flytdiagram (på papir) for en algoritme som leser et tall og skriver ut om det er positivt, negativt eller null.

Du trenger to valg etter hverandre.

flowchart TD
    A([Start]) --> B[/Les tall/]
    B --> C{tall > 0?}
    C -- Ja --> D[/Skriv ut positivt/]
    C -- Nei --> E{tall < 0?}
    E -- Ja --> F[/Skriv ut negativt/]
    E -- Nei --> G[/Skriv ut null/]
    D --> H([Slutt])
    F --> H
    G --> H

Dette tilsvarer en if-elif-else-kjede.

Diagrammet skal summere tallene fra \(1\) til \(4\), men løkka stopper aldri. Finn feilen.

flowchart TD
    A([Start]) --> B[summen = 0<br/>tall = 1]
    B --> C{tall <= 4?}
    C -- Ja --> D[summen = summen + tall]
    D --> C
    C -- Nei --> F[/Skriv ut summen/]
    F --> G([Slutt])

Hva er verdien til tall hver gang vi kommer til rombet?

Variabelen tall endres aldri i løkka, så tall <= 4 er alltid sann. Vi mangler et steg tall = tall + 1 mellom summen = summen + tall og rombet. Uten det er løkka uendelig.

Kodeoppgaver

Disse oppgavene rettes automatisk. Skriv koden i editoren og trykk Kjør.

Oversett pseudokoden til Python. Lagre svaret i summen.

summen = 0
for hvert tall fra 1 til 100
    hvis tallet er delelig med 3
        legg tallet til summen
skriv summen

range(1, 101) gir tallene fra \(1\) til \(100\). Delelig med \(3\) betyr tall % 3 == 0.

Diagrammet under halverer tallet \(100\) til det er \(1\) eller mindre, og teller stegene. Oversett det til Python. Lagre stegene i steg.

flowchart TD
    A([Start]) --> B[n = 100<br/>steg = 0]
    B --> C{n > 1?}
    C -- Ja --> D[n = n // 2]
    D --> E[steg = steg + 1]
    E --> C
    C -- Nei --> F[/Skriv ut steg/]
    F --> G([Slutt])

Rombet er betingelsen i en while-løkke, og de to rektanglene er løkkekroppen.

Oversett pseudokoden til Python.

for hvert tall fra 5 ned til 1
    skriv tallet
skriv "Start!"

Bruk range(5, 0, -1). «Start!» skrives ut etter løkka, uten innrykk.

Utfordringer

Skriv en algoritme for «gjett tallet» som pseudokode, og tegn et flytdiagram for den.

Du trenger variablene nedre, ovre og gjett, en løkke og et valg med tre utganger.

Pseudokode:

nedre = 1
ovre = 100
gjenta
    gjett = midten av nedre og ovre
    hvis gjett er riktig
        stopp
    ellers hvis gjett er for lavt
        nedre = gjett + 1
    ellers
        ovre = gjett - 1

Flytdiagram:

flowchart TD
    A([Start]) --> B[nedre = 1<br/>ovre = 100]
    B --> C[gjett = midten]
    C --> D{riktig?}
    D -- Ja --> G([Slutt])
    D -- Nei --> E{for lavt?}
    E -- Ja --> F[nedre = gjett + 1]
    E -- Nei --> H[ovre = gjett - 1]
    F --> C
    H --> C

Gi to grunner til at man vil planlegge med pseudokode eller flytdiagram før man koder, i stedet for å begynne med Python.

  • Du kan konsentrere deg om hva algoritmen gjør, uten å tenke på syntaks som kolon og innrykk. Da finner du ofte logiske feil tidlig.
  • Andre kan lese og vurdere planen din, også de som ikke kan Python. Det gjør det lettere å samarbeide og å oppdage misforståelser før det er brukt tid på koden.
  • Planen kan brukes til flere programmeringsspråk, og den gjør det lettere å dele opp og fordele arbeidet i et team.

Oppsummering

Symboler

  • Oval: start og slutt
  • Rektangel: handling
  • Parallellogram: inn og ut
  • Rombe: valg (Ja/Nei)

Valg i pseudokode

hvis betingelse
    ...
ellers
    ...

Løkke i pseudokode

gjenta mens betingelse
    ...
for hvert x i liste
    ...

Mermaid

flowchart TD
    A([Start]) --> B{x > 0?}
  • En løkke i et flytdiagram er en pil som går tilbake til et rombe.
  • Pseudokode har ingen fast skrivemåte, men må være nøyaktig og lett å lese.
  • Lag flytdiagrammet eller pseudokoden før du koder.

2.6 Bruk det i prosjektene

2.7 Oppgaver

Disse oppgavene blander temaene fra hele kapittelet. Kodeoppgavene rettes automatisk. Flere oppgaver finner du i notatboka (lenkene øverst i kapittelet).

Velg liste, tuppel eller ordbok for hver av disse, og begrunn valget.

Karakterene til en elev i et fag, som blir flere utover året.

Skal samlingen endres? Skal du slå opp på noe annet enn en plassering?

Liste. Samlingen blir større, og rekkefølgen er viktig.

Koordinatene til et punkt på kartet.

Skal samlingen endres? Skal du slå opp på noe annet enn en plassering?

Tuppel. To verdier som hører sammen og ikke skal endres.

Hvor mange poeng hver spiller har, slått opp på navn.

Skal samlingen endres? Skal du slå opp på noe annet enn en plassering?

Ordbok. Vi slår opp på navnet og får poengene tilbake.

Navnene på ukedagene.

Skal samlingen endres? Skal du slå opp på noe annet enn en plassering?

Tuppel (eller liste). Ukedagene er faste og endres ikke, så et tuppel passer, men en liste går også.

def mystisk(liste):
    ut = []
    for x in liste:
        if x not in ut:
            ut.append(x)
    return ut
Hva gir mystisk([1, 2, 1, 3, 2])?

Følg funksjonen for den lista. Når legges et tall til i ut?

[1, 2, 3]

Beskriv med én setning hva funksjonen gjør.

Følg funksjonen for den lista. Når legges et tall til i ut?

Den gir en ny liste med hvert element bare én gang, i den rekkefølgen de først forekommer.

Foreslå et bedre navn på funksjonen.

Følg funksjonen for den lista. Når legges et tall til i ut?

For eksempel fjern_duplikater eller unike. Et godt navn sier hva funksjonen gjør.

Lag funksjonen karakter(poeng) som gir "A" fra \(90\) poeng, "B" fra \(75\), "C" fra \(60\), "D" fra \(50\) og "E" ellers.

Bruk en if-elif-kjede, og returner bokstaven. Sjekk den strengeste betingelsen først.

Lag funksjonen statistikk(tall) som gir minste tall, største tall og gjennomsnittet, som et tuppel. Du skal ikke bruke min, max eller sum.

Start med det første tallet som både minste og største, og legg sammen i en sum. Returner minste, storste, summen / len(tall).

Lag funksjonen tell_ord(tekst) som gir en ordbok med hvor mange ganger hvert ord forekommer. Gjør alle ord til små bokstaver.

Bruk tekst.lower().split() til å få en liste med ordene, og antall.get(ord, 0) + 1 til å telle.

Lag funksjonen lengste_ord(tekst) som gir det lengste ordet i teksten. Er flere ord like lange, skal det første gjelde. For en tom tekst skal funksjonen gi en tom tekst, "".

Start med lengste = "". Gå gjennom tekst.split(), og bytt ut hvis ordet er lengre enn det du har.

2.8 Oppsummering

Variabler og operatorer

Variabler og typer

antall = 3
pris = 29.9     # float
navn = "Kari"   # str
ok = True       # bool

Operatorer

7 / 2    # 3.5
7 // 2   # 3
7 % 2    # 1
2 ** 3   # 8

Typekonvertering

int("12")
float("3.5")
str(7)

Valg og løkker

Valg

if poeng >= 90:
    ...
elif poeng >= 60:
    ...
else:
    ...

for-løkke

for x in range(1, 6):
    print(x)

while-løkke

while belop < 2000:
    belop *= 1.05

break og continue

if x == 0:
    continue
if x > 9:
    break

Lister, tupler og ordbøker

Liste

tall = [4, 8, 15]
tall.append(16)
tall[0], tall[-1]
tall[1:3]

Tuppel

punkt = (3, 4)
x, y = punkt

Ordbok

d = {"a": 1}
d["b"] = 2
d.get("c", 0)
for k, v in d.items():
    ...

Funksjoner og algoritmer

Funksjon

def areal(b, h):
    return b * h

Fem trinn

  1. Forstå problemet
  2. Lag eksempler
  3. Lag en plan
  4. Skriv koden
  5. Test

Flytdiagram

  • Oval: start og slutt
  • Rektangel: handling
  • Parallellogram: inn og ut
  • Rombe: valg
  • = gir en variabel verdi, == sammenligner.
  • Indeksene i en liste starter på \(0\), og stoppverdien i range er ikke med.
  • En funksjon uten return gir None.
  • Test med spesielle tilfeller: tom liste, ett element, negative tall.