Python nb-no:Funksjoner

[edit] Introduksjon

Funksjoner er biter med program som du kan bruke om igjen. De lar deg gi navn til en blokk med påstander, og du kan kjøre blokken hvor som helst i programmet ditt så mange ganger du vil ved å bruke det navnet. Dette betegnes som å kalle på funksjonen. Vi har allerede brukt mange innebygde funksjoner, som len- og range-funksjonene.

Konseptet med funksjonen er kanskje den viktigste byggesteinen i all ikke-triviell programvare (i alle programmeringsspråk), så vi vil se på forskjellige sider av funksjoner i dette kapitlet.

Funksjoner defineres med def-nøkkelordet. Dette blir etterfulgt av en identifikator for funksjonen og et par med parenteser som kan inneholder navn på variabler, og linjen slutter med et kolon. Etter dette kommer en blokk med påstander som er del av funksjonen. Dette eksemplet viser at det er ganske enkelt:

Eksempel:

#!/usr/bin/python
# Filnavn: funksjon1.py
 
def siHallo():
    print('Hello World!') # blokk som tilhører funksjonen
# Slutt på funksjonen
 
siHallo() # kall på funksjonen
siHallo() # kall på funksjonen igjen

Output:

   $ python funksjon1.py
   Hello World!
   Hello World!

Hvordan det virker:

Vi definerer en funksjon kalt siHallo ved å bruke syntaksen jeg forklarte ovenfor. Denne funksjonen inneholder ikke noen parametre, og derfor er det ikke erklært noen variabler innenfor parentesene. Parametre for funksjonen er bare input til funksjonen slik at vi kan gi den forskjellige verdier og få tilbake samsvarende resultater.

Legg merke til at vi kan kalle på den samme funksjonen to ganger, som betyr at vi ikke må skrive den samme koden igjen.

[edit] Funksjonsparametre

En funksjon kan ha parametre, som er verdier du gir til funksjonen slik at funksjonen kan bruke de verdiene til noe. Disse parametrene er akkurat som variabler, med unntak av at verdiene til disse variablene allerede er definert når vi kaller på funksjonen og allerede er tildelt når funksjonen kjører.

Parametre blir spesifisert innenfor de to parentesene når du definerer funksjonen og blir separert av kommaer. Når vi kalles på funksjonen gir vi verdiene på samme måte. Legg merke til terminologien her - navnene som gis til funksjonen i definisjonen kalles parametre mens verdiene du gir til den når du kaller på den kalles argumenter.

Eksempel:

#!/usr/bin/python
# Filnavn: funk_param.py
 
def printMax(a, b):
    if a > b:
        print(a, 'er størst')
    elif a == b:
        print(a, 'og', b, 'er like store')
    else:
        print(b, 'er størst')
 
printMax(3, 4) # bruk bokstavelige verdier
 
x = 5
y = 7
 
printMax(x, y) # bruk variabler som argumenter

Output:

   $ python func_param.py
   (4, 'er størst')
   (7, 'er størst')

Hvordan det virker:

Her definerer vi en funksjon kalt printMax de vi tar to parametre kalt a og b. Vi finner ut det største tallet ved å bruke en enkel if..elif..else-påstand og trykker så det største tallet.

Første gangen vi bruker printMax gir vi tallene, eller argumentene, rett til funksjonen. Andre gangen bruker vi funksjonen med variabler. printMax(x, y) gjør at verdien til argumentet x blir gitt til parameter a og verdien til y til parameter b. printMax-funksjonen virker likt i begge tilfellene.

[edit] Lokale variabler

De variablene du erklærer når du definerer en funksjon har ingen sammenheng med variabler med samme navn som befinner seg utenfor funksjonen, det vil si at variabelnavn er lokale for funksjonen. Dette kalles for variabelens rekkevidde. Alle variabler har kun rekkevidde innenfor blokken der de blir erklært, og dette starter fra man definerer funksjonsnavnet.

Eksempel:

#!/usr/bin/python
# Filnavn: funk_lokal.py
 
def funk(x):
    print('x er', x)
    x = 2
    print('Forandret lokal x til', x)
 
x = 50
funk(x)
print('x er fortsatt', x)

Output:

   $ python funk_lokal.py
   x er 50
   Forandret lokal x til 2
   x er fortsatt 50

Hvordan det virker:

Første gangen vi bruker verdien til navnet x innenfor funksjonen, bruker Python verdien til parametret som er erklært innenfor funksjonen.

Så gir vi verdien 2 til x. Navnet x er lokalt for funksjonen func(x). Så når vi forandrer verdien til x innenfor funksjonen, blir ikke x-en som vi har definert i hovedblokken påvirket.

I den siste print-påstanden bekrefter vi at verdien til x i hovedblokken faktisk er upåvirket.

[edit] Bruke global-påstanden

Hvis du har lyst til å gi en verdi til et navn som er definert på det øverste nivået (det vil si at det ikke er innenfor noen bestemt rekkevidde, som en funksjon eller klasse), må du fortelle Python at navnet ikke er lokalt, men globalt. Vi gjør dette ved å bruke global-påstanden. Det er umulig å gi en verdi til en variabel definert utenfor en funksjon uten global-påstanden.

Du kan bruke verdiene til variabler som er definert utenfor funksjonen i en vanlig funksjon (så lenge det ikke er noen variabel med samme navn inni funksjonen), men dette oppfordres du ikke til fordi det blir uklart for den som leser programmet hvor variabelen er definert. Å bruke global-påstanden gjør det klart at variabelen er definert i den ytterste blokken.

Eksempel:

#!/usr/bin/python
# Filnavn: funk_global.py
 
def funk():
    global x
 
    print('x er', x)
    x = 2
    print('Forandret global x til', x)
 
x = 50
funk()
print('Verdien til x er', x)

Output:

   $ python func_global.py
   x er 50
   Forandret global x til 2
   Verdien til x er 2

Hvordan det virker:

global-påstanden blir brukt for å erklære at x er en global variabel; dermed gir vi en ny verdi til x innenfor funksjonen, som viser seg når vi bruker verdien til x i hovedblokken.

Du kan spesifisere mer enn en global variabel med samme global-påstand. For eksempel slik: global x, y, z.

[edit] Bruke nonlocal-påstanden

Du har lært hvordan du skal få tak i variabler i lokal og global rekkevidde ovenfor. Det er en annen type rekkevidde kalt "nonlocal", som er midt imellom de to andre typene. Disse kan du se når du definerer funksjoner inni funksjoner.

Siden alt i Python bare er kjørbar kode kan du definere funksjoner hvor som helst.

La oss ta et eksempel:

#!/usr/bin/python
# Filnavn: funk_nonlocal.py
 
def funk_ytre():
    x = 2
    print('x er', x)
 
    def funk_indre():
        nonlocal x
        x = 5
 
    funk_indre()
    print('Forandret lokal x til', x)
 
funk_ytre()

Output:

   $ python funk_nonlocal.py
   x er 2
   Forandret lokal x til 5

Hvordan det virker:

Når vi befinner oss inni funk_indre, er x-en som er definert i den første linjen i funk_ytre egentlig hverken i global rekkvidde eller lokal rekkevidde. Vi erklærer at vi bruker denne x-en ved å skrive nonlocal x, og så får vi tilgang til den variabelen.

Prøv å forandre nonlocal x til global x eller fjern påstanden i seg selv, og se forskjellen mellom det originale programmet og disse to tilfellene.

[edit] Standardargumentverdier

I noen funksjoner har du nok lyst til å gjøre noen av parametrene valgfrie og bruke standardverdier hvis brukeren ikke oppgir noen verdier for de parametrene. Dette gjør du ved hjelp av standardargumentverdier. Du kan lage standardargumentverdier når du definerer funksjonen ved å følge opp navnet med en tildelingsoperator (=) etterfulgt av standardverdien.

Legg merke til at standardargumentverdien burde være en konstant. Mer presist sagt burde standardargumentverdien være uforanderlig - dette blir forklart mer nøye i senere kapitler. Akkurat nå må du bare huske dette.

Eksempel:

#!/usr/bin/python
# Filnavn: funk_standard.py
 
def si(melding, ganger = 1):
    print(melding * ganger)
 
si('Hello')
si('World', 5)

Output:

   $ python funk_standard.py
   Hello
   WorldWorldWorldWorldWorld

Hvordan det virker:

Funksjonen kalt si blir brukt til å skrive en streng så mange ganger som du har lyst. Hvis vi ikke oppgir en verdi, så blir strengen bare skrevet en gang. Vi gjør dette ved å spesifisere en standardverdi på 1 for parameteren ganger.

Første gangen vi bruker si oppgir vi bare en streng, og derfor skriver den bare strengen en gang. Andre gangen vi bruker si oppgir vi både en streng og argumentet 5, og bestemmer dermed at vi vi at den skal si meldingen fem ganger.

Viktig

Bare de parametrene som er på slutten av parameterlisten kan gis standardargumentverdier, som vil si at du ikke kan ha en parameter med en standardargumentverdi foran en uten en standardverdi i rekkefølgen som parametrene blir erklært.

Dette er fordi verdiene til argumenter blir gitt til dem etter hvilken posisjon de har, slik at Python først gir verdier til de parametrene som ikke har noen standardverdi. For eksempel er def funk(a, b=5) gyldig, men def funk(a=5, b) er ugyldig.

[edit] Nøkkelordargumenter

Hvis du har funksjoner med mange parametre, og du kun vil oppgi verdier for noen av dem, kan du gi verdier til slike parametre ved å gi dem navn - dette kalles nøkkelordargumenter - vi bruker navnet (nøkkelordet) i stedet for posisjonen (som vi har brukt hele tiden hittil) for å oppgi argumenter til funksjonen.

Det er to fordeler med dette: - Å bruke funksjonen blir enklere fordi vi ikke trenger å bekymre oss for rekkefølgen på argumentene. - Vi får muligheten til å gi verdier kun til de parametrene vi har lyst til, så lenge de andre parametrene har standardargumentverdier.

Eksempel:

#!/usr/bin/python
# Filnavn: funk_ord.py
 
def funk(a, b=5, c=10):
    print('a er', a, 'og b er', b, 'og c er', c)
 
funk(3, 7)
funk(25, c=24)
funk(c=50, a=100)

Output:

   $ python funk_ord.py
   a er 3 og b er 7 og c er 10
   a er 25 og b er 5 og c er 24
   a er 100 og b er 5 og c er 50

Hvordan det virker:

Funksjonen kalt funk har en parameter uten standardargumentverdier, fulgt av to parametre med standardargumentverdier.

Første gang vi bruker den, som funk(3, 7), får parametret a verdien 3, parametret b verdien 5 og c verdien 10.

Andre gang vi bruker den, som funk(25, c=24), får a verdien 25 på grunn av argumentets posisjon i parentesen. Så får parameteren c verdien 24 fordi vi bruker nøkkelord. Variabelen b får standardverdien 5.

Tredje gang vi bruker den, som funk(c=50, a=100), bruker vi nøkkelordargumenter for å oppgi verdiene. Legg merke til at vi oppgir verdien til parameteren c før a, selv om a ble definert før c da vi definerte funksjonen.

[edit] VarArgs-parametre

Noen ganger kan du ha lyst til å definere en funksjon som tar et hvilket som helst antall parametre, og dette kan du gjøre ved å bruke asterisker:

#!/usr/bin/python
# Filnavn: total.py
 
def total(initial=5, *numbers, **keywords):
    count = initial
    for number in numbers:
        count += number
    for key in keywords:
        count += keywords[key]
    return count
 
print(total(10, 1, 2, 3, vegetables=50, fruits=100))

Output:

   $ python total.py
   166

How It Works:

When we declare a starred parameter such as *param, then all the positional arguments from that point till the end are collected as a list called 'param'.

Similarly, when we declare a double-starred parameter such as **param, then all the keyword arguments from that point till the end are collected as a dictionary called 'param'.

We will explore lists and dictionaries in a later chapter.

[edit] Parametre med kun nøkkelord

Hvis vi vil ha visse nøkkelordparametre som kun skal kunne defineres dersom man bruker nøkkelord og ikke etter posisjonen til argumenter, kan de erklæres etter et parameter med stjerne:

#!/usr/bin/python
# Filename: keyword_only.py
 
def total(initial=5, *numbers, vegetables):
    count = initial
    for number in numbers:
        count += number
    count += vegetables
    return count
 
print(total(10, 1, 2, 3, vegetables=50))
print(total(10, 1, 2, 3))
# Raises error because we have not supplied a default argument value for 'vegetables'

Output:

   $ python keyword_only.py
   66
   Traceback (most recent call last):
     File "test.py", line 12, in <module>
   print(total(10, 1, 2, 3))
   TypeError: total() needs keyword-only argument vegetables

How It Works:

Declaring parameters after a starred parameter results in keyword-only arguments. If these arguments are not supplied a default value, then calls to the function will raise an error if the keyword argument is not supplied, as seen above.

If you want to have keyword-only arguments but have no need for a starred parameter, then simply use an empty star without using any name such as def total(initial=5, *, vegetables).

[edit] Return-påstanden

return-påstanden blir brukt for å vende tilbake fra en funksjon, det vil si å bryte ut fra den. Vi kan også ta med en verdi fra funksjonen.

Eksempel:

#!/usr/bin/python
# Filnavn: funk_return.py
 
def maksimum(x, y):
    if x > y:
        return x
    else:
        return y
 
print(maksimum(2, 3))

Output:

   $ python funk_return.py
   3

Hvordan det virker:

maksimum funksjonen kommer tilbake med det største av parametrene, som i dette tilfellet er tallene vi gir til funksjonen. Den bruker en enkel if..else-påstand for å finne den største verdien og returnerer med den verdien.

Legg merke til at return-påstanden uten en verdi er lik påstanden return None. None er en spesialtype i Python som representerer tomhet. For eksempel viser den at en variabel ikke har noen verdi dersom den har verdien None.

Alle funksjoner har en inneforstått return None-påstand på slutten, med mindre du har skrevet en egen return-påstand. Du kan se detter ved å kjøre print enellerannenFunksjon() der funksjonen enellerannenFunksjon ikke har noen return-påstand, som:

def enellerannenFunksjon():
    pass

pass-påstanden brukes for å vise at blokken med påstander er tom.

Bemerkning

Det finnes en innebygd funksjon kalt max, som virker likt som 'finn maksimum'-funksjonaliteten vi lagde i stad, så bruk denne funksjonen når du trenger den.

[edit] Dokumentasjonsstrenger

Python har en artig funksjon kalt dokumentasjonsstrenger, men disse blir vanligvis omtalt med deres kortere engelske navn; docstrings, eller med det fornorskede navnet vi har gitt dem i denne boken dokstrenger. Dokstrenger er et viktig verktøy som du burde bruke fordi den hjelper deg med å dokumentere programmet ditt bedre og gjør det enklere å forstå. Vi kan faktisk hente dokstrenger fra for eksempel en funksjon mens programmet kjører!

Eksempel:

#!/usr/bin/python
# Filnavn: funk_dok.py
 
def printMax(x, y):
    '''Skriver det største av to tall.
 
    Verdiene må være heltall.'''
    x = int(x) # Gjør om til heltall hvis det er mulig
    y = int(y)
 
    if x > y:
        print(x, 'er størst')
    else:
        print(y, 'er størst')
 
printMax(3, 5)
print(printMax.__doc__)

Output:

   $ python funk_dok.py
   5 er størst
   Skriver det største av to tall.
   
           Verdiene må være heltall.

Hvordan det virker:

En streng på den første logiske linjen i en funksjon er dokstrengen til den funksjonen. Legg merke til at dokstrenger også gjelder moduler og klasser som vi skal lære om i deres respektive kapitler.

Det er fastsatt at en dokstreng skal være en flerlinjet streng der den første linjen starter med en stor bokstav og slutter med et punktum. Så er den andre linjen blank, etterfulgt av en detaljert forklaring som starter på den tredje linjen. Det anbefales på det sterkeste at du følger denne konvensjonen for alle de viktige funksjonene dine.

Vi kan få tilgang til dokstrengen til printMax-funksjonen ved å bruke attributtet (navnet som tilhører) __doc__ (legg merke til de doble understrekene) for funksjonen. Husk på at Python behandler alt som et objekt, inkludert funksjoner. Vi skal lære mer om objekter i kapitlet om klasser.

Hvis du har brukt help() i Python har du allerede sett hvordan man bruker dokstrenger. Det help() gjør er å hente __doc__-attributtet for den funksjonen og vise den på en pen måte for deg. Du kan prøve det ut på funksjonen ovenfor, bare legg til help(printMax) i programmet ditt. Husk på å trykke q-tasten for å gå ut av help-funksjonen.

Automatiserte verktøy kan hente dokumentasjonen fra programmet ditt på denne måten. Derfor anbefaler jeg på det sterkeste at du bruker dokstrenger for alle ikke-trivielle funksjoner du skriver. pydoc-kommandoen som følger med Python-installasjonen virker på samme måten som help() ved hjelp av dokstrenger.

[edit] Annotasjoner

Funksjoner har enda en avansert funksjon som kalles annotasjoner, som er enda en artig måte å legge ved tilleggsinformasjon for hvert av parametrene, så vell som verdien til return. Siden Python-språket ikke tolker annotasjoner på noen måte (det er opp til tredjeparts biblioteker å tolke det på den måten de vil) kommer vi til å hoppe over dette. Hvis du er interessert i å lese om dem kan du ta en titt på Python Enhancement Proposal No. 3107.

[edit] Sammendrag

Vi har sett mange sider av funksjoner, men legg merke til at vi ikke har sett på alle sider ved dem. Uansett har vi tatt en titt på det meste av det det du kommer til å bruke på hverdagsbasis.

Nå skal vi ta en titt på hvordan du skal bruke og lage Python-moduler.