2.5 Funksjoner og gjenbruk

Slutt å kopiere og lime

Tenk deg at du har skrevet kode som regner ut gjennomsnittet av tre tall, og trenger den flere steder. Du kan kopiere og lime inn – men det gir duplisering, flere feil og vondt vedlikehold. Funksjoner løser dette.

En funksjon er en navngitt, gjenbrukbar kodeblokk som utfører en bestemt oppgave. Du har faktisk brukt funksjoner hele tiden: print(), input(), int() og range(). Nå skal du lage dine egne. Tenk på en funksjon som en maskin: du putter noe inn (parametere), maskinen jobber, og du får noe ut (returverdi).

Du definerer en funksjon med def:

def si_hei():
    print("Hei! Velkommen!")

si_hei()
si_hei()

Viktig: å definere en funksjon kjører den ikke. Koden inni kjøres først når du kaller den ved å skrive navnet med parenteser. For å gjøre funksjonen fleksibel sender du verdier inn via parametere:

def hils_paa(navn):
    print(f"Hei, {navn}!")

hils_paa("Sara")

Her er navn en parameter i definisjonen, mens "Sara" er et argument du sender inn. Du kan ha flere parametere, som presenter(fornavn, etternavn, alder) – men da må rekkefølgen på argumentene matche rekkefølgen på parameterne.

Å få noe tilbake

Mange funksjoner skal ikke bare gjøre noe – de skal regne ut noe og gi svaret tilbake. Det gjør de med return:

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

resultat = beregn_areal(5, 3)  # resultat = 15

Når Python møter return, stopper funksjonen umiddelbart og sender verdien tilbake. Kode etter return i samme funksjon kjøres aldri. Tommelfingerregelen er: regner funksjonen ut noe, bruk return; gjør den bare en handling som å skrive ut tekst, trenger du den ikke. En funksjon uten return returnerer automatisk None. Du kan til og med returnere flere verdier samtidig: return summen, gjennomsnitt, storste kan pakkes ut med s, g, maks = ....

Dette leder oss til scope – hvor en variabel er tilgjengelig. Lokale variabler opprettes inne i en funksjon og finnes bare mens funksjonen kjører; de kan ikke brukes utenfor. Også parametere er lokale. Globale variabler opprettes utenfor alle funksjoner og kan leses overalt:

melding = "Hei utenfra"
def min_funksjon():
    lokal = "Hei innenfra"
    print(lokal)    # ok
    print(melding)  # ok, kan lese global
min_funksjon()
# print(lokal)  # FEIL – finnes ikke her

Funksjoner kan lese globale variabler, men for å endre dem må du bruke global – noe du som hovedregel bør unngå. Bruk heller parametere og returverdier. Du kan også gi parametere standardverdier med def hils(navn, hilsen="Hei"), men parametere med standardverdi må komme sist.

Stå på skuldrene til andre

Du trenger ikke skrive alt selv. Python kommer med hundrevis av ferdige moduler fulle av nyttige funksjoner. Du henter dem inn med import:

import math
print(math.pi)        # 3.141592653589793
print(math.sqrt(16))  # 4.0

Det finnes flere måter å importere på. import random lar deg skrive random.randint(1, 10). from random import randint lar deg droppe random.-forstavelsen og bare skrive randint(1, 10). Og import random as rnd gir modulen et kortere kallenavn. Blant de mest nyttige standardmodulene er math (matematikk), random (tilfeldige tall), datetime (dato og tid), os (operativsystem) og string (tekst).

La oss samle alt i et eksempel – en BMI-kalkulator delt i to funksjoner med klare oppgaver:

def beregn_bmi(vekt_kg, hoyde_m):
    """Beregner BMI fra vekt i kg og høyde i meter."""
    return round(vekt_kg / (hoyde_m ** 2), 1)

def bmi_kategori(bmi):
    if bmi < 18.5:
        return "Undervekt"
    elif bmi < 25:
        return "Normalvekt"
    elif bmi < 30:
        return "Overvekt"
    else:
        return "Fedme"

For en person på 70 kg og 1,75 m gir dette BMI 22.9 og kategorien «Normalvekt». Teksten i trippel-anførselstegn øverst i beregn_bmi er en docstring – innebygd dokumentasjon som forklarer hva funksjonen gjør. Ved å dele programmet i små funksjoner med klare ansvarsområder blir koden lettere å lese, teste og gjenbruke.

Oppsummering

Funksjoner er gjenbrukbare kodeblokker som lar deg slutte å kopiere og lime. Du definerer dem med def, sender data inn via parametere (argumentene er verdiene du faktisk gir), og får svar tilbake med return. Husk at å definere en funksjon ikke kjører den – det skjer først når du kaller den.

Scope styrer hvor variabler lever: lokale variabler finnes bare inne i funksjonen, mens globale kan leses overalt. Som hovedregel kommuniserer du via parametere og returverdier framfor globale variabler. Til slutt kan du importere moduler som math, random og datetime for å gjenbruke ferdig kode. Med funksjoner og moduler kan du bygge større programmer som er ryddige, lette å teste og enkle å vedlikeholde.