5.3 Kontrollstrukturer | Teknologi og forskningslære 1

If-setninger, for-løkker og while-løkker.

35 min

6 oppgaver

If-setningerFor-løkkerWhile-løkkerBetingelser

Du leser den tradisjonelle versjonen

Din fremgang i kapitlet

0 / 6 oppgaver

Funksjoner og moduler

Etter hvert som programmene dine blir lengre og mer komplekse, blir det viktig å organisere koden godt. Funksjoner lar deg samle relaterte instruksjoner i gjenbrukbare blokker med et beskrivende navn. I stedet for å skrive den samme koden på nytt hver gang du trenger den, kan du definere en funksjon én gang og kalle den så mange ganger du vil.

Moduler lar deg bruke funksjoner som andre har skrevet – for eksempel Pythons innebygde math-modul med matematiske funksjoner, eller random-modulen for tilfeldige tall.

I dette kapittelet lærer du å:
- Definere egne funksjoner med def
- Bruke parametre for å sende inn data
- Bruke returverdier for å hente ut resultater
- Importere og bruke moduler

Funksjoner

En funksjon er en navngitt blokk med kode som utfører en bestemt oppgave. Du definerer funksjonen med nøkkelordet def, og kaller den ved å skrive navnet med parenteser. Enkleste form - funksjon uten parametre: def hils(): print("Hei og velkommen!") print("Klar for programmering?") # Kalle funksjonen: hils() # Skriver ut de to linjene hils() # Kan kalles flere ganger Funksjonen utføres ikke av seg selv - den kjøres bare når du kaller den (skriver navnet med parenteser). Du kan kalle den så mange ganger du ønsker. Navnekonvensjoner: - Bruk snake_case (små bokstaver med understrek) - Velg beskrivende navn som forklarer hva funksjonen gjør - Eksempler: beregn_areal(), les_temperatur(), skriv_rapport()

Parametre og argumenter

Parametre gjør funksjoner fleksible – de lar deg sende inn ulike data hver gang du kaller funksjonen.

def hils_person(navn):       # 'navn' er en parameter
    print(f"Hei, {navn}!")

hils_person("Ola")           # "Ola" er et argument
hils_person("Kari")          # "Kari" er et argument

Du kan ha flere parametre, separert med komma:

def beskriv_maling(sted, temperatur, tid):
    print(f"Sted: {sted}")
    print(f"Temperatur: {temperatur} °C")
    print(f"Tidspunkt: {tid}")

beskriv_maling("Oslo", 18.5, "14:30")
beskriv_maling("Bergen", 15.2, "09:00")

Standardverdier lar deg gi parametre forhåndsdefinerte verdier:

def beregn_kraft(masse, akselerasjon=9.81):
    kraft = masse * akselerasjon
    print(f"Kraft: {kraft:.1f} N")

beregn_kraft(10)           # Bruker standardverdien 9.81
beregn_kraft(10, 3.7)      # Overstyrer med 3.7 (f.eks. Mars)

✏️Eksempel: Funksjon for temperaturomregning

Skriv en funksjon celsius_til_fahrenheit(celsius) som regner om Celsius til Fahrenheit, og en funksjon fahrenheit_til_celsius(fahrenheit) som regner den andre veien. Test begge.

def celsius_til_fahrenheit(celsius):
    fahrenheit = celsius * 1.8 + 32
    print(f"{celsius} °C = {fahrenheit:.1f} °F")

def fahrenheit_til_celsius(fahrenheit):
    celsius = (fahrenheit - 32) / 1.8
    print(f"{fahrenheit} °F = {celsius:.1f} °C")

# Test:
celsius_til_fahrenheit(0)      # 0 °C = 32.0 °F
celsius_til_fahrenheit(100)    # 100 °C = 212.0 °F
fahrenheit_til_celsius(98.6)   # 98.6 °F = 37.0 °C

Hver funksjon har et tydelig navn som beskriver hva den gjør, og tar inn én parameter. Ved å skrive beregningen som en funksjon kan vi enkelt gjenbruke den med ulike verdier.

📝Oppgave 1

Hva skriver følgende kode ut?

def doble(x):
    print(x * 2)

doble(7)

Returverdier

En funksjon kan returnere en verdi tilbake til stedet den ble kalt fra, ved å bruke nøkkelordet return.def beregn_areal(radius): areal = 3.14159 * radius ** 2 return areal # Bruk returverdien: mitt_areal = beregn_areal(5.0) print(f"Arealet er {mitt_areal:.2f}") # Arealet er 78.54Forskjellen mellom print() og return:- print() viser verdien på skjermen, men lagrer den ikke- return sender verdien tilbake slik at den kan brukes videre i programmet# Med print – kan ikke bruke resultatet videre: def areal_print(r): print(3.14159 * r ** 2) # Med return – resultatet kan lagres og brukes: def areal_return(r): return 3.14159 * r ** 2 resultat = areal_return(3.0) # resultat = 28.27... dobbelt = resultat * 2 # Kan brukes videre!En funksjon kan returnere flere verdier ved å skille dem med komma:def beregn_sirkel(radius): areal = 3.14159 * radius ** 2 omkrets = 2 * 3.14159 * radius return areal, omkrets a, o = beregn_sirkel(5.0) print(f"Areal: {a:.1f}, Omkrets: {o:.1f}")

✏️Eksempel: Statistikkfunksjoner

Skriv en funksjon beregn_gjennomsnitt(verdier) som tar inn en liste med tall og returnerer gjennomsnittet. Skriv også en funksjon finn_maks(verdier) som returnerer den høyeste verdien.

def beregn_gjennomsnitt(verdier):
    total = 0
    for v in verdier:
        total = total + v
    return total / len(verdier)

def finn_maks(verdier):
    hoyest = verdier[0]
    for v in verdier:
        if v > hoyest:
            hoyest = v
    return hoyest

# Test med temperaturdata:
temperaturer = [18.3, 21.7, 19.5, 23.1, 17.8]

snitt = beregn_gjennomsnitt(temperaturer)
maks = finn_maks(temperaturer)

print(f"Gjennomsnitt: {snitt:.1f} °C")    # 20.1 °C
print(f"Høyeste: {maks} °C")               # 23.1 °C

Begge funksjonene bruker return for å sende resultatet tilbake. Vi kan deretter lagre resultatene i variabler og bruke dem videre. Funksjonen len(verdier) gir antall elementer i listen.

📝Oppgave 2

Hva er verdien av resultat etter at følgende kode er kjørt?

def legg_til(a, b):
    return a + b

def doble(x):
    return x * 2

resultat = doble(legg_til(3, 4))

Moduler

En modul er en fil med Python-kode som inneholder funksjoner, variabler og klasser som kan gjenbrukes i andre programmer. Python har mange innebygde moduler som er klare til bruk. Importere en hel modul: import math print(math.pi) # 3.141592653589793 print(math.sqrt(25)) # 5.0 print(math.sin(math.pi)) # ~0 (sinus til pi) Importere bestemte funksjoner: from math import sqrt, pi print(pi) # 3.141592653589793 print(sqrt(25)) # 5.0 (trenger ikke 'math.' foran) Nyttige innebygde moduler for teknologi og forskning: Modul Beskrivelse Eksempel math Matematiske funksjoner math.sqrt(), math.log() random Tilfeldige tall random.randint(), random.uniform() time Tid og forsinkelser time.sleep(), time.time() statistics Statistikk statistics.mean(), statistics.stdev()

Modul	Beskrivelse	Eksempel
`math`	Matematiske funksjoner	`math.sqrt()`, `math.log()`
`random`	Tilfeldige tall	`random.randint()`, `random.uniform()`
`time`	Tid og forsinkelser	`time.sleep()`, `time.time()`
`statistics`	Statistikk	`statistics.mean()`, `statistics.stdev()`

Moduler i praksis

Her er et eksempel som bruker flere moduler for å simulere et vitenskapelig eksperiment:

import math
import random
import statistics

# Generere simulerte temperaturdata med støy
malinger = []
for i in range(20):
    sann_temp = 22.0 + 3.0 * math.sin(i * 0.5)  # Varierer med sinus
    stoy = random.uniform(-0.5, 0.5)              # Tilfeldig målestøy
    malinger.append(sann_temp + stoy)

# Bruke statistics-modulen for analyse
gjennomsnitt = statistics.mean(malinger)
std_avvik = statistics.stdev(malinger)

print(f"Antall målinger: {len(malinger)}")
print(f"Gjennomsnitt: {gjennomsnitt:.2f} °C")
print(f"Standardavvik: {std_avvik:.2f} °C")

Du kan også lage dine egne moduler ved å lagre funksjoner i en Python-fil. Hvis du lagrer funksjoner i mine_funksjoner.py, kan du importere dem i et annet program med import mine_funksjoner.

Moduler er en av de store styrkene ved Python – de lar deg bygge på arbeidet til andre og gjenbruke kode på tvers av prosjekter.

📝Oppgave 3

Hvilken modul må du importere for å bruke funksjonen sqrt() (kvadratrot)?

Oppsummering – Funksjoner og moduler

Du har lært hvordan du organiserer kode i gjenbrukbare blokker:

Konsept	Forklaring	Eksempel
Definere funksjon	Lag en navngitt kodeblokk	`def beregn(x):`
Parametre	Dataen funksjonen tar imot	`def f(a, b):`
Returverdi	Resultat som sendes tilbake	`return areal`
Standardverdi	Forhåndsdefinert parameterverdi	`def f(x=10):`
Modul	Fil med gjenbrukbare funksjoner	`import math`

Fordeler med funksjoner:
- Gjenbruk: Skriv koden én gang, bruk den mange ganger
- Lesbarhet: Beskrivende funksjonsnavn gjør koden lettere å forstå
- Vedlikehold: Endringer gjøres ett sted, virker overalt
- Testing: Lettere å teste små, isolerte deler av programmet
Tommelfingerregel: Hvis du kopierer og limer inn den samme koden mer enn to ganger, bør du lage en funksjon.

📝Oppgave 4

Skriv en funksjon beregn_bmi(vekt_kg, hoyde_m) som beregner og returnerer BMI (body mass index). Formelen er $\displaystyle \text{BMI} = \frac{\text{vekt}}{\text{høyde}^2}$ . Skriv deretter et hovedprogram som bruker funksjonen: les inn vekt og høyde fra brukeren, beregn BMI, og skriv ut resultatet med én desimal samt en vurdering (under 18.5: «Undervekt», 18.5–24.9: «Normalvekt», 25–29.9: «Overvekt», 30+: «Fedme»).

📝Oppgave 5

Lag et program med tre funksjoner for enkel dataanalyse: a) generer_data(n) – genererer og returnerer en liste med n tilfeldige heltall mellom 1 og 100 (bruk random.randint). b) analyser_data(data) – tar inn en liste og returnerer gjennomsnitt, høyeste verdi og laveste verdi (bruk return snitt, maks, min_v). c) skriv_rapport(data, snitt, maks, min_v) – skriver en pent formatert rapport. Hovedprogrammet skal generere 15 tall, analysere dem og skrive rapporten.

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.