4. Funktioner
Programmeringsteknik
| Teori | Övningar | Rondelet |
Innehåll |
Vad har man funktioner till?
Stora program är besvärligare att konstruera än små. Men man kan göra det enklare för sig genom att dela upp programmet i funktioner. En funktion är som ett litet delprogram i programmet.
När man anordnar tävlingar med riktiga sniglar tar det mycket lång tid innan deltagarna kommer i mål. Vi ska istället skriva ett litet program som simulerar en tävling mellan två sniglar:
---------------------------------------------------
| VEM HAR DEN SNABBASTE SNIGELN? |
| |
| Här får din snigel tävla mot en vältränad |
| racersnigel. Skriv in namnet på din snigel |
| så sätter tävlingen igång! |
---------------------------------------------------
Vad heter din snigel? Ebba
Klara...färdiga...gå!
Ebba: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @
Racersnigeln: - - - - - - - - - - - - - - - - - - - - - - - - - - - @
Det här loppet tog en oväntad vändning, Ebba vann!
Dela upp ett problem i funktioner
För att programmet ska bli enklare att skriva bestämmer vi först vilka funktioner vi ska ha. Det är inte alls självklart hur programmet ska delas upp i funktioner; samma problem kan lösas på många olika sätt! Vi vill se till att varje funktion har ett enda uppdrag.
Här är ett förslag på uppdelning:
- Skriv ut informationsrutan och läs in namnet på snigeln
- Simulera tävlingen och rita upp banorna
- Skriv ut vem som vann
Ettan och tvåan består av flera olika moment. Vi gör det ännu enklare för oss genom att dela upp i ännu mindre delar:
- Skriv ut informationsrutan
- Läs in namnet på en snigel
- Simulera tävlingen
- Rita upp en snigels bana
- Skriv ut vem som vann
Vi börjar med att skriva in dessa moment som kommentarer i filen snigel.py, för att vi ska hålla reda på vad som är kvar att göra. Då får vi också en kommentar för varje funktion, så att det syns vad som händer var.
Definiera en funktion
Först kommer funktionshuvudet (första raden i funktionen). Exempel:
def visa_information():
Funktionshuvudet består av fyra delar.
- Ordet def (talar om att en funktion ska definieras här)
- Funktionens namn, gärna ett verb som beskriver vad funktionen gör
- Ett par parenteser ()
- Ett kolon
Under funktionshuvudet lägger man funktionkommentaren:
def visa_information():
''' Skriver ut informationsrutan
'''
Sedan kommer funktionskroppen, som helt enkelt är en följd av indenterade satser som funktionen ska utföra. Så här ser hela funktionen ut:
def visa_information():
''' Skriver ut informationsrutan
'''
print("""
---------------------------------------------------
| VEM HAR DEN SNABBASTE SNIGELN? |
| |
| Här får din snigel tävla mot en vältränad |
| racersnigel. Skriv in namnet på din snigel |
| så sätter tävlingen igång! |
---------------------------------------------------""")
(För att kunna skriva en sträng som sträcker sig över flera rader så startar och avslutar vi strängen med tre stycken "-tecken. Vanliga strängar, som börjar och slutar med enkelt citattecken, kan nämligen inte innehålla radbrytningar.)
Lägg till koden ovan i din fil snigel.py och provkör.
Men vad nu - programmet skriver inte ut något alls? Gå vidare till nästa avsnitt för att få reda på varför!
Anropa en funktion
Satserna i funktionskroppen utförs inte om inte funktionen anropas. Anropet ska stå längst ner i programmet, under funktionsdefinitionerna. Den delen av programmet kallar vi huvudprogrammet.
Anropet består bara av funktionens namn följt av ett parentespar. Om du lägger till anropet sist i ditt program ska alltihop se ut så här:
def visa_information():
''' Skriver ut informationsrutan
'''
print("""
---------------------------------------------------
| VEM HAR DEN SNABBASTE SNIGELN? |
| |
| Här får din snigel tävla mot en vältränad |
| racersnigel. Skriv in namnet på din snigel |
| så sätter tävlingen igång! |
---------------------------------------------------""")
# Läs in namnet på en snigel
# Simulera tävlingen
# Rita upp en snigels bana
# Skriv ut vem som vann
visa_information()
Spara i filen snigel.py och provkör!
Skicka utdata från en funktion (returvärden)
Då ger vi oss på nästa funktion, som ska läsa in namnet på en snigel. Namnet på snigeln är utdata från funktionen. Den som kör programmet och knappar in namnet tycker förstås att det är indata, men ur funktionens synvinkel är det nåt som ska skickas ut.
För att skicka ut ett värde ur funktionen skriver vi ordet return följt av den variabel vi vill skicka ut värdet på. Funktionen som läser in namnet kommer att se ut så här:
def las_namn():
''' Läs in namnet på en snigel
returns: namnet på snigeln
'''
namn = input("Vad heter din snigel? ")
return namn
När vi ska anropa funktionen måste vi ta hänsyn till att den returnerar ett värde. Därför skriver vi anropet i en tilldelningssats, med en variabel till vänster som får ta emot det returnerade värdet. Variabeln behöver inte ha samma namn som variabeln i return-satsen inuti funktionen.
din_snigels_namn = las_namn()
När den här satsen utförs av Python kommer följande att hända. Först anropas funktionen las_namn, som läser in namnet och returnerar det. Sen kommer det returnerade värdet att lagras i variabel din_snigels_namn.
Vi lägger in den nya i filen snigel.py och provkör.
def visa_information():
''' Skriver ut informationsrutan
'''
print("""
---------------------------------------------------
| VEM HAR DEN SNABBASTE SNIGELN? |
| |
| Här får din snigel tävla mot en vältränad |
| racersnigel. Skriv in namnet på din snigel |
| så sätter tävlingen igång! |
---------------------------------------------------""")
def las_namn():
''' Läs in namnet på en snigel
returns: namnet på snigeln
'''
namn = input("Vad heter din snigel? ")
return namn
# Simulera tävlingen
# Rita upp en snigels bana
# Skriv ut vem som vann
visa_information()
din_snigels_namn = las_namn()
Men hur ska vi veta om det fungerade eller inte? Jo, vi lägger in en kontrollutskrift
print("Din snigel heter alltså", din_snigels_namn)
allra sist i programmet. Kontrollutskrifter är ett enkelt sätt att se om programmet fungerar som det ska, och är till stor nytta när man försöker ta reda på varför programmet inte gör som det ska.
Provkör igen. När programmet fungerar kan du ta bort kontrollutskriften!
Det här är viktigt, så vi tar ett exempel till, den här gången med två returvärden. Nästa funktion ska simulera tävlingen, på det här viset:
- Sniglarna startar bägge på startstrecket, dvs vid 0
- Vi skriver ut Klara...färdiga...gå
- Och startar själva tävlingen, som representeras av en while-slinga
- I varje varv i slingan låter vi sniglarna ta varsitt skutt av slumpmässig längd
- När någon av sniglarna (eller bägge) passerar mållinjen så avbryter vi
- Sist returnerar vi bägge sniglarnas slutpositioner
def tavling():
''' Simulerar en tävling mellan två sniglar
returns: sniglarnas slutpositioner
'''
snigelbana1 = 0
snigelbana2 = 0
print("Klara...färdiga...gå! \n")
while snigelbana1 < DISTANS and snigelbana2 < DISTANS:
snigelbana1 += random.randrange(5)
snigelbana2 += random.randrange(5)
return snigelbana1, snigelbana2
I return-satsen allra sist kan vi se att två värden returneras, åtskilda med kommatecken. Givetvis måste vi då också ta emot två värden i huvudprogrammet.
Den distans (i centimeter) som sniglarna ska tillryggalägga representeras av konstanten DISTANS. En variabel som ska ha ett konstant värde under hela programmet brukar man skriva med stora bokstäver, VERSALER. Python bryr sig inte om det, men andra människor som läser programmet kan se vad man menar. Vi definierar DISTANS överst i huvudprogrammet, och frågar oss om den kommer att synas inuti funktionen?
Lägg in den nya funktionen i snigel.py, enligt nedan. Glöm inte att lägga in kontrollutskrifter av snigelbana1 och snigelbana2 innan du provkör!
import random
def visa_information():
''' Skriver ut informationsrutan
'''
print("""
---------------------------------------------------
| VEM HAR DEN SNABBASTE SNIGELN? |
| |
| Här får din snigel tävla mot en vältränad |
| racersnigel. Skriv in namnet på din snigel |
| så sätter tävlingen igång! |
---------------------------------------------------""")
def las_namn():
''' Läs in namnet på en snigel
returns: namnet på snigeln
'''
namn = input("Vad heter din snigel? ")
return namn
def tavling():
''' Simulerar en tävling mellan två sniglar
returns: sniglarnas slutpositioner
'''
snigelbana1 = 0
snigelbana2 = 0
print("Klara...färdiga...gå! \n")
while snigelbana1 < DISTANS and snigelbana2 < DISTANS:
snigelbana1 += random.randrange(5)
snigelbana2 += random.randrange(5)
return snigelbana1, snigelbana2
DISTANS = 30
visa_information()
din_snigels_namn = las_namn()
snigelbana1, snigelbana2 = tavling()
När du fått det här att fungera så ska vi ta en ny titt på funktionen tavling. Ser du att vi gör precis samma sak med variablerna snigelbana1 och snigelbana2? Först sätts variablerna till noll, sedan jämför vi bägge med DISTANS i while-slingans villkor, och inuti while-slingan ökas bägge med ett slumpat värde. Sist returneras bägge värdena. Det här kallas för kodupprepning och det ska man försöka undvika, av följande skäl:
- Det blir mer kod att skriva, vilket ger fler felkällor
- Programmet blir svårare att underhålla - när man ska införa ändringar måste man ändra för bägge variablerna
- Det ser fult ut
Skicka indata till en funktion (parametrar)
I det här avsnittet ska vi sona vårt stilbrott genom att skriva en generell funktion för utskrift av en snigels bana. Funktionen ska gå att använda för vilken snigel som helst.
Utskriften av en snigelbana kan se ut så här:
Ebba: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @
Vad vill vi kunna variera från en snigel till en annan? Två saker - snigelns
namn och banans längd. Säg att vår funktion heter rita_banan.
Här följer tre olika exempel på hur en sån funktion skulle kunna anropas:
rita_banan("Ebba", 31)
rita_banan("Racersnigeln", 28)
rita_banan(din_snigels_namn, snigelbana1)
De två värden eller variabler som står innanför parenteserna i anropet
kallas för parametrar. När vi definierar funktionen måste vi
namnge alla parametrarna. Vi kallar dom för snigelnamn
respektive langd. Så här ser funktionen ut.
def rita_banan(snigelnamn, langd):
''' Ritar en snigelbana
param snigelnamn: namnet på snigeln
param langd: längden på snigelns bana
'''
print(snigelnamn.rjust(12) + ":", end=" ")
for i in range(1, langd):
# slemspåret
print ("-", end=" ")
# snigeln
print("@")
Du har nog inte sett rjust förut? Det är en strängmetod som högerjusterar strängen i givet antal positioner. Namnen kommer då att sluta i samma position (12), så att våra snigelbanor kan starta i samma läge.
De två anropen av funktionen ritaBanan kommer att se ut så här:
rita_banan(din_snigels_namn, snigelbana1)
rita_banan("Racersnigeln", snigelbana2)
Vi lägger till den sista funktionen också, den som ska skriva ut vem som vann. Som indata till funktionen vill vi skicka in längden på sniglarnas banor samt sniglarnas namn, alltså totalt fyra olika parametrar. så här blir det:
def utse_vinnare(langd1, langd2, namn1, namn2="Racersnigeln"):
''' Skriver ut vinnaren
param langd1: längden på snigel 1's bana
param langd2: längden på snigel 2's bana
param namn1: namnet på snigel 1
param namn1: namnet på snigel 2
'''
print(langd1, langd2)
print ("\n")
if langd1 >= DISTANS and langd2 >= DISTANS:
print("Det blev oavgjort.")
else:
if langd1 >= DISTANS:
print("Det här loppet tog en oväntad vändning," , namn1, "vann!")
else:
print(namn2, "vann, som vanligt.")
Den sista parametern har fått ett skönsvärde, alltså ett värde som används om vi inte skickar in något på den platsen. Då kan man om man vill utelämna den parametern i anropet, på det här viset:
utse_vinnare(snigelbana1, snigelbana2, din_snigels_namn)
Nu sätter vi ihop alltihop och provkör. För att undvika globala variabler så lägger vi in ett huvudprogram:
import random
def visa_information():
''' Skriver ut informationsrutan
'''
print ("""
---------------------------------------------------
| VEM HAR DEN SNABBASTE SNIGELN? |
| |
| Här får din snigel tävla mot en vältränad |
| racersnigel. Skriv in namnet på din snigel |
| så sätter tävlingen igång! |
---------------------------------------------------""")
def las_namn():
''' Läs in namnet på en snigel
returns: namnet på snigeln
'''
namn = input("Vad heter din snigel? ")
return namn
def tavling():
''' Simulerar en tävling mellan två sniglar
returns: sniglarnas slutpositioner
'''
snigelbana1 = 0
snigelbana2 = 0
print("Klara...färdiga...gå! \n")
while snigelbana1 < DISTANS and snigelbana2 < DISTANS:
snigelbana1 += random.randrange(5)
snigelbana2 += random.randrange(5)
return snigelbana1, snigelbana2
def rita_banan(snigelnamn, langd):
''' Ritar en snigelbana
param snigelnamn: namnet på snigeln
param langd: längden på snigelns bana
'''
print(snigelnamn.rjust(12) + ":", end=" ")
for i in range(1,langd):
print("-", end = " ") #slemspåret
print("@") # snigeln
def utse_vinnare(langd1, langd2, namn1, namn2="Racersnigeln"):
''' Skriver ut vinnaren
param langd1: längden på snigel 1's bana
param langd2: längden på snigel 2's bana
param namn1: namnet på snigel 1
param namn1: namnet på snigel 2
'''
print(langd1, langd2)
print("\n")
if langd1 >= DISTANS and langd2 >= DISTANS:
print("Det blev oavgjort.")
else:
if langd1 >= DISTANS:
print("Det här loppet tog en oväntad vändning," , namn1, "vann!")
else:
print(namn2, "vann, som vanligt.")
def huvudprogram():
''' Simulerar en snigeltävling
'''
visa_information()
din_snigels_namn = las_namn()
snigelbana1, snigelbana2 = tavling()
rita_banan(din_snigels_namn, snigelbana1)
rita_banan("Racersnigeln", snigelbana2)
utse_vinnare(snigelbana1, snigelbana2, din_snigels_namn, "Racersnigeln")
DISTANS = 30
huvudprogram()
Kommentera en funktion
Som redan nämnts så är kommentarer mycket viktiga för att man ska kunna förstå och överblicka sina program. Man kommentera både funktioner i sin helhet samt specifika rader, då det ibland kan underlätta ifall kommentaren är där det som den beskriver händer istället för vid funktionsdeklarationen. Använd följande struktur för funktionskommentarer:
def funktionens_namn(param1, param2): '''<Kort kommentar/förklaring om vad funktionen gör> param param1: <förklara inparametern> param param2: <förklara inparametern> returns: <returvärden> '''
Se Att kommentera för exempel.
Rekursion
Nu börjar vi om med ett helt nytt problem. Vi vill skriva ett program som räknar ut summan av dom första n heltalen, t ex 1+2+3+4=10. Det här är ett så enkelt problem, så det räcker med en enda funktion. Hur ska vi beräkna summan då? Vi förenklar problemet lite: Säg att vi ska räkna ut summan av de fem första heltalen. Då kan vi först räkna ut summan av de fyra första heltalen och sen lägga till fem. Men summan av de fyra första heltalen är ju lätt att räkna ut - det är ju summan av de tre första heltalen plus fyra. Och så vidare...
Vi skriver summaberäkningen som en funktion, och låter den räkna enligt mönstret summa(n) = summa(n-1) + n. Funktionen har n som parameter, och programmet ser ut så här:
def summa(n):
''' Beräknar summan 1+2+...+n-1+n
param n: positivt heltal
returns: summan av 1+2+...+n-1+n
'''
return summa(n-1) + n
print("Välkommen till summaberäkningsprogrammet!")
print("Här beräknas summan 1+2+3+...n")
n = int(input("Vilket heltal ska vara det sista i summan? "))
print("Summan = ", summa(n))
Provkörde du? Isåfall kan det vara bra att komma ihåg att man kan avbryta ett program med Ctrl-C. Det som händer här är att funktionen summa anropar sig själv i all oändlighet. Vad beror det på?
Jo, vi har glömt att tala om när beräkningen ska avbrytas. Anropar vi med n=3, så kommer funktionen att försöka räkna ut summa(2), summa(1), summa(0), summa(-1) och så vidare.
Vi vill ju att det minsta talet i summan ska vara 1, och det måste vi ange i funktionen. Nytt försök:
def summa(n):
''' Beräknar summan 1+2+...+n-1+n
param n: positivt heltal
returns: summan av 1+2+...+n-1+n
'''
if n > 1:
return summa(n-1) + n
else:
return 1
print("Välkommen till summaberäkningsprogrammet!")
n = int(input("Vilket tal ska vara det sista i summan? "))
print("Summan = ", summa(n))
Det här fungerade väl bra? Att lösa ett problem genom att låta en funktion anropa sig själv kallas rekursion. Det man behöver är:
- Rekursiv tanke: som reducerar problemet till ett enklare problem med samma struktur
- Basfall: det måste finnas ett fall som inte leder till rekursivt anrop
Test 4
Dags för test nummer 4. Testet hittar du som vanligt under rubriken Examination på kursens förstasida. Även detta test rättas automatiskt och du har möjlighet att göra om testet flera gånger om du inte lyckas på första försöket.
