Definiera funktioner

Vi har redan använt funktioner som len, print och input i våra program. Dessa är funktioner som är inbyggda i Python och de är därmed alltid tillgängliga. Det är dessutom möjligt att definiera egna funktioner.

Definiera en funktion

Före en funktion kan användas måste den definieras. Man inleder definitionen med nyckelordet def (define). Därefter följer namnet på funktionen, följt av parentes och kolon. Efter det här följer funktionens innehåll – indenterat precis som med while- och if-blocken.

Den här kodsnutten definierar till exempel funktionen meddelande:

def meddelande():
    print("Det här är min funktion!")

Om vi kör den här koden, ser det på ytan ut som om inget skulle hända. Det beror på att vi en så länge endast har definierat funktionen, dvs. sagt att vi har en funktion som heter meddelande och angett vilken kod den innehåller. För att få ett resultat måste vi använda funktionen. Vi säger att vi anropar, eller kallar på, funktionen.

Det är lätt att anropa en funktion – vi behöver endast nämna dess namn i koden följt av parenteserna. Så här kan vi utveckla det föregående exemplet:

def meddelande():
    print("Det här är min funktion!")

meddelande()

Här är resultatet:

När en funktion har definierats kan den anropas flera gånger.

def meddelande():
    print("Det här är min funktion!")

meddelande()
meddelande()
meddelande()

Argument hos funktioner

Funktioner tar ofta emot ett eller fler argument som kan påverka funktionens resultat. Till exempel tar de inbyggda print- och input-funktionerna emot text som ska visas som argument:

print("Hejps!")                      # som parameter strängen "Hejps!"
namn = input("Berätta ditt namn: ")  # som parameter strängen "Berätta ditt namn: "
print(namn)                          # som parameter värdet på variabeln namn

Termerna argument och parameter är nästan synonymer. Skillnaden är att argument används för den verkliga data som ges till funktionen vid ett anrop, medan dessa inom funktionen tilldelas till variabler som kallas parametrar. Vi ger alltså argument till en funktion då vi anropar den. När vi definierar en funktion talar vi istället om parametrar. Argument kallas också aktuella parametrar, medan parametrar kan kallas formella parametrar.

Det här kan kännas som en meningslös skillnad, och dessutom följer inte alla källor samma definition. Vi strävar efter att göra den här skillnaden tydlig under den här kursen. Med korrekt terminologi är det lättare att förstå andra material förutom det som den här kursen erbjuder.

Låt oss definiera några funktioner som tar emot argument. När vi definierar funktionen sätter vi parameterns/parametrarnas namn inom parenteserna efter funktionens namn:

def halsa(sak):
    print("Hej", sak)

När funktionen anropas två gånger…

halsa("Beatrice")
halsa("världen!")

…får vi två hälsningar:

Vi tar ännu en titt på funktionsdefinitionen:

def halsa(sak):
    print("Hej", sak)

På den första raden har vi definierat att funktionen tar emot ett argument och tilldelar det till variabeln sak. Inom funktionen använder print-instruktionen det värde som finns lagrat i sak.

När funktionen anropas får parametern sak det värde som getts som argument i funktionsanropet. Till exempel resulterar följande funktionsanrop…

namn = "Alice"
halsa(namn)

… i att variabeln sak får värdet "Alice". Argumentet är i detta fall namn, medan parametern är sak.

Namnet på en funktion ges enligt samma principer som variabelnamn. De ska vara beskrivande, i regel innehålla små bokstäver och understreck. Undantag finns igen, men vi ignorerar dem tills vidare.

Fler exempel

Vi tar en titt på fler exempelfunktioner som tar emot argument. Här är parametern en siffra:

def kvadrat(x):
    print(f"Kvadraten av {x} är {x * x}")

kvadrat(2)
kvadrat(5)

Här har vi en if-sats inom en funktion:

def halsa(namn):
    if namn == "Beatrice":
        print("Hejps,", namn)
    else:
        print("God dag,", namn)

halsa("Beatrice")
halsa("Mårten")

Den här funktionen tar emot två argument:

def summa(x, y):
    resultat = x + y
    print(f"Summan av {x} och {y} är {resultat}")

summa(1, 2)
summa(5, 24)

Funktionen har också en hjälpvariabel, resultat, som används för att lagra summan av argumentens värden.

Märk att namnen på parametrarna i funktionsdefinitionen inte har några kopplingar till andra variabler utanför definitionen. Vi kan anropa ovanstående funktion på följande sätt:

x = 100
y = 30
summa(1, 2)
summa(x + y, 10)

Det här skriver ut:

I det första funktionsanropet får parametrarna värdena x = 1 och y = 2. I det andra anropet får de värdena x = 130 och y = 10. Det här oavsett att vi i huvudprogrammet och anropet använder variabler med samma namn. För att göra koden lättläst är det dock ofta en god idé att använda skilda namn för parametrar och andra variabler.

I nästa modul återkommer vi till funktionsdefinitioner.

Varning: globala variabler inom funktioner

I exemplen ovan observerade vi att det är möjligt att tilldela nya variabler i funktionsdefinitioner. Funktionen har också åtkomst till variabler utanför funktionen, i huvudfunktionen. Dessa variabler kallas globala variabler.

Att låta funktioner använda globala variabler är oftast en dålig idé. Det kan orsaka en hel del problem, till exempel orsaka buggar som är svåra att spåra.

Här är ett exempel på en funktion som använder en global variabel "av misstag":

# global variabel
namn = "Beatrice"

def halsa(fornamn):
    # vi skriver av misstag ut den globala variabelns värde istället för parametern
    print("Hej", namn)

halsa("Alice")
halsa("Beatrice")

Oavsett vilka argument vi anropar funktionen med skrivs värdet "Beatrice" från den globala variabeln ut.

Vänligen svara på en kort enkät gällande den här veckans material.

Se dina poäng genom att klicka på cirkeln nere till höger av sidan.