Funksjoner

• Funksjonskall
• Funskjonskall med returverdi
• Funksjonskall med både returverdi og sideeffekt
• Hvorfor funksjoner?
• Vår første funksjon
• Definere egne funksjoner
• Retursetninger
• Vanlig feil: forveksle returverdi og sideeffekt
• Mer enn én returverdi
• Ordbok
• Skop

Funksjonskall

Å kalle en funksjon betyr at vi instruerer funksjonenen til å kjøres. For eksempel gjør vi et kall til print -funksjonen i denne kodesnutten:

a = "Hello"
b = "World"
print(a + b)
...

Når vi kaller en funksjon, gir vi ofte funksjonen noe informasjon som den trenger for å gjøre jobben sin. Denne informasjonen kalles et argument. I eksempelet over blir verdien "HelloWorld" gitt som argument til print-funksjonen (det er denne verdien uttrykket a + b evaluerer til).

Funksjonskall med returverdi

Et annet eksempel på et funksjonskall, er kallet til len -funksjonen i kodesnutten under. Dette er en funksjon med en returverdi.

s = "Hello"
x = len(s)
...

Her blir verdien "Hello" gitt som argument til len-funksjonen. Funksjonen returnerer så verdien 5, før variabelen x endres til å peke på denne verdien.

x = max(1, 2, 3)   # x = 3
y = min(1, 2, 3)   # y = 1
z = abs(-6)        # z = 6
print(x, y, z)

s = input("Skriv noe: ") # s = "Hallo"    (hvis brukeren skriver Hallo)
l = len(s)               # l = 5          (hvis brukeren skrev Hallo)
print(s, l)

x = print("Hello") # Skriver ut Hello. Returverdien fra print lagres i x
print(x)           # None

Funksjonskall med både returverdi og sideeffekt

Et tredje eksempel på et funksjonskall vi har sett før, er input-funksjonen. Denne funksjonen har både sideeffekt og en returverdi. Med sideeffekt mener vi at noe skjer i «verden forøvrig» som følge av funksjonskallet, som ikke er en returverdi. I dette tilfellet skjer det noe på skjermen: teksten «Navn: » vises.

name = input("Navn: ")
...

Her blir strengen "Navn:" gitt som argument til input-funksjonen. Som en sideeffekt av input-funksjonen vises denne strengen i terminalen. Brukeren skriver inn f. eks. «Ole». Funksjonen returnerer så verdien "Ole" før variabelen name endres til å peke på denne verdien.

Hvorfor funksjoner?

Noen har gjort et kall til print-funksjonen: under panseret i datamaskinen skjer det noe greier, og så «vipps!» dukker det opp tekst i terminalen. Heldigvis trenger ikke vi å tenke på noe av det. print-funksjonen bare fungerer. Vi kan gjenbruke noen andre sin genialitet uten at det koster oss en kalori. Dette bringer oss til de viktigste hensiktene med funksjoner: å gjenbruke kode og å abstrahere bort detaljer.

Vår første funksjon

En funksjon er en sekvens med kommandoer man kan referere til ved hjelp av et funksjonsnavn. Man kan utføre funksjonen flere ganger ved å kalle den flere ganger.

# Vi definerer en funksjon som heter `my_sample_function`
def my_sample_function():
    print("A")
    print("B")
    print("C")

# Vi kaller my_sample_function to ganger
my_sample_function()
my_sample_function()

Funksjonskroppen (setningene som skal utføres når funksjonen kjører) må ha riktig innrykk. God stil tilsier at innrykket består av 4 mellomrom.

def hello():
    print("Skriv ditt navn:")
    name = input()
   print(f"Hei {name}") # Krasjer, mangler et mellomrom

hello()

Definere egne funksjoner

For å definere vår egen funksjon:

• begynn med det spesielle ordet def fulgt av et mellomrom; så
• et valgfritt navn vi ønsker å gi funksjonen; så
• en opplisting av parametre omsluttet av paranteser; så
• et kolon; så
• selve funksjonskroppen med innrykk og eventuelt retursetninger

Funksjonskroppen er instruksjonene som skal utføres når funksjonen kalles, og må ha et innrykk i forhold til def-ordet. Standard innrykk er 4 mellomrom.

def sum_of_squares(a, b):
    square_of_a = a * a
    square_of_b = b * b
    return square_of_a + square_of_b

x = sum_of_squares(1, 1)
print(x) # 2

y = sum_of_squares(1, x)
print(y) # 5

En funksjon må være definert før den kalles.

sum_of_squares(1, 2) # Krasjer, funksjonen sum_of_squares er ikke definert enda

def sum_of_squares(a, b):
    square_of_a = a * a
    square_of_b = b * b
    return square_of_a + square_of_b

En setning som befinner seg inne i en funksjonskropp kan derimot kalle andre funksjoner som defineres senere i koden; så lenge den andre funksjonen er definert når den kalles er det tilstrekkelig.

def besok_bestemor():
    reis_til_bestemor()
    print("Spis kake")
    reis_hjem_fra_bestemor()

def reis_til_bestemor():
    print("Ta bussen til byen")
    print("Ta toget til Hønefoss")
    print("Bli hentet av bestemor på stasjonen")

def reis_hjem_fra_bestemor():
    print("Bli kjørt til Hønefoss av bestemor")
    print("Ta toget til byen")
    print("Ta bussen hjem")

besok_bestemor()

Hva skjer hvis du gjør kallet til besok_bestemor() like før du skriver definisjonen av reis_hjem_fra bestemor i stedet for etterpå? Krasjer det? Hvis ja; når og hvorfor krasjer det?

Retursetninger

Dersom en funksjon skal returnere en verdi (som ikke er None), må den ha en retursetning. Returverdien er den verdien uttrykket i retur-setningen evaluerer til.

def square(x):
    return x * x

x2 = square(3)
print(x2) # 9

Dersom en funksjon ikke har noen retursetning, eller retur-setningen ikke inneholder et uttrykk, returnerer funksjonen den spesielle verdien None.

def a():
    print("Denne funksjonen returnerer None")
    return None

return_value_a = a()
print(return_value_a) # None

def b():
    print("Denne funksjonen har en tom return-setning")
    return
    
return_value_b = b()
print(return_value_b) # også None

def c():
    print("Denne funksjonenen har ikke return-setning")

return_value_c = c()
print(return_value_c) # også None

Det er ikke nødvendig at en retursetning er den siste setningen i en funksjon; men når en retursetning utføres, avsluttes funksjonen umiddelbart uten å fortsette videre i funksjonskroppen. Hvis man har kode etter en retursetning, kalles dette gjerne død kode (og det er selvfølgelig svært dårlig stil).

def hello():
    print("Hello")
    return
    print("Goodbye") # død kode; utføres aldri

hello() # Hello

Det kan ofte være nyttig å ha en tidlig retur-setninger inne i en if-setning, for å avslutte funksjonen tidlig under gitte betingelser.

def go_to_club(name, age):
    if age < 18:
        return f"Yo {name}, you're too young!"
    result = f"Hi there, {name}! It's time to party"
    result += "party"
    result += "party"
    result += "party"
    result += "party"
    return result + "!"

print(go_to_club("Ole", 14)) # Yo Ole, you're too young!
print(go_to_club("Kari", 18)) # Hi there, Kari! It's time to partypartypa...

Vanlig feil: forveksle returverdi og sideeffekt

En av de vanligste feilene ferske programmerere gjør, er å forveksle returverdi og sideeffekt. Dette er en feil som er lett å gjøre, fordi det er lett å tenke at en funksjon som skriver ut noe på skjermen, returnerer det den skriver ut. Dette er ikke tilfelle.

def cubed(x):
    print(x**3)   # Funksjon uten retur-verdi, kun side-effekt

cubed(2)          # ser ut til å virke
print(cubed(3))   # rart (skriver også ut `None`)
print(2*cubed(4)) # Krasj!

Gjør det heller slik:

def cubed(x):
    return x**3   # Funksjonen har retur-verdi, men ingen side-effekt

cubed(2)          # ser ikke ut til å virke (hvorfor?)
print(cubed(3))   # funker!
print(2*cubed(4)) # funker!

Mer enn én returverdi

Det er teknisk sett kun mulig å ha én returverdi i en funksjon. Men: det er mulig at returverdien er en «tuple» (en slags liste). Da kan vi for alle praktiske formål tenke på det som om funksjonen returnerer flere verdier.

def plus_minus(x, epsilon):
    x_lo = x - epsilon
    x_hi = x + epsilon
    return x_lo, x_hi # komma for å skille verdier lager en «tuple»

# Man får egentlig kun én returverdi, men den kan pakkes opp til flere
window = plus_minus(1000, 5)
a = window[0]
b = window[1]
print(a, b) # 995 1005

# Python har en snarvei for å pakke opp en tuple med én gang
a, b = plus_minus(50, 2)
print(a, b) # 48 52 

Man kan ha så mange elementer man vil i en tuple (men det må matche antall variabler når vi pakker opp).

def three_next_numbers(n):
    return n + 1, n + 2, n + 3

a, b, c = three_next_numbers(10)
print(a, b, c) # 11 12 13

a, b = three_next_numbers(10) # Krasjer: returnert tuple har 3 verdier, ikke bare 2
print(a, b)

Ordbok

1
2
3
4
5
6
7
8
9

def sum_of_squares(a, b):
    square_of_a = a * a
    square_of_b = b * b
    return square_of_a + square_of_b

x = sum_of_squares(3, 4) + 42


print(x)

Funksjonsdefinisjon. En funksjonsdefinisjon forteller Python at vi ønsker å definere en ny funksjon. En funksjonsdefinisjon består av følgende komponenter:

• det spesielle ordet def,
• et valgfritt navn vi ønsker å gi funksjonen (funksjonsnavn),
• en opplisting av valgfritt antall parametre omsluttet av paranteser (parentesene må være med selv om det ikke er noen parametre),
• et kolon (:), og
• en funksjonskropp med innrykk. Dette er en sekvens med setninger som skal utføres når funksjonen kalles.

I eksempelet vist over utgjør linje 1-4 en funksjonsdefinisjon.

At en funksjon defineres, betyr ikke at funksjonskroppen kjøres. Det er bare når funksjonenen kalles at funksjonskroppen kjøres.

Funksjonskall. Et funksjonskall er en instruksjon om å kjøre en funksjon. Et funksjonskall består av følgende komponenter:

• funksjonsnavnet, og
• en opplisting av argumenter omsluttet av paranteser. Parentesene må være med selv om det ikke er noen argumenter.

I eksempelet vis over utgjør sum_of_squares(3, 4) på linje 6 et funksjonskall.

Alle funksjonskall er uttrykk (men ikke alle uttrykk er funksjonskall). Et funksjonskall evalueres til returverdien fra funksjonen som kalles. I eksempelet over evalueres funksjonskallet sum_of_squares(3, 4) på linje 6 til verdien 25.

Parameter. En parameter er en lokal variabel. Parametre får angitt hvilke verdier de refererer til når funksjonen kalles, og slutter å eksistere når funksjonskallet er ferdig/returnerer. I eksempelet over er a og b parametre til funksjonen sum_of_squares, og verdiene de blir angitt å referere til når funksjonen kalles er 3 og 4.

Argument. Et argument er en verdi som gis en funksjon når den kalles. I eksempelet over er 3 og 4 argumenter ved funksjonskallet til sum_of_squares på linje 6. Når en funksjon kalles, vil parametrene (i utgangspunktet) referere til argumentene.

Lokal variabel. En lokal variabel er en variabel som er definert inne i en funksjonskropp. Lokale variabler eksisterer kun underveis i et funksjonskall, og slutter å eksistere når kallet er ferdig/returnerer. I eksempelet over er square_of_a og square_of_b i tillegg til parametrene a og b lokale variabler i funksjonen sum_of_squares.

Global variabel. En global variabel er en variabel som er definert utenfor en funksjonskropp. Slike variabler slettes ikke fra funksjonskall til funksjonskall, men eksisterer så lenge programmet kjører. I eksempelet over er x en global variabel.

Signatur. En funksjonssignatur består minimum av funksjonsnavnet og en opplisting av parametrene til funksjonen. Funksjonssignaturen i eksempelet over er altså «sum_of_squares(a, b)». En signatur er den informasjonen som er nødvendig å kjenne til for å kunne kalle funksjonen. I tillegg til funksjonsnavn og parametre, kan også informasjon om returverdien (f. eks. hvilke type den har) og docstring-kommentarer inngå i signaturen.

Skop

En variabel eksisterer i ett skop basert på hvor variabelen ble definert. Hver funksjon har sitt eget skop; variabler som er definert i dette skopet kan ikke nås utenfra.

def foo(x):
    print(x)

foo(2) # skriver ut 2
print(x) # Krasjer, siden variabelen x kun var definert i foo sitt skop

def bar():
    y = 42
    print(y)

bar() # skriver ut 42
print(y) # Krasjer, siden variabelen y kun var definert i bar sitt skop

Det samme variabelnavnet kan eksistere i ulike skop. Men selv om variablene heter det samme, er de helt uavhengig av hverandre.

def f(x):
    print("Vi er i f, x =", x)
    x += 5
    return x

def g(x):
    y = f(x*2)
    print("Vi er i g, x =", x)
    z = f(x*3)
    print("Vi er i g, x =", x)
    return y + z

print(g(2))

Det kan eksistere flere skop samtidig når koden kjører.

• Det globale skopet opprettes når Python begynner å kjøre programmet, og fjernes ikke før Python avslutter.
  • Alle variabler som blir definert utenfor en funksjon, befinner seg i det globale skopet.
• Hver gang du kaller en funksjon, opprettes et nytt skop som tilhører dette funksjonskallet. Dette kalles et lokalt skop. Det slettes fullstendig når funksjonen returnerer/er ferdig.
  • Alle parameterne er variabler som hører til det lokale skopet
  • Alle variabler som opprettes i funksjonen tilhører det lokale skopet
• Siden du kan kalle én funksjon fra en annen, kan det være mange slike skop «oppå hverandre.»
• Det er teknisk sett alltid mulig å se variabler fra det globale skopet, men det er ikke en anbefalt praksis. Dersom vi har en lokal variabel med samme navn, vil den maskere den globale variabelen:

x = "x i globalt skop"
y = "y i globalt skop"

def f():
    y = "y i lokalt skop"
    z = "z i lokalt skop"
    print(x)
    print(y)
    print(z)

f()

Hold tungen rett i munnen og regn ut hva svaret blir før du kjører koden under. Ta notater på papir for å holde styr på hva som foregår.

def f(x):
    print("Vi er i f, x =", x)
    x += 7
    return round(x / 3)

def g(x):
    x *= 10
    return 2 * f(x)

def h(x):
    x += 3
    return f(x+4) + g(x)

print(h(f(1)))