5.3 Kontrollstrukturer
If-setninger, for-løkker og while-løkker.
35 min
6 oppgaver
If-setningerFor-løkkerWhile-løkkerBetingelser
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:
``python
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
(små bokstaver med understrek)
- Velg beskrivende navn som forklarer hva funksjonen gjør
- Eksempler: beregnareal(), lestemperatur(), skrivrapport()`Parametre og argumenter
Parametre gjør funksjoner fleksible – de lar deg sende inn ulike data hver gang du kaller funksjonen.
``python
def hilsperson(navn): # 'navn' er en parameter
print(f"Hei, {navn}!")
hilsperson("Ola") # "Ola" er et argument
hilsperson("Kari") # "Kari" er et argument
`
Du kan ha flere parametre, separert med komma:
`python
def beskrivmaling(sted, temperatur, tid):
print(f"Sted: {sted}")
print(f"Temperatur: {temperatur} °C")
print(f"Tidspunkt: {tid}")
beskrivmaling("Oslo", 18.5, "14:30")
beskrivmaling("Bergen", 15.2, "09:00")
`
Standardverdier lar deg gi parametre forhåndsdefinerte verdier:
`python
def beregnkraft(masse, akselerasjon=9.81):
kraft = masse * akselerasjon
print(f"Kraft: {kraft:.1f} N")
beregnkraft(10) # Bruker standardverdien 9.81
beregn_kraft(10, 3.7) # Overstyrer med 3.7 (f.eks. Mars)
``
✏️Eksempel: Funksjon for temperaturomregning
Skriv en funksjon celsiustilfahrenheit(celsius) som regner om Celsius til Fahrenheit, og en funksjon fahrenheittilcelsius(fahrenheit) som regner den andre veien. Test begge.
``python
def celsiustilfahrenheit(celsius):
fahrenheit = celsius * 1.8 + 32
print(f"{celsius} °C = {fahrenheit:.1f} °F")
def fahrenheittilcelsius(fahrenheit):
celsius = (fahrenheit - 32) / 1.8
print(f"{fahrenheit} °F = {celsius:.1f} °C")
Test:
celsiustilfahrenheit(0) # 0 °C = 32.0 °F
celsiustilfahrenheit(100) # 100 °C = 212.0 °F
fahrenheittilcelsius(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?
``python
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.
``python
def beregnareal(radius):
areal = 3.14159 radius 2
return areal
Bruk returverdien:
mittareal = beregnareal(5.0)
print(f"Arealet er {mittareal:.2f}") # Arealet er 78.54
`
Forskjellen mellom
og return:
- print() viser verdien på skjermen, men lagrer den ikke
- return sender verdien tilbake slik at den kan brukes videre i programmet`python
Med print – kan ikke bruke resultatet videre:
def arealprint(r):
print(3.14159 r * 2)Med return – resultatet kan lagres og brukes:
def arealreturn(r):
return 3.14159 r * 2resultat = arealreturn(3.0) # resultat = 28.27...
dobbelt = resultat 2 # Kan brukes videre!
`En funksjon kan returnere flere verdier ved å skille dem med komma:
python
def beregnsirkel(radius):
areal = 3.14159 radius 2
omkrets = 2 3.14159 * radius
return areal, omkretsa, o = beregn_sirkel(5.0)
print(f"Areal: {a:.1f}, Omkrets: {o:.1f}")
``✏️Eksempel: Statistikkfunksjoner
Skriv en funksjon beregngjennomsnitt(verdier) som tar inn en liste med tall og returnerer gjennomsnittet. Skriv også en funksjon finnmaks(verdier) som returnerer den høyeste verdien.
``python
def beregngjennomsnitt(verdier):
total = 0
for v in verdier:
total = total + v
return total / len(verdier)
def finnmaks(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 = beregngjennomsnitt(temperaturer)
maks = finnmaks(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?
``python
def leggtil(a, b):
return a + b
def doble(x):
return x * 2
resultat = doble(leggtil(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:
``python
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:
`python
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()` |
Moduler i praksis
Her er et eksempel som bruker flere moduler for å simulere et vitenskapelig eksperiment:
``python
import math
import random
import statistics
Generere simulerte temperaturdata med støy
malinger = []
for i in range(20):
sanntemp = 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(sanntemp + stoy)
Bruke statistics-modulen for analyse
gjennomsnitt = statistics.mean(malinger)
stdavvik = statistics.stdev(malinger)
print(f"Antall målinger: {len(malinger)}")
print(f"Gjennomsnitt: {gjennomsnitt:.2f} °C")
print(f"Standardavvik: {std
`
Du kan også lage dine egne moduler ved å lagre funksjoner i en Python-fil. Hvis du lagrer funksjoner i
, kan du importere dem i et annet program med import minefunksjoner`.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 beregnbmi(vektkg, hoyde_m) som beregner og returnerer BMI (body mass index). Formelen er . 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) genererdata(n) – genererer og returnerer en liste med n tilfeldige heltall mellom 1 og 100 (bruk random.randint). b) analyserdata(data) – tar inn en liste og returnerer gjennomsnitt, høyeste verdi og laveste verdi (bruk return snitt, maks, minv). c) skrivrapport(data, snitt, maks, min_v) – skriver en pent formatert rapport. Hovedprogrammet skal generere 15 tall, analysere dem og skrive rapporten.