Oversikt

Del 3 på eksamen er 3–5 oppgaver av typen «Skriv en funksjon …», til sammen 23–36 poeng. Oppgaveteksten oppgir alltid funksjonsnavn, parametre og ett eller to eksempelkall med forventet returverdi. Bruk eksempelkallene som fasit mens du skriver — det er den enkleste måten å sikre poeng på.

Funksjon eller prosedyre

Skillet er avgjørende for poengsummen:

Står det «returnerer» i oppgaveteksten, skal du bruke return.
Står det «skriver ut», skal du bruke print.

Bytter du om, mister du poeng selv om logikken er korrekt. En funksjon uten return returnerer None:

def skriv_pris(pris):
    print("Pris:", pris, "kr")

svar = skriv_pris(99)
print(svar)        # None

Parametre er lokale

def dobbel(t):
    t = t * 2

x = 5
dobbel(x)
print(x)          # 5, ikke 10

Tilordningen inne i funksjonen treffer bare den lokale parameteren. Tall og strenger er uforanderlige, så kallerens variabel er urørt.

Lister og ordbøker er annerledes — de sendes som referanse:

def nuller_ut(liste):
    for i in range(len(liste)):
        liste[i] = 0        # ENDRER kallerens liste

def gir_ny(liste):
    liste = [0, 0, 0]       # endrer BARE den lokale referansen

Skillet mellom å endre objektet og å peke et annet sted er nøyaktig det samme som for objekter i klasser, og det er testet direkte som flervalgsoppgave flere ganger.

Flere returpunkter

return avslutter funksjonen umiddelbart. Det gir et svært nyttig mønster for ja/nei-spørsmål:

def alle_like(tallene):
    if len(tallene) == 0:
        return True
    forste = tallene[0]
    for t in tallene:
        if t != forste:
            return False
    return True

Legg merke til at return True står etter løkka. Kommer vi gjennom hele lista uten motbevis, er påstanden sann. Skriver du else: return True inne i løkka, svarer funksjonen etter å ha sett på bare det første elementet — en av de vanligste feilene i Del 3.

Funksjoner som kaller funksjoner

Eksamensoppgavene er bygget i lag: deloppgave b bruker funksjonen fra deloppgave a, c bruker b, og så videre. Oppgaveteksten sier eksplisitt at du kan bruke funksjonene selv om du ikke har løst dem. Det er en poenggaranti du skal utnytte:

def poeng(tekst):
    if tekst == "joker":
        return 0
    return len(tekst)

def poengsum(kort):
    total = 0
    for t in kort:
        total += poeng(t)
    return total

print(poengsum(["hjerte", "joker", "kong"]))   # 6 + 0 + 4 = 10

Refaktorering — fjern gjentatt kode

Denne oppgavetypen har stått på flere eksamenssett: du får et program med to nesten like blokker og skal skrive det om til én gjenbrukbar funksjon som kalles to ganger. Det som gir poeng er (1) at funksjonen har en parameter, (2) at den kalles to ganger, og (3) at utskriften blir nøyaktig den samme.

def tell_forekomster(elementer):
    resultat = {}
    for e in elementer:
        if e not in resultat:
            resultat[e] = 0
        resultat[e] += 1
    return resultat

def skriv_antall(elementer):
    tabell = tell_forekomster(elementer)
    for n in tabell:
        print("Antall", n, ":", tabell[n])

skriv_antall(["F", "E", "R", "S", "K"])
skriv_antall(["Flodhest", "er", "best"])

Merk at print med komma setter inn ett mellomrom mellom argumentene, så utskriften blir Antall F : 1 — med mellomrom foran kolonet. Skal utskriften være «nøyaktig den samme», teller den detaljen.

Lokale variabler og kallrekkefølge

teller = 0

def okt():
    teller = 0
    teller = teller + 1
    return teller

print(okt(), okt(), teller)    # 1 1 0

Variabelen inne i funksjonen er ny hver gang. Vil du at en verdi skal huskes mellom kall, må den enten returneres og lagres av kalleren, eller ligge som instansvariabel i et objekt. Det siste er hele grunnen til at vi har klasser.

Når en funksjon kaller en annen, settes den første på vent til den andre er ferdig. Det som starter sist, avsluttes først.

Parametre og argumenter

Parameter er navnet i definisjonen, argument er verdien du sender inn. Rekkefølgen avgjør hvilken verdi som havner hvor:

def karantene(vaksinert, farge):
    if vaksinert:
        return 0
    if farge == "groenn":
        return 3
    return 10

print(karantene(False, "groenn"))   # 3
print(karantene("groenn", False))   # 0  — feil rekkefolge, ingen feilmelding!

Det andre kallet gir 0 fordi strengen "groenn" regnes som sann i en if-test. Ingen feilmelding, bare feil svar. Kontroller alltid parameterrekkefølgen mot eksempelkallene i oppgaveteksten.

Funksjoner som returnerer flere typer

Samme funksjon kan returnere ulike typer avhengig av situasjonen, og det er ofte akkurat det oppgaven ber om:

def flertall(dyreliste):
    antall = {}
    for dyr in dyreliste:
        if dyr not in antall:
            antall[dyr] = 0
        antall[dyr] += 1
    beste = None
    uavgjort = False
    for dyr in antall:
        if beste is None or antall[dyr] > antall[beste]:
            beste = dyr
            uavgjort = False
        elif antall[dyr] == antall[beste]:
            uavgjort = True
    if uavgjort:
        return "uavgjort"
    return beste

print(flertall(["ulv", "sau", "ulv"]))           # ulv
print(flertall(["ulv", "sau", "sau", "ulv"]))    # uavgjort

Legg merke til at uavgjort settes tilbake til False når en ny leder finnes. Uten den linja ville en tidligere likhet «henge igjen» og gi feil svar.

Prosedyrer med sideeffekt

def skriv_oversikt(ordbok):
    for n in ordbok:
        print(n, ":", ordbok[n])

En prosedyre skriver ut eller endrer noe, men returnerer None. Den bør ikke både skrive ut og returnere — da blir det uklart for kalleren hva som er hensikten, og oppgaveteksten skiller alltid tydelig mellom de to.

Skrivestrategi under eksamen

Les eksempelkallene og skriv dem ned som assert-linjer.
Skriv funksjonssignaturen nøyaktig som oppgitt — samme navn, samme parameterrekkefølge.
Velg akkumulator (0, "", [], {}) og initialiser den før løkka.
Skriv løkka.
Sett return på riktig innrykksnivå — inne i løkka for «første treff», etter løkka for «etter å ha sett på alt».
Kjør assert-linjene i hodet, med et grensetilfelle i tillegg (tom liste, likhet, negativ verdi).

Studieguide: Funksjoner