2.1 Funksjoner: def, parametere og return

En navngitt bit kode som utfører en bestemt oppgave, og som du kan bruke om igjen med ulike data.

To ting skjer med en funksjon, og de er lett å blande:

- Du definerer den én gang, med def. Da skjer det ingenting ennå — Python
bare noterer oppskriften.
- Du kaller den så mange ganger du vil, ved å skrive navnet med parentes
etter. Først da kjøres kroppen.

Alt du har brukt så langt med parentes etter navnet — print(...), int(...),
len(...) — er funksjoner. Nå skal du skrive dine egne.

Definerer en funksjon. Linja avsluttes med kolon, og kroppen står innrykket under:

def hils(navn):
    print("Hei,", navn)

hils("Ada")
hils("Nora")

Utskrift:

Hei, Ada
Hei, Nora

Legg merke til at kroppen kjøres to ganger, én gang per kall — men den er skrevet én gang.

Definisjonen må stå før kallet i programmet. Python leser filen ovenfra, og kjenner ikke et navn den ikke har sett ennå.

To ord for to sider av samme sak:

- Parameter er navnet i definisjonen: navn i def hils(navn):. Det er en
variabel som får en verdi når funksjonen kalles.
- Argument er verdien du sender inn ved kallet: "Ada" i hils("Ada").

En funksjon kan ha flere parametere, skilt med komma, og da er rekkefølgen avgjørende: det første argumentet havner i den første parameteren.

def vis(fornavn, etternavn):
    print(fornavn, etternavn)

vis("Ada", "Berg")
vis("Berg", "Ada")

Utskrift:

Ada Berg
Berg Ada

Python vet ingenting om hva navnene betyr — den fyller bare inn i rekkefølge.

Sender en verdi tilbake til den som kalte funksjonen:

def dobbel(tall):
    return tall * 2

svar = dobbel(21)
print(svar)
print(dobbel(5) + 1)

Utskrift:

42
11

To ting skjer samtidig når return kjøres. Funksjonen avsluttes umiddelbart
— ingen linjer under blir kjørt. Og verdien blir resultatet av kallet, slik at du kan lagre den i en variabel eller regne videre med den, som på siste linje.

return er derfor ikke det samme som print. print viser noe på skjermen;
return gir en verdi tilbake til programmet.

Kommer en funksjon til slutten av kroppen uten å ha kjørt en return, gir den tilbake None. Det er en egen verdi i Python, og den betyr «ingenting».

def uten_retur(x):
    y = x * 2

print(uten_retur(5))

Utskrift:

None

None er den vanligste kilden til forvirrende feil hos nybegynnere: programmet krasjer ikke der funksjonen ble skrevet, men et helt annet sted der noen prøver å regne med None.

Ser du None i en utskrift, er svaret nesten alltid at det mangler et return.

En funksjon kan ha så mange return den vil. Den som kjøres først, avslutter funksjonen:

def karakter(poeng):
    if poeng >= 90:
        return "A" elif poeng >= 60:
        return "C" return "F"

print(karakter(95), karakter(72), karakter(20))

Utskrift:

A C F

Legg merke til at siste linje ikke trenger else: kommer programmet dit i det hele tatt, betyr det at ingen av de tidligere return-ene kjørte.

Dette er en ryddig og helt vanlig form i fagets løsningsforslag, og den er lett å spore: finn den første betingelsen som er sann, så vet du hva funksjonen gir.

En funksjon kan returnere flere verdier på én gang, skilt med komma. Ved kallet tar du imot dem med like mange navn:

def del_og_rest(a, b):
    return a // b, a % b

hele, rest = del_og_rest(17, 5)
print(hele, rest)

Utskrift:

3 2

Antall navn på venstre side må stemme med antall verdier funksjonen returnerer.

Dette kalles å pakke ut returverdiene. Det er en ryddig løsning når to opplysninger naturlig hører sammen, og den finnes i fagets egne løsningsforslag.

En funksjon kan bruke en annen funksjon i kroppen sin, akkurat som du kaller den fra hovedprogrammet:

def er_vokal(tegn):
    return tegn == "a" or tegn == "e" or tegn == "i" or tegn == "o" or tegn == "u"

def tell_vokaler(tekst):
    antall = 0 for tegn in tekst:
        if er_vokal(tegn):
            antall = antall + 1 return antall

print(tell_vokaler("bibliotek"))

Utskrift:

4

Legg merke til hvordan if er_vokal(tegn): leser nesten som norsk. Det er poenget: en godt navngitt hjelpefunksjon gjør den ytre funksjonen kortere og lettere å lese.

På eksamen er dette uttrykkelig tillatt — du kan legge til egne hjelpefunksjoner ved behov, så lenge du kommenterer kort hva de gjør.

En liten funksjon som finnes for å gjøre en annen funksjon enklere. er_vokal over er et typisk eksempel: den gjør én ting, og den gjør den godt.

To grunner til at dette lønner seg på eksamen. Du får delkarakter per deloppgave, og en hjelpefunksjon som virker, gir uttelling selv om den store funksjonen ikke ble ferdig. Og du kan bruke en metode oppgaveteksten beskriver selv om du ikke selv rakk å skrive den — da kaller du den bare, som om den var ferdig.

Regelen for gode hjelpefunksjoner er enkel: én oppgave per funksjon, og et navn som sier hva den svarer på.

Linjene som kjøres når funksjonen kalles, altså de innrykkede linjene under
def.

Alt som lages i kroppen — tellere, mellomregninger — finnes bare mens funksjonen kjører, og forsvinner når den returnerer. Det er derfor en teller kan settes til null i kroppen uten at gamle kall påvirker nye.

Reglene for hva som er synlig hvor, kalles scope, og de er tema i
kap. 2.2.

Å ta imot flere returverdier med like mange navn: hele, rest = del_og_rest(17, 5).

Antallet må stemme. To verdier og tre navn gir en feilmelding, og det samme gjør det motsatte.

Tar du imot med ett navn i stedet, får du begge verdiene samlet som et par — det er derfor print(min_og_maks(4, 4, 4)) viser (4, 4) med parentes.

Et funksjonskall er et uttrykk med en verdi, og kan derfor brukes overalt en verdi kan stå: i et regnestykke (dobbel(5) + 1), som argument til en annen funksjon (print(tell_tegn(...))), eller som betingelse (if f(tekst):).

Den siste formen forutsetter at funksjonen returnerer True eller False, og den er vanlig i fagets fasiter fordi den leser som norsk.

Du trenger altså ikke lagre svaret i en variabel først — men gjør det gjerne hvis det gjør koden lettere å lese.

Skriver du bare trippel(4) på en linje for seg, kjøres funksjonen, verdien regnes ut, og så kastes den.

Det er ikke en feil, og for funksjoner som skriver ut noe selv, er det helt riktig bruk. Men returnerer funksjonen en verdi du trenger, er en slik linje nesten alltid en forglemmelse: du har glemt print eller glemt å lagre svaret.

I en sporingsoppgave betyr det at linja ikke gir noen utskrift.

To atskilte hendelser, og skillet er verdt å ha helt klart.

Definisjonen (def dobbel(tall): med kroppen under) forteller Python hvordan
noe skal gjøres. Når linja leses, skjer det ingenting annet enn at navnet blir kjent.

Kallet (dobbel(4)) er det som faktisk kjører kroppen. Uten et kall blir en
funksjon aldri brukt, uansett hvor riktig den er skrevet.

I en sporingsoppgave betyr det at du kan hoppe over hele def-blokken ved første gjennomlesing, og først lese kroppen når du kommer til et kall.

Argumentene fylles inn i parameterne i den rekkefølgen de står — det første argumentet i den første parameteren, og så videre.

Python vet ingenting om hva navnene betyr. Kaller du vis("Berg", "Ada") når funksjonen forventer fornavn først, får du ingen feilmelding; du får bare feil svar.

Antallet må derimot stemme: for få eller for mange argumenter gir en feilmelding med én gang.

En funksjon som returnerer True eller False. er_vokal(tegn) og
ingen_mellomrom(tekst) er begge boolske.

Slike funksjoner kan brukes direkte som betingelse: if er_vokal(tegn):.
Det leser som norsk, og det er den formen fagets løsningsforslag bruker.

Navngi dem som et ja-eller-nei-spørsmål — er_…, har_…, alle_…, ingen_…
— så vet leseren hva et True betyr uten å lese kroppen.

Speilbildet av flagg med tidlig retur, brukt når du leter etter ett treff i stedet for å kreve at alle oppfyller noe:

- inne i løkka: return True ved første treff,
- etter løkka: return False.

Merk hvilket svar som står hvor. Det svaret som kan avgjøres av ett enkelt element, hører inne i løkka; det som krever at hele samlingen er undersøkt, hører etter.

Blander du de to mønstrene, får du feilkode #7.

Du kan skrive bare return på en linje. Da avsluttes funksjonen umiddelbart, og den gir None tilbake.

Formen brukes når funksjonen skriver ut noe selv og du vil avbryte tidlig, for eksempel etter en feilmelding til brukeren.

Ber oppgaven om en verdi, er en bar return derimot nesten alltid en forglemmelse — svaret ble aldri sendt tilbake.

Variabler som lages inne i en funksjonskropp, finnes bare mens funksjonen kjører, og lages på nytt ved hvert kall.

Det er derfor antall = 0 i tell_tegn ikke husker noe fra forrige kall — hvert kall starter med blanke ark. Egenskapen er hele grunnen til at en funksjon kan brukes om igjen med nye data.

Den samme egenskapen er kilden til self-fella i
kap. 5.1: en variabel som bare lages lokalt, forsvinner når metoden er ferdig.

Ett konkret kall med konkrete verdier som viser at en funksjon gir galt svar:
«alle_like("aab") gir True, men skulle gitt False».

Formen er et eksplisitt krav på eksamen. En forklaring i ord om at «funksjonen håndterer ikke flere ulike tegn» er en halv besvarelse; moteksempelet er en hel.

Slik finner du et: let etter et kanttilfelle — tom inndata, ett element, like verdier, eller data der feilen slår inn først etter første runde.

Sjangeren har eget kapittel i kap. 4.2.

Funksjonsnavnet skal si hva funksjonen gir, ikke hvordan den regner det ut.
tell_tegn, lengste_lengde og er_vokal er gode navn; funksjon2 og gjor er det ikke.

Norske navn er helt greie og er stilen i fagets egne løsningsforslag — men
ingen æ, ø eller å i koden. Skriv stoerst, laan, baat.

Bruk aldri navnet på en innebygd funksjon (sum, len, input, str) — det er feilkode #13, og den er stum.

På eksamen har du lov til å kalle en funksjon eller metode som er beskrevet i oppgaveteksten, selv om du ikke selv fikk skrevet den — eller ikke rakk å bli ferdig med deloppgaven der den skulle stå.

Dette er grunnen til at man aldri skal stå fast. Klarte du ikke deloppgave c, skriver du likevel deloppgave d som om c var ferdig, og kaller funksjonen derfra.

Det samme gjelder dine egne hjelpefunksjoner: du kan legge til dem du trenger, så lenge du kommenterer kort hva de gjør.