Funksjoner
Syntaks for funksjoner
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 `eksempel_funksjon`
def eksempel_funksjon():
print("A")
print("B")
print("C")
# Vi kaller eksempel_funksjon to ganger
eksempel_funksjon()
eksempel_funksjon()
Det som utføres i funksjonen må være indentert med riktig antall mellomrom.
def hello():
print("Skriv ditt navn:")
name = input()
print(f"Hei {name}") # Krasjer, mangler et mellomrom
hello()
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 = 2022 - birth_year
print(f"Du blir {age} år i år")
Parametre, returverdi og sideeffekter
Funksjoner kan ta input i form av parametre, og kan produsere output i form av både en returverdi og sideeffekter.
# Vi definerer en funksjon som heter `dobling`
# Funksjonen har én parameter (x)
# Funksjonen har returverdi (x * 2)
# Funksjonen har sideeffekt (print skriver til skjermen)
def dobling(x):
print("Jeg dobler nå", x)
return x * 2
# Vi utfører noen kall til dobling-funksjonen.
# Verdiene vi gir som input kalles argumenter.
print(dobling(2))
print(dobling(3) + 4)
print(dobling(dobling(2)))
Funksjoner kan ha så mange parametre vi vil. En parameter er en variabel.
def repeat_print(string, repetitions):
print(string * repetitions)
repeat_print("foo", 3) # skriver ut foofoofoo
def f():
return 42
print(f()) # skriver ut 42
# Merk! Antall argumenter må matche antall parametre!
repeat_print("bar") # krasjer
print(f(1, 2)) # ville også krasjet
Når koden i en funksjon treffer return, avsluttes funksjonen.
def is_positive(x):
print("Hello!") # kjører
return (x > 0)
print("Goodbye!") # kjører ikke ("død kode")
print(is_positive(5)) # skriver først Hello, deretter True
Hvis en funksjon ikke utfører en return-setning, returneres den spesielle verdien None.
def a():
print("Denne funksjonen returnerer None")
return None
print(a()) # None
def b():
print("Denne funksjonen har en tom return-setning")
return
print(b()) # None
def c():
print("Denne funksjonenen har ikke return-setning")
print(c()) # None
Vanlig feil: forveksling av utskrift og returverdi
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!
Innebygde funksjoner
Python har mange innebygde funksjoner. Vi har allerede sett print -funksjonen. Noen andre funksjoner det er greit å vite om:
print(int(2.8), int("3")) # int-funksjonen konverterer til heltall
print(float("0.5"), float(1)) # float-funksjonen konverterer til flyttall
print(bool(0), bool(1)) # bool-funksjonen konverterer til True eller False
print("Score: " + str(50)) # str-funksjonen konverterer til streng
print(len("Hurra")) # len gir oss antall symboler i strengen/teksten
print(abs(-3)) # absolutt-verdi
print(max(2, 3)) # maksimum
print(min(2, 3)) # minimum
Noen funksjoner er innebygd i Python, men likevel ikke umiddelbart tilgjengelig; de må importeres først.
print(math.factorial(4)) # vi håper på 4*3*2*1 = 24
# krasjer fordi math ikke er importert
import math
print(math.factorial(4)) # 24
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)))