Variabler, talltyper, strenger og boolske verdier i Python.
Kontrollstrukturer
Til nå har programmene våre kjørt linje for linje fra topp til bunn. Men i virkelige programmer trenger vi ofte å ta valg (gjøre noe bare hvis en betingelse er oppfylt) og gjenta handlinger (kjøre de samme instruksjonene mange ganger). Dette styres med kontrollstrukturer.
I dette kapittelet lærer du tre viktige kontrollstrukturer:
- If-setninger – for å ta beslutninger basert på betingelser
- For-løkker – for å gjenta kode et bestemt antall ganger
- While-løkker – for å gjenta kode så lenge en betingelse er sann
Disse verktøyene gjør at du kan skrive programmer som reagerer på data og utfører komplekse oppgaver automatisk.
Et boolsk uttrykk er et uttrykk som evalueres til enten True (sant) eller False (usant). Boolske uttrykk bygges med sammenligningsoperatorer:
| Operator | Betydning | Eksempel | Resultat |
|---|---|---|---|
== | Er lik | 5 == 5 | True |
!= | Er ulik | 5 != 3 | True |
< | Mindre enn | 3 < 5 | True |
> | Større enn | 3 > 5 | False |
<= | Mindre enn eller lik | 5 <= 5 | True |
>= | Større enn eller lik | 6 >= 5 | True |
Logiske operatorer kombinerer flere boolske uttrykk:
| Operator | Betydning | Eksempel |
|---|---|---|
and | Begge må være sanne | x > 0 and x < 100 |
or | Minst én må være sann | x < 0 or x > 100 |
not | Negasjon (snur sannhetsverdien) | not (x > 0) |
Boolske uttrykk i praksis
Boolske uttrykk er grunnlaget for alle beslutninger i programmering. Her er noen eksempler:
temperatur = 25
fuktighet = 80
print(temperatur > 20) # True
print(temperatur == 25) # True (merk: dobbelt likhetstegn!)
print(temperatur > 20 and fuktighet > 70) # True
print(temperatur > 30 or fuktighet > 90) # FalseVanlig feil: Å bruke enkelt likhetstegn (=) i stedet for dobbelt (==) i sammenligninger. Husk: = tilordner en verdi, mens == sammenligner to verdier.
Boolske uttrykk er spesielt nyttige i teknologi og forskningslære – for eksempel for å sjekke om en sensorverdi er innenfor et akseptabelt område, eller om en måling overskrider en alarmgrense.
En temperatursensor gir verdien 28.5 °C. Skriv boolske uttrykk som sjekker: a) Er temperaturen over 30 °C? b) Er temperaturen mellom 20 og 30 °C? c) Er temperaturen under 0 eller over 35?
temp = 28.5
# a) Er temperaturen over 30 °C?
print(temp > 30) # False
# b) Er temperaturen mellom 20 og 30 °C?
print(temp > 20 and temp < 30) # True
# c) Er temperaturen under 0 eller over 35?
print(temp < 0 or temp > 35) # FalseUttrykk b) bruker and fordi begge betingelsene må stemme. Uttrykk c) bruker or fordi det holder at én av betingelsene er sann.
Gitt x = 7, hva blir resultatet av x >= 5 and x < 10?
En if-setning lar programmet utføre ulike handlinger avhengig av om en betingelse er sann eller usann.
Grunnleggende if:
if betingelse:
# Kode som kjøres hvis betingelsen er TrueIf-else:
if betingelse:
# Kjøres hvis True
else:
# Kjøres hvis FalseIf-elif-else (flere betingelser):
if betingelse_1:
# Kjøres hvis betingelse_1 er True
elif betingelse_2:
# Kjøres hvis betingelse_2 er True
elif betingelse_3:
# Kjøres hvis betingelse_3 er True
else:
# Kjøres hvis ingen av betingelsene er TrueViktig: Kodeblokken under en betingelse må være rykket inn med 4 mellomrom (eller én tab). Innrykket forteller Python hvilken kode som hører til betingelsen.
Skriv et program som leser inn en temperatur og skriver ut en passende melding: under 0 → «Frost!», 0–15 → «Kaldt», 15–25 → «Behagelig», over 25 → «Varmt!».
temp = float(input("Skriv inn temperaturen (°C): "))
if temp < 0:
print("Frost! Vær forsiktig med glatte veier.")
elif temp <= 15:
print("Kaldt. Ta på deg en jakke.")
elif temp <= 25:
print("Behagelig temperatur.")
else:
print("Varmt! Husk å drikke nok vann.")Eksempelkjøring:
Skriv inn temperaturen (°C): 18
Behagelig temperatur.Python sjekker betingelsene ovenfra og ned og utfører koden under den første betingelsen som er sann. Rekkefølgen er viktig – vi sjekker temp < 0 først, deretter temp <= 15 (som også dekker temp >= 0 fordi vi allerede har utelukket negative verdier).
Hva skriver følgende kode ut?
x = 15
if x > 20:
print("A")
elif x > 10:
print("B")
elif x > 5:
print("C")
else:
print("D")En for-løkke brukes til å gjenta en kodeblokk et bestemt antall ganger, eller for å gå gjennom elementene i en sekvens.
Grunnleggende for-løkke med range():
for i in range(5):
print(i) # Skriver ut 0, 1, 2, 3, 4range() med ulike argumenter:
| Kall | Genererer | Forklaring |
|---|---|---|
range(5) | 0, 1, 2, 3, 4 | Fra 0 til (men ikke med) 5 |
range(2, 7) | 2, 3, 4, 5, 6 | Fra 2 til (men ikke med) 7 |
range(0, 10, 2) | 0, 2, 4, 6, 8 | Fra 0 til 10, med steg 2 |
Løkke gjennom en sekvens:
farger = ["rød", "grønn", "blå"]
for farge in farger:
print(farge) # Skriver ut: rød, grønn, blåFor-løkker er svært nyttige for å behandle mange datapunkter, f.eks. sensorverdier fra et eksperiment.Skriv et program som ber brukeren om 5 temperaturmålinger, beregner gjennomsnittet og skriver det ut.
total = 0
for i in range(5):
maling = float(input(f"Skriv inn måling {i + 1}: "))
total = total + maling
gjennomsnitt = total / 5
print(f"Gjennomsnittstemperatur: {gjennomsnitt:.1f} °C")Eksempelkjøring:
Skriv inn måling 1: 18.2
Skriv inn måling 2: 19.5
Skriv inn måling 3: 20.1
Skriv inn måling 4: 19.8
Skriv inn måling 5: 18.9
Gjennomsnittstemperatur: 19.3 °CLøkken kjører 5 ganger (range(5) gir verdiene 0–4). For hver iterasjon leser vi inn en måling og legger den til totalen. Vi bruker i + 1 i utskriften slik at nummerering starter på 1 i stedet for 0.
Hva skriver for i in range(3, 8): print(i) ut?
En while-løkke gjentar en kodeblokk så lenge en betingelse er sann. While-løkker er nyttige når du ikke vet på forhånd hvor mange ganger løkken skal kjøre.
while betingelse:
# Kode som gjentas så lenge betingelsen er TrueEksempel – nedtelling:
tall = 5
while tall > 0:
print(tall)
tall = tall - 1 # Viktig: oppdater variabelen!
print("Start!")Utskrift: 5, 4, 3, 2, 1, Start!Advarsel: Hvis betingelsen aldri blir False, får du en uendelig løkke – programmet stopper aldri. Pass alltid på at løkkevariabelen endres slik at betingelsen til slutt blir usann.
break-setningen avbryter løkken umiddelbart:
while True:
svar = input("Skriv 'stopp' for å avslutte: ")
if svar == "stopp":
breakSkriv et program der datamaskinen velger et tilfeldig tall mellom 1 og 20, og brukeren skal gjette til de finner det riktige tallet.
import random
hemmelig = random.randint(1, 20)
antall_forsok = 0
print("Jeg tenker på et tall mellom 1 og 20.")
while True:
gjett = int(input("Ditt gjett: "))
antall_forsok = antall_forsok + 1
if gjett < hemmelig:
print("For lavt! Prøv igjen.")
elif gjett > hemmelig:
print("For høyt! Prøv igjen.")
else:
print(f"Riktig! Du brukte {antall_forsok} forsøk.")
breakProgrammet bruker while True for å kjøre løkken inntil brukeren gjetter riktig. Inne i løkken brukes en if-elif-else for å gi tilbakemelding. Når brukeren gjetter riktig, avsluttes løkken med break.
Hva blir verdien av teller etter at følgende kode er kjørt?
teller = 0
while teller < 10:
teller = teller + 3En uendelig løkke oppstår når betingelsen i en while-løkke aldri blir False:
# FEIL – dette stopper aldri!
tall = 1
while tall > 0:
print(tall)
tall = tall + 1 # tall blir bare større, aldri <= 0Hvis du havner i en uendelig løkke, trykk Ctrl+C for å avbryte programmet. For å unngå uendelige løkker:
- Sørg alltid for at løkkevariabelen endres inne i løkken
- Sjekk at endringen bringer betingelsen nærmere False
- Bruk break som nødstopp i while True-løkker
Oppsummering – Kontrollstrukturer
Du har nå lært de tre viktigste kontrollstrukturene i Python:
| Struktur | Bruksområde | Nøkkelord |
|---|---|---|
| If-setning | Ta beslutninger basert på betingelser | if, elif, else |
| For-løkke | Gjenta kode et bestemt antall ganger | for, in, range() |
| While-løkke | Gjenta kode så lenge betingelse er sann | while, break |
Sammenligningsoperatorer:
==, !=, <, >, <=, >=Logiske operatorer:
and, or, notTommelfingerregel: Bruk en for-løkke når du vet hvor mange ganger koden skal kjøre. Bruk en while-løkke når du ikke vet antall gjentagelser, men har en betingelse som skal sjekkes.
Kontrollstrukturer er kjernen i all programmering. Med if-setninger og løkker kan du skrive programmer som reagerer intelligent på data – for eksempel analysere målinger, styre sensorer og automatisere prosesser.
Skriv et Python-program som skriver ut alle partall fra 2 til og med 20 ved hjelp av en for-løkke. Programmet skal i tillegg beregne og skrive ut summen av alle disse partallene.
Skriv et Python-program som simulerer en enkel temperatursensor. Programmet skal: a) Generere 10 tilfeldige temperaturverdier mellom 15.0 og 35.0 °C (bruk random.uniform(15, 35)). b) Skrive ut hver måling med nummering. c) Telle hvor mange målinger som er over 25 °C (alarmgrensen). d) Beregne og skrive ut gjennomsnittstemperaturen og antall alarmer.
Dette kapitlet er skrevet av Anthropics toppmodeller (Claude Opus og Claude Fable) og er foreløpig ikke manuelt gjennomgått — kvalitetskontrollen gjøres av uavhengige KI-agenter, og innmeldte feil rettes fortløpende. Funnet en feil? Meld fra, så retter vi den. Les mer om hvordan innholdet lages.