1.6 Funksjoner, scope og lambda

Definerer en funksjon. Linja slutter med kolon, og alt som hører til funksjonen står med innrykk under — nøyaktig samme regel som for løkkekroppen i kap. 1.3.

Navnene i parentesen kalles parametre. De er navn funksjonen bruker internt, og de får verdier først når funksjonen kalles.

def celsius_til_fahrenheit(grader):
    return grader * 9 / 5 + 32

print(celsius_til_fahrenheit(20))
print(celsius_til_fahrenheit(-40))

Utskrift:

68.0
-40.0

Legg merke til at def-linja i seg selv ikke gjør noe: den lagrer oppskriften. Først kallet celsius_til_fahrenheit(20) kjører kroppen. Og at svaret er 68.0 og ikke 68 skyldes /, som alltid gir flyttall.

Leverer en verdi ut av funksjonen — og avslutter den umiddelbart. Alt som står etter return i samme funksjon, kjøres aldri.

En funksjon uten return gir verdien None, Pythons ord for «ingenting». Det er en av de vanligste sporingsfellene, fordi funksjonen kan se ut som den virker: den skriver noe ut, men leverer ikke noe tilbake.

def energi(masse, fart):
    e = 0.5 * masse * fart**2
    return e
    print('denne linja kjores aldri')

print(energi(2.0, 3.0))

Utskrift:

9.0

Sensor skiller nøye mellom «funksjonen skriver ut svaret» og «funksjonen returnerer svaret». Ber oppgaven om at funksjonen skal beregne noe, skal den returnere — ikke skrive ut.

En funksjon som bare skriver ut, leverer likevel en verdi tilbake: None. Skriver du den ut, står det None.

def skriv_rapport(navn, grader):
    print(navn, 'malte', grader, 'grader')

svar = skriv_rapport('Blindern', 4.2)
print(svar)

Utskrift:

Blindern malte 4.2 grader
None

To linjer utskrift fra to ulike print. Den første kommer fra inne i funksjonen, den andre fra det funksjonen ga tilbake. Prøver du å regne videre med svar, stopper programmet med en TypeError — None kan ikke legges sammen med et tall.

I def energi(masse, fart) er masse og fart parametre. I kallet energi(2.0, 3.0) er 2.0 og 3.0 argumenter.

Skillet er verdt å holde på fordi oppgavetekster bruker begge ordene, og fordi et parameternavn bare finnes inne i funksjonen. Det er det scope handler om, senere i kapitlet.

Uten navn i kallet pares argumentene med parametrene i rekkefølge: første argument til første parameter, og så videre.

Det betyr at vindkjoling(4.0, 5.0) og vindkjoling(5.0, 4.0) er to helt forskjellige kall. Rekkefølgen i def-linja er kontrakten, og den må du lese før du kaller.

Skriver du parameternavn=verdi i kallet, spiller rekkefølgen ingen rolle: vindkjoling(vind=5.0, temp=4.0) er samme kall som vindkjoling(4.0, 5.0).

Regelen er at alle posisjonsargumenter må komme først i kallet; navngitte argumenter kan så stå i hvilken som helst rekkefølge etterpå.

Navngitte argumenter er sensorvennlige i lange kall: solve(t_span, N) sier lite, mens plt.plot(x, y, label='S') sier alt. Du møter formen igjen i kap. 4.3.

En parameter kan få en standardverdi i def-linja: def vindkjoling(temp, vind, faktor=0.7). Da kan argumentet utelates i kallet, og standardverdien brukes.

Parametre med standardverdi må stå sist i def-linja.

def vindkjoling(temp, vind, faktor=0.7):
    return temp - faktor * vind

print(vindkjoling(4.0, 5.0))
print(vindkjoling(4.0, 5.0, 1.2))
print(vindkjoling(vind=5.0, temp=4.0))
print(vindkjoling(4.0, faktor=0.5, vind=5.0))

Utskrift:

0.5
-2.0
0.5
1.5

Linje 1 og 3 gir samme svar fordi de sender de samme verdiene — bare på hver sin måte. Standardverdier er hverdagskost i faget: steglengden h=1e-5 i numerisk derivasjon (kap. 6.1) og toleransen tol=1e-10 i testfunksjoner (kap. 3.1) er begge default-argumenter.

Komma etter return pakker verdiene i en tuppel — den faste sammenstillingen du møtte i kap. 1.5. Funksjonen returnerer altså fortsatt bare én verdi; den verdien inneholder bare flere ting.

Tar du imot resultatet i ett navn, får du hele tuppelen, og kan indeksere i den som i en liste.

Med to navn på venstresiden pakkes tuppelen ut, ett navn per verdi. Antall navn må stemme eksakt med antall returverdier.

def min_og_maks(verdier):
    minste = verdier[0]
    storste = verdier[0]
    for v in verdier:
        if v < minste:
            minste = v
        if v > storste:
            storste = v
    return minste, storste

lav, hoy = min_og_maks([4.2, -1.5, 5.0, 0.3])
print(lav, hoy)
par = min_og_maks([4.2, -1.5, 5.0, 0.3])
print(par)
print(par[1])

Utskrift:

-1.5 5.0
(-1.5, 5.0)
5.0

Legg merke til forskjellen i utskriften: to navn gir to tall skilt med mellomrom, ett navn gir tuppelen med parenteser og komma. Det er en tegn-for-tegn-detalj i sjanger A.

Begge startverdiene settes til verdier[0], ikke til 0 — ellers ville en liste med bare negative tall gitt feil svar på storste.

Et navn som får verdi inne i en funksjon, finnes bare der. Det forsvinner når funksjonen er ferdig, og kan ikke brukes utenfra.

Parametrene er også lokale: masse i def energi(masse, fart) finnes bare inne i energi.

Praktisk konsekvens: to funksjoner kan trygt bruke samme navn i, total eller x uten å ødelegge for hverandre.

Finnes ikke navnet lokalt, leter Python utenfor funksjonen. Derfor virker dette:

grense = 3

def over_grensen(verdi):
    return verdi > grense

print(over_grensen(5), over_grensen(1))

Utskrift:

True False

Funksjonen leser grense utenfra, uten at den er sendt inn. Det virker, men det er dårlig vane: funksjonen blir avhengig av noe som står et helt annet sted. Sensor foretrekker at alt funksjonen trenger, kommer inn som argument — gjerne med standardverdi.

Dette er kjernen i feil #13. Et likhetstegn inne i en funksjon lager alltid en ny, lokal variabel — det endrer aldri den globale med samme navn.

x = 5

def f():
    x = 10
    return x

print(f(), x)

Utskrift:

10 5

Funksjonen returnerer sin egen x, som er 10. Den globale x er fortsatt 5. To forskjellige variabler, samme navn.

Merk rekkefølgen: print(f(), x) kaller funksjonen først, men det spiller ingen rolle — kallet kan ikke endre den globale x uansett når det skjer.

Regelen over gjelder tilordning. Endrer du innholdet i noe som ble sendt inn — med append, med indeksering eller med innsetting i en ordbok — ser du endringen utenfor også:

def legg_til_null(liste):
    liste.append(0)

maalinger = [1, 2]
legg_til_null(maalinger)
print(maalinger)

Utskrift:

[1, 2, 0]

Men en tilordning inne i funksjonen kobler bare det lokale navnet til noe nytt, og lar originalen i fred:

def nullstill(liste):
    liste = []
    return liste

maalinger = [1, 2]
nullstill(maalinger)
print(maalinger)

Utskrift:

[1, 2]

Skillet er alt: liste.append(0) endrer objektet, liste = [] bytter ut navnet. Det er samme skille som ligger bak feil #20 i kap. 1.5 — å endre argumentet i stedet for å bygge og returnere noe nytt.

def dobbel(x):
    return 2 * x

g = dobbel
print(g(7))
print(type(dobbel))

Utskrift:

14
<class 'function'>

Parentesene er altså ikke pynt: de betyr «kjør nå». Å skrive plt.legend uten parenteser er en klassisk grunn til at ingenting skjer.

En parameter kan ta imot en funksjon, og kalles med parenteser inne i kroppen. Da er metoden skrevet én gang og virker for alle funksjoner:

from math import sin

def verditabell(f, a, b, n):
    for i in range(n + 1):
        x = a + i * (b - a) / n
        print(f'{x:5.2f}{f(x):8.3f}')

verditabell(sin, 0.0, 1.0, 2)

Utskrift:

 0.00   0.000
 0.50   0.479
 1.00   0.841

Merk range(n + 1): n er antall intervaller, og da trengs n + 1 punkter for å få med begge endene. Det er feil #1 i feilkatalogen — den hyppigste i hele faget — og du møter den igjen i hvert eneste kapittel om numeriske metoder.

Legg også merke til at sin sendes inn uten parenteser.

Lager en funksjon på én linje, uten def og uten return. lambda x: x**2 - 2 betyr nøyaktig det samme som:

def kvadrat(x):
    return x**2 - 2

Formen er lambda parametre: uttrykk. Etter kolon står ett uttrykk, som blir returverdien — ingen løkker, ingen flere linjer.

kvadrat = lambda x: x**2 - 2
print(kvadrat(3))
print(kvadrat(0))

Utskrift:

7
-2

Bruk lambda når funksjonen er kort og bare trengs på ett sted — typisk som argument til en annen funksjon. Skal den brukes flere steder, skriv def: det leses lettere.

Tar en tekst som inneholder Python-kode, regner den ut og gir verdien. Da kan et uttrykk komme utenfra — fra brukeren eller fra kommandolinjen — i stedet for å stå fast i koden.

x = 4
uttrykk = '3*x + 1'
print(eval(uttrykk))
print(eval('2**3**2'))

Utskrift:

13
512

Uttrykket regnes ut med de variablene som finnes akkurat da, og med vanlige presedensregler — derfor 512 og ikke 64, siden ** regnes fra høyre.

Kombinert med lambda gir dette et program som kan behandle en funksjon brukeren skriver inn: f = eval('lambda x: x**2 - 2'). Mer om brukerinput i kap. 2.1.

Funksjonens def-linje: navnet, parametrene, rekkefølgen deres og eventuelle standardverdier.

Oppgavetekster oppgir signaturen presist — «skriv funksjonen forward_euler(f, T, N, u0)» — og sensor sjekker den først. Bytter du om to parametre, virker koden fortsatt for deg, men ikke for den som kaller den. Les signaturen ordrett fra oppgaveteksten, og skriv den av.

En verdi er kallbar hvis den kan skrives med parenteser etter seg: funksjoner er kallbare, tall og lister er det ikke.

Ordet dukker opp i feilmeldingen TypeError: 'int' object is not callable, som nesten alltid betyr at du har sendt inn et tall der en funksjon var ventet — felle #19. I kap. 5.1 lager du dine egne kallbare objekter.

En liten funksjon som gjør én ting, brukt av en større. Sensor liker dem: de gjør koden kort, og de kan rettes hver for seg.

Et typisk eksempel er å skille beregningen fra utskriften — én funksjon som regner og returnerer, og løkka som skriver ut, utenfor. Da kan den samme beregningen brukes i en testfunksjon senere, slik du gjør i kap. 3.1.