2.1 Funksjoner: def, parametere og return

Nøkkelordet def innfører en ny funksjon. Etter def står navnet, så parameterne i parentes, så et kolon. Alt som hører til funksjonen, står rykket inn fire mellomrom under. Den første linja uten innrykk er utenfor funksjonen igjen.

Å definere en funksjon utfører den ikke. Definisjonen sier bare hva som skal skje hvis noen kaller den senere.

def pant(flasker):
    return flasker * 2

print(pant(6))

Utskrift:

12

Et kall er navnet etterfulgt av parentes med verdiene funksjonen skal jobbe på: pant(6). Parentesen er obligatorisk. Skriver du bare pant, refererer du til funksjonen selv og ikke til resultatet av å kjøre den.

Kallet er et uttrykk: det har en verdi, og den verdien kan du lagre i en variabel, regne videre med eller sende rett inn i print.

def pant(flasker):
    return flasker * 2

kvittering = pant(6)
print(kvittering)
print(type(pant))

Utskrift:

12
<class 'function'>

Den siste linja viser forskjellen: pant uten parentes er selve funksjonen, pant(6) er tallet den gir tilbake.

I def pant(flasker): er flasker en parameter. I kallet pant(6) er 6 argumentet. Ordene forveksles ofte, men på eksamen står de i oppgaveteksten: «funksjonen skal ta én parameter» betyr at def-linja skal ha nøyaktig ett navn i parentesen.

En funksjon kan ha flere parametere, skilt med komma, og den kan ha null: def meny(): er en helt lovlig definisjon.

Sender du argumentene rett fram, kobles de til parameterne etter rekkefølge: første argument til første parameter, andre til andre. Rekkefølgen er alt — Python kan ikke vite hva du mente.

def differanse(a, b):
    return a - b

print(differanse(10, 3))
print(differanse(3, 10))

Utskrift:

7
-7

Samme funksjon, samme to tall, to helt forskjellige svar. Bytter du om argumentene i en oppgave om for eksempel prisendring, får du fortegnsfeil i hele resten av besvarelsen.

Du kan også navngi argumentene i kallet: differanse(b=3, a=10). Da spiller rekkefølgen ingen rolle, fordi hvert argument sier selv hvilken parameter det hører til.

Navngitte argumenter må stå etter eventuelle posisjonsargumenter i kallet. Bokas kode bruker dem mest når en funksjon har mange parametere og kallet ellers blir uleselig.

def differanse(a, b):
    return a - b

print(differanse(b=3, a=10))
print(differanse(10, b=3))

Utskrift:

7
7

En parameter kan få en standardverdi i def-linja. Da er argumentet valgfritt i kallet: utelater du det, brukes standardverdien; oppgir du det, overstyres den.

Parametere med standardverdi må stå sist i parameterlista. def f(prosent=10, pris) er en syntaksfeil.

def rabattpris(pris, prosent=10):
    return pris - pris * prosent / 100

print(rabattpris(200))
print(rabattpris(200, 25))

Utskrift:

180.0
150.0

Merk at svarene er 180.0 og 150.0, ikke 180 og 150: / gir alltid et flyttall, også når regnestykket går opp.

Verdien kan være av hvilken som helst type: et tall, en streng, en boolsk verdi, en liste. Er det en liste eller et tall du har regnet ut i en løkke, er det den ferdige verdien etter løkka du returnerer.

def sum_av(verdier):
    total = 0
    for v in verdier:
        total = total + v
    return total

resultat = sum_av([12, 7, 31])
print(resultat + 100)

Utskrift:

150

Fordi sum_av([12, 7, 31]) er tallet 50, kan du regne videre med kallet på samme måte som med et hvilket som helst annet tall.

None dukker opp av seg selv i to situasjoner du må kjenne igjen: når en funksjon mangler return, og når et søk ikke fant noe (return None er bokas standardsvar på «ikke funnet»).

verdi = None
print(verdi)
print(verdi is None)

Utskrift:

None
True

Bruk is None og ikke == None når du tester. Begge virker, men is None er formen fasitene bruker.

Faller kjøringen ut nederst i funksjonen uten å møte et return, returnerer funksjonen None automatisk. Det gjelder også funksjoner som bare skriver ut noe.

Dette er den vanligste enkeltfeilen i besvarelser: oppgaven ber om en funksjon som returnerer et resultat, kandidaten skriver print i stedet, og alt som skal bruke resultatet videre, får None.

def vis_sum(a, b):
    print(a + b)

svar = vis_sum(3, 4)
print(svar)

Utskrift:

7
None

Den første linja i utskriften kommer fra print inne i funksjonen. Den andre viser hva funksjonen faktisk ga tilbake: None.

Så snart return kjøres, hopper Python ut av funksjonen. Kode som står etter, kjøres aldri — heller ikke resten av en løkke return står inne i.

Det er en egenskap du bruker med vilje: står return inne i en if inne i en løkke, stopper funksjonen i det øyeblikket den har funnet svaret sitt.

def finn_forste_negative(verdier):
    for v in verdier:
        if v < 0:
            return v
    return None

print(finn_forste_negative([4, 9, -2, -7]))
print(finn_forste_negative([4, 9]))

Utskrift:

-2
None

Det siste return None står utenfor løkka og nås bare hvis løkka gikk helt gjennom uten å finne noe. Nettopp den linja er «ikke funnet»-tilfellet sensor ser etter.

Regelen i bokas kode, og i fasitene: funksjoner som regner ut noe, returnerer; utskriften skjer der resultatet brukes. Da kan den samme funksjonen gjenbrukes i en senere deloppgave som skal regne videre — og gjenbruk er noe sensor belønner.

Ber oppgaveteksten uttrykkelig om at funksjonen skal skrive ut noe, gjør du selvsagt det. Nøkkelordene i teksten er «returnerer» mot «skriver ut».

Skriver du flere verdier etter return, skilt med komma, pakkes de sammen til ett tuppel — en fast, uforanderlig gruppe verdier — og det er tuppelet som returneres.

Du trenger ikke kunne tuppel-apparatet ennå (det kommer i kap. 3.6); du trenger bare å vite at det du får tilbake, inneholder verdiene i den rekkefølgen du skrev dem.

def del_og_rest(teller, nevner):
    return teller // nevner, teller % nevner

print(del_og_rest(17, 5))

Utskrift:

(3, 2)

Utskriften viser parentesene og komma mellom verdiene — slik skriver Python et tuppel. Skulle du hatt tallene hver for seg, pakker du dem ut.

Står det like mange navn på venstre side av likhetstegnet som det er verdier på høyre, får hvert navn sin verdi. Det er dette som gjør flere returverdier praktisk.

Antallet må stemme nøyaktig. To navn og tre verdier gir feilmeldingen ValueError: too many values to unpack, som avbryter programmet.

def del_og_rest(teller, nevner):
    return teller // nevner, teller % nevner

hele, rest = del_og_rest(17, 5)
print('Hele:', hele)
print('Rest:', rest)

Utskrift:

Hele: 3
Rest: 2

Rekkefølgen er den samme som i return-linja. Bytter du om navnene på venstre side, bytter du om betydningen — og det er ingen feilmelding som redder deg.

En variabel som får verdi inne i en funksjon — enten som parameter eller ved tilordning — er lokal. Den opprettes når funksjonen kalles og forsvinner når den returnerer.

Prøver du å bruke den utenfor, får du NameError, og programmet stopper.

def regn_ut():
    svar = 42
    print('Inne i funksjonen:', svar)

regn_ut()
print('Etter kallet finnes ikke svar lenger.')

Utskrift:

Inne i funksjonen: 42
Etter kallet finnes ikke svar lenger.

En variabel som lages på modulnivå — helt til venstre i fila, utenfor alle funksjoner — kan leses inne i en funksjon uten videre.

Bokas kode bruker dette bare til konstanter: verdier som ikke endrer seg, skrevet med store bokstaver (MVA_SATS, MAKS_LAAN). Alt annet sendes inn som parameter, fordi en funksjon som henter data fra det store rommet rundt seg, ikke lenger kan gjenbrukes uten det rommet.

MVA_SATS = 0.25

def med_mva(pris):
    return pris * (1 + MVA_SATS)

print(med_mva(400))

Utskrift:

500.0

Dette er selve fellen. Tilordner du et navn inne i en funksjon, lager Python en ny, lokal variabel — også når det finnes en global variabel med akkurat samme navn. Den globale er urørt etterpå.

antall = 10

def endre():
    antall = 99
    print('Inne:', antall)

endre()
print('Ute:', antall)

Utskrift:

Inne: 99
Ute: 10

Vil du at den nye verdien skal ut av funksjonen, returnerer du den og tilordner utenfor: antall = endre(). Det er formen fasitene bruker; nøkkelordet global er teknisk mulig, men gir uoversiktlig kode og brukes ikke i denne boka.

Før du skriver kroppen, skal du kunne si hva funksjonen gjør i én setning som begynner med et verb: «Returnerer antall målinger over grensen.» Klarer du ikke det, gjør funksjonen mer enn én ting, og bør deles.

Det er ikke bare god skikk — det er en egen eksamenssjanger. Sjanger C («forklar med én setning hva funksjonen gjør») går igjen i 60 % (6 av 10 sett), og svaret skal si hva funksjonen oppnår, ikke hvordan koden virker linje for linje.

God: «Returnerer den høyeste verdien i lista og indeksen dens.»
Dårlig: «Den lager først en variabel som heter beste, så går den gjennom lista med en for-løkke, og hvis tallet er større enn beste, så ...»

En funksjon som svarer ja eller nei, returnerer den boolske verdien direkte. Sammenligningen er allerede True eller False — den trenger ingen if rundt seg.

def er_myndig(alder):
    return alder >= 18

print(er_myndig(20))
print(er_myndig(17))
print(er_myndig(18))

Utskrift:

True
False
True

Formen if alder >= 18: return True else: return False gir det samme svaret og full uttelling, men er fire linjer der én holder — og konsishet vurderes.

Navnet på en slik funksjon bør leses som et spørsmål: er_myndig, er_ledig, har_plass.

Bokas navn skrives med små bokstaver og understrek mellom ordene: finn_beste, antall_per_type, les_gyldig_alder. Navnet er et verb eller et spørsmål, aldri bare et substantiv.

Norske og engelske navn er like gyldige på eksamen; fasitene i arkivet blander (les_inn_data og item_winner i samme sett). Boka bruker overveiende norske navn.

Ett navn du aldri skal bruke, verken på en funksjon eller en variabel, er navnet på noe innebygd: sum, list, max, input, str, type. Skriver du sum = 0, virker ikke sum(...) i resten av programmet (felle #14 — å skygge et innebygd navn). Bruk total, verdier, tekst i stedet.