Funktionsdefinitioner och parametrar

Efter denna lektion kommer du att kunna skapa återanvändbara Python-funktioner med parametrar, hantera returvärden samt använda standardargument och förstå variabelers räckvidd.

Vad är en funktion och varför använder vi dem?

I programmering är en funktion en namngiven och återanvändbar block av kod som utför en specifik uppgift. Istället för att skriva samma koduppsättning om och om igen samlar vi koden i en funktion. Detta följer en av programmeringens viktigaste principer: DRY (*Don't Repeat Yourself*).

I Python definieras en funktion med nyckelordet `def`, följt av funktionens namn, parenteser `()` och ett kolon `:`. Koden som hör till funktionen måste indenteras (skjutas in med tab/mellanrum).

python

def säg_hej():

print("Hej och välkommen till kursen!")

Att enbart definiera en funktion gör inte att koden körs direkt. Funktionen sparas i minnet och exekveras först när den anropas med sitt namn följt av parenteser:

python

säg_hej() # Anropar funktionen

Tre huvudsakliga fördelar:

1. Återanvändbarhet: Skriv koden en gång, anropa den så många gånger du behöver.

2. Struktur: Stora program blir lättare att förstå när de delas upp i mindre, fokuserade funktioner.

3. Underhållbarhet: Om du behöver rätta ett fel gör du det på ett ställe istället för på tjugo.

Parametrar, Argument och Returvärden

För att funktioner ska vara flexibla behöver de kunna ta emot indata och skicka tillbaka utdata.

Parametrar vs Argument

• En parameter är variabelnamnet som står i funktionens definition (fungerar som en lokal platshållare).
• Ett argument är det faktiska värdet som skickas med när funktionen anropas.

python

def hälsa_person(namn): # 'namn' är en parameter

print(f"Hej, {namn}!")

hälsa_person("Alice") # "Alice" är ett argument

Returvärden med `return`

För att skicka ett resultat tillbaka från funktionen använder vi nyckelordet `return`. Värdet som returneras kan sparas i en variabel eller användas i vidare beräkningar.

python

def dubblera(tal):

return tal * 2

resultat = dubblera(5) # resultat tilldelas värdet 10

print(resultat)

Skillnaden mellan `print()` och `return`

Det är mycket viktigt att inte blanda ihop `print()` och `return`:

• `print()` visar text på skärmen för användaren, men lämnar inget värde kvar till programmet.
• `return` skickar tillbaka ett datavärde från funktionen. Om du inte använder `return` returnerar funktionen automatiskt värdet `None`.

Standardargument och Nyckelordsargument

Python gör det möjligt att definiera parametrar med förvalda värden, så kallade standardargument (*default arguments*). Om anroparen inte skickar med något värde för en sådan parameter används standardvärdet.

Standardargument

python

def beräkna_pris(pris, moms_sats = 0.25):

return pris * (1 + moms_sats)

Anrop utan att ange moms_sats (använder 0.25):

totalt_1 = beräkna_pris(100) # Returnerar 125.0

Anrop där moms_sats överskrids med 0.12 (12% moms):

totalt_2 = beräkna_pris(100, 0.12) # Returnerar 112.0

*Viktig regel*: Alla parametrar utan standardvärden måste placeras före parametrar som har standardvärden i funktionsdefinitionen.

Positionella argument vs Nyckelordsargument

När du anropar en funktion kan du antingen skicka argument baserat på ordning (positionella) eller genom att explicit ange parameternamnet (nyckelordsargument):

python

def beskriv_hus(stad, typ="villa"):

print(f"Ett hus av typen {typ} i {stad}.")

Nyckelordsargument (ordningen spelar ingen roll när namnen anges):

beskriv_hus(typ="lägenhet", stad="Malmö")

Räckvidd (Scope) och Lokala Variabler

När du skapar variabler inuti en funktion existerar de endast under tiden som funktionen körs. Detta koncept kallas för variabelns räckvidd eller scope.

Lokalt scope

Variabler som skapas inuti en funktion kallas lokala variabler. De är endast synliga och tillgängliga *inuti* den funktionen.

python

def beräkna():

x = 10 # 'x' är en lokal variabel

return x * 2

beräkna()

print(x) # KASTAR FEL! NameError: name 'x' is not defined

När funktionen har kört klart rensas de lokala variablerna ur minnet.

Globalt scope

Variabler som definieras i huvudprogrammet (utanför funktioner) kallas globala variabler. En funktion kan läsa globala variabler, men bör normalt inte ändra dem direkt.

python

moms = 0.25 # Global variabel

def beräkna_moms(belopp):

return belopp * moms # Kan läsa 'moms'

Bästa praxis: "Svart låda"

En välskriven funktion fungerar som en isolerad "svart låda":

• Den tar emot allt den behöver via sina parametrar.
• Den skickar ut sitt resultat via `return`.
• Den undviker sidoeffekter (ändrar inte variabler utanför sig själv).