3.4 Funksjoner og modularitet | Elektro og datateknologi VG1

Definere og bruke funksjoner, parametre og returverdier for gjenbrukbar kode.

55 min

6 oppgaver

FunksjonerParametreReturverdierModulariseringScope

Du leser den tradisjonelle versjonen

Din fremgang i kapitlet

0 / 6 oppgaver

Funksjoner og modularitet

Når programmer blir større, blir det vanskelig å holde oversikt. Funksjoner lar oss dele opp koden i gjenbrukbare, navngitte blokker som hver løser én oppgave. Du har allerede brukt innebygde funksjoner som print(), input() og range(). Nå skal du lære å lage dine egne.

Fordeler med funksjoner:
- Gjenbruk: Skriv koden én gang, bruk den mange ganger
- Oversikt: Programmet blir lettere å lese og forstå
- Feilsøking: Lettere å finne og fikse feil i isolerte blokker
- Samarbeid: Ulike personer kan jobbe med ulike funksjoner

Definere funksjoner med def

Vi lager en funksjon med nøkkelordet def, etterfulgt av funksjonsnavnet og parenteser: def hilsen(): print("Hei og velkommen!") print("Hyggelig å se deg.") For å kalle (bruke) funksjonen skriver vi navnet med parenteser: hilsen() # Kjører koden inne i funksjonen hilsen() # Vi kan kalle den så mange ganger vi vil Viktig: Funksjonen må defineres før den kalles. Python leser koden ovenfra og ned.

✏️En enkel funksjon

Lag en funksjon som skriver ut en adskiller-linje for å gjøre utskrifter ryddigere.

def skriv_linje():
    print("-" * 40)

skriv_linje()
print("Rapport: Spenning i krets A")
skriv_linje()
print("Måling 1: 5.2V")
print("Måling 2: 5.1V")
skriv_linje()

Output:

----------------------------------------
Rapport: Spenning i krets A
----------------------------------------
Måling 1: 5.2V
Måling 2: 5.1V
----------------------------------------

📝Oppgave 1

Hva er riktig måte å definere en funksjon i Python?

Parametre og returverdier

Parametre er verdier vi sender inn til en funksjon. Returverdier er resultatet funksjonen gir tilbake. def adder(a, b): # a og b er parametre return a + b # return sender verdien tilbake resultat = adder(3, 5) # 3 og 5 er argumenter print(resultat) # 8 En funksjon kan ta null, én eller flere parametre. Uten return returnerer funksjonen None . def beregn_areal(lengde, bredde): return lengde * bredde areal = beregn_areal(5, 3) print("Arealet er:", areal) # Arealet er: 15

✏️Ohms lov som funksjon

Lag en funksjon som beregner motstand ved hjelp av Ohms lov: R = U / I.

def beregn_motstand(spenning, strom):
    if strom == 0:
        return None   # Kan ikke dele på null
    return spenning / strom

# Bruk funksjonen
r1 = beregn_motstand(12, 0.5)
r2 = beregn_motstand(5, 0.1)

print("Motstand 1:", r1, "ohm")  # 24.0 ohm
print("Motstand 2:", r2, "ohm")  # 50.0 ohm

Funksjonen tar spenning og strøm som parametre og returnerer motstanden. Ved strøm lik 0 returneres None for å unngå feil.

📝Oppgave 2

Lag en funksjon beregn_effekt(spenning, strom) som returnerer effekten P = U × I. Test funksjonen med spenning 230V og strøm 0.5A.

📝Oppgave 3

Hva returnerer denne funksjonen når vi kaller dobbel(4)?

def dobbel(x):
    resultat = x * 2
    print(resultat)

Standardverdier for parametre

Vi kan gi parametre en standardverdi (default). Da trenger ikke brukeren å oppgi alle argumenter: def hilsen(navn, sprk="norsk"): if sprk == "norsk": print(f"Hei, {navn}!") elif sprk == "engelsk": print(f"Hello, {navn}!") hilsen("Kari") # Hei, Kari! (bruker standard "norsk") hilsen("Kari", "engelsk") # Hello, Kari! Regler: - Parametre med standardverdi må komme etter parametre uten - Standardverdier gjør funksjoner mer fleksible - Du kan overstyre standardverdien ved å sende inn et argument

✏️Motstandsberegning med enhet

Lag en funksjon som beregner og formaterer motstand med valgfri enhet.

def vis_motstand(spenning, strom, enhet="ohm"):
    motstand = spenning / strom
    if enhet == "kohm":
        motstand = motstand / 1000
    return f"{motstand:.1f} {enhet}"

print(vis_motstand(12, 0.001))           # 12000.0 ohm
print(vis_motstand(12, 0.001, "kohm"))   # 12.0 kohm

Når vi ikke oppgir enhet, brukes standardverdien "ohm". Ved behov kan vi oppgi "kohm" for kilo-ohm.

📝Oppgave 4

Lag en funksjon celsius_til(temp, enhet="fahrenheit") som konverterer en temperatur fra Celsius til enten Fahrenheit (F = C × 9/5 + 32) eller Kelvin (K = C + 273.15).

Test funksjonen med:
- celsius_til(100) → skal gi Fahrenheit
- celsius_til(0, "kelvin") → skal gi Kelvin

Scope: lokale og globale variabler

Scope handler om hvor en variabel er tilgjengelig. Lokale variabler er opprettet inne i en funksjon og finnes bare der: def min_funksjon(): x = 10 # Lokal variabel print(x) # 10 min_funksjon() print(x) # Feil! x finnes ikke utenfor funksjonen Globale variabler er opprettet utenfor funksjoner og kan leses overalt: melding = "Hei" # Global variabel def skriv(): print(melding) # Kan lese globale variabler skriv() # Hei Viktig: Unngå å endre globale variabler inne i funksjoner. Bruk heller parametre og returverdier for å sende data inn og ut av funksjoner.

Tenk på funksjoner som selvstendige enheter:
- Inn: Data sendes inn via parametre
- Ut: Resultater sendes ut via return
- Unngå: Å bruke globale variabler inne i funksjoner

# Dårlig praksis
total = 0
def legg_til(tall):
    global total    # Endrer global variabel
    total = total + tall

# God praksis
def legg_til(total, tall):
    return total + tall

total = legg_til(0, 5)   # total = 5
total = legg_til(total, 3) # total = 8

📝Oppgave 5

Hva skrives ut av denne koden?

x = 5

def endre():
    x = 10
    print(x)

endre()
print(x)

📝Oppgave 6

Lag et program med tre funksjoner for å beregne elektrisk effekt på ulike måter:

1. effekt_ui(spenning, strom) — beregner P = U × I
2. effekt_ri(motstand, strom) — beregner P = R × I²
3. effekt_ur(spenning, motstand) — beregner P = U² / R

Test alle tre funksjonene med verdier der U = 12V, I = 2A, R = 6Ω og verifiser at alle gir samme resultat (24W).

Oppsummering

I dette kapittelet har du lært:

- Funksjoner er navngitte kodeblokker som gjør programmet modulært og gjenbrukbart
- Parametre og argumenter lar funksjoner ta imot data
- Returverdier med return gir resultater tilbake fra funksjonen
- Standardverdier for parametre gjør funksjonskall mer fleksible
- Lokalt og globalt scope bestemmer hvor variabler er tilgjengelige
- Funksjoner gjør koden lettere å lese, teste og vedlikeholde

Nøkkelbegreper

Begrep	Forklaring
Funksjon	Navngitt kodeblokk som utfører en oppgave
Parameter	Variabel i funksjonsdefinisjonen
Argument	Verdi som sendes til funksjonen ved kall
Returverdi	Verdien funksjonen gir tilbake
Standardverdi	Forhåndsdefinert verdi for en parameter
Scope	Området der en variabel er tilgjengelig

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.