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
• 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.

# Vi definerer en funksjon som heter «my_sample_function»
def my_sample_function(my_crazy_parameter, my_insane_parameter):
    print("*********")
    print("*", my_crazy_parameter)
    print("*", my_insane_parameter)
    print("*********")

# Vi kaller my_sample_function 
my_sample_function("foo", "bar")
my_sample_function("baz", "qux")

Parameter. En funksjon har som regel noen ukjente variabler den trenger for å gjøre jobben sin. De ukjente variablene kalles parametre til funksjonen. Den som definerer en funksjon bestemmer selv hva parameterne heter. Når funksjonen kalles må parametrene til funksjonen fylles med argumenter.

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

find_age() # Krasjer, funksjonen find_age er ikke definert enda

def find_age():
    print("Hvilket år ble du født?")
    birth_year = int(input())
    age = 2023 - birth_year
    print(f"Du blir {age} år i år")

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, 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) # None

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

return_value_c = c()
print(return_value_c) # 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!

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)))