4. Funktioner

Programmeringsteknik

Nuvarande version

[redigera] 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!

[redigera] 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:

1. Skriv ut informationsrutan och läs in namnet på snigeln
2. Simulera tävlingen och rita upp banorna
3. 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:

1. Skriv ut informationsrutan
2. Läs in namnet på en snigel
3. Simulera tävlingen
4. Rita upp en snigels bana
5. 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.

Fråga: Tänk om vi ville skriva ett program för stavningskontroll, i vilka funktioner skulle vi då dela upp det?

Svar:Till exempel följande: inläsning av ordlistan, kontroll av ett ord mot ordlistan, utskrift av rättelseförslag

[redigera] Definiera en funktion

Först kommer funktionshuvudet (första raden i funktionen). Exempel:

def visaInformation():

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 kommer funktionskroppen, som helt enkelt är en följd av indenterade satser som funktionen ska utföra. Så här ser hela funktionen ut:

# Skriver ut informationsrutan
def visaInformation():
    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 trä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!

[redigera] 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:

# Skriver ut informationsrutan
def visaInformation():
    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

visaInformation()

Spara i filen snigel.py och provkör!

[redigera] 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 lasNamn():
    namn = raw_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.

dinSnigelsNamn = lasNamn()

När den här satsen utförs av Python kommer följande att hända. Först anropas funktionen lasNamn, som läser in namnet och returnerar det. Sen kommer det returnerade värdet att lagras i variabel dinSnigelsNamn.

Vi lägger in den nya i filen snigel.py och provkör.

# Skriver ut informationsrutan
def visaInformation():
    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
def lasNamn():
    namn = raw_input("Vad heter din snigel? ")
    return namn

# Simulera tävlingen
# Rita upp en snigels bana
# Skriv ut vem som vann

visaInformation()
dinSnigelsNamn = lasNamn()

Men hur ska vi veta om det fungerade eller inte? Jo, vi lägger in en kontrollutskrift

print "Din snigel heter alltså", dinSnigelsNamn

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():
    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

# Skriver ut informationsrutan
def visaInformation():
    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äser in namnet på användarens snigel
def lasNamn():
    namn = raw_input("Vad heter din snigel? ")
    return namn

# Simulerar en tävling mellan två sniglar
def tavling():
    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
visaInformation()
dinSnigelsNamn = lasNamn()
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

[redigera] 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 ritaBanan. Här följer tre olika exempel på hur en sån funktion skulle kunna anropas:

ritaBanan("Ebba", 31)
ritaBanan("Racersnigeln", 28)
ritaBanan(dinSnigelsNamn, 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 ritaBanan(snigelnamn,langd):
    print snigelnamn.rjust(12) + ":",
    for i in range(1,langd):
        print "-",                 # slemspåret
    print "@"                      # snigeln

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:

ritaBanan(dinSnigelsNamn,snigelbana1)
ritaBanan("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 utseVinnare(langd1, langd2, namn1, namn2="Racersnigeln"):
    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:

utseVinnare(snigelbana1, snigelbana2, dinSnigelsNamn)

Nu sätter vi ihop alltihop och provkör:

import random

# Skriver ut informationsrutan
def visaInformation():
    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äser in namnet på användarens snigel
def lasNamn():
    namn = raw_input("Vad heter din snigel? ")
    return namn

# Simulerar en tävling mellan två sniglar
def tavling():
    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

# Ritar en snigelbana
def ritaBanan(snigelnamn,langd):
    print snigelnamn.rjust(12) + ":",
    for i in range(1,langd):
        print "-",    #slemspåret
    print "@"         # snigeln

# Skriver ut vinnaren
def utseVinnare(langd1, langd2, namn1, namn2="Racersnigeln"):
    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."


DISTANS = 30
visaInformation()
dinSnigelsNamn = lasNamn()
snigelbana1, snigelbana2 = tavling()
ritaBanan(dinSnigelsNamn,snigelbana1)
ritaBanan("Racersnigeln",snigelbana2)
utseVinnare(snigelbana1, snigelbana2, dinSnigelsNamn)

[redigera] Rekursion

Bild på kakaopaket

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):
    return summa(n-1) + n

print "Välkommen till summaberäkningsprogrammet!"
print "Här beräknas summan 1+2+3+...n"
n = input("Vilket tal 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):
    if n > 1:
        return summa(n-1) + n
    else:
        return 1

print "Välkommen till summaberäkningsprogrammet!"
n = 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

[redigera] Test

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.

[redigera] Inlämningsuppgift 2 (Rondelet)

Inlämningsuppgiften är individuell och får inte lösas i grupp.

I den här inlämningsuppgiften ska du skriva ett antal funktioner för att göra ett program som skapar en dikt av en inläst text. Programmet ska läsa in fyra meningar och sedan skriva ut texten uppdelad på följande rader:

1. Textens fyra första ord
2. Resten av första meningen
3. Textens fyra första ord igen
4. Andra meningen
5. Tredje meningen
6. Fjärde meningen
7. Textens fyra första ord en sista gång

Texten kommer då att likna en rondelet - en fransk diktform.

Här är ett exempel på en körning:

                DIKTAUTOMATEN

Skriv in fyra meningar och få ut en rondelet!

Skriv mening nr 1: Det fanns ingen fil när jag handlade på Konsum.
Skriv mening nr 2: Bananerna var också slut.
Skriv mening nr 3: Jag köpte bröd istället.
Skriv mening nr 4: Nån sorts limpa med mycket fibrer.


DET FANNS INGEN FIL

Det fanns ingen fil
när jag handlade på Konsum.
Det fanns ingen fil
Bananerna var också slut.
Jag köpte bröd istället.
Nån sorts limpa med mycket fibrer.
Det fanns ingen fil

[redigera] Tips

Medan du testar programmet kan du ersätta anropet av din inläsningsfunktion med tilldelningssatser. På det sättet slipper du skriva in fyra meningar varje gång du testkör ditt program!

# För testning:
sentence[0] = "Det fanns ingen fil när jag handlade på Konsum.
sentence[1] = "Bananerna var också slut.
sentence[2] = "Jag köpte bröd istället.
sentence[3] = "Nån sorts limpa med mycket fibrer."

Det finns en användbar metod i Python som heter split() med vars hjälp du kan dela upp en mening så att det blir en lista av enskilda ord. Här är ett exempel som visar hur man använder split():

mening = "En ganska kort mening."
lista = mening.split()
# lista har nu värdet ["En", "ganska", "kort", "mening."]

För att göra om små bokstäver till stora i en sträng så kan du använda metoden upper():

mening = "En ganska kort mening."
ny_mening = mening.upper()
# ny_mening har nu värdet "EN GANSKA KORT MENING."

[redigera] Inlämning

Programmet ska finnas i en fil med namnet Uppgift2.py. Följ den här mallen:

# Programmeringsteknik webbkurs KTH inlämningsuppgift 2.
# <Ditt namn>
# <Datum>
# <Kort beskrivning av vad programmet gör>

<Programkod>

Innan du skickar in programmet så ska du se till att där inte finns någon kodupprepning som kan åtgärdas med funktioner och slingor.

När du har finputsat ditt program så går du till kursens förstasida. Under rubriken Examination hittar du Inlämningsuppgift 2 och där kan du lämna in filen Uppgift2.py. Observera att filen måste vara i textformat, vilket den automatiskt blir om du skapar den med hjälp av IDLE. Detta för att vi ska kunna prova och testköra ditt program.