Programmeringsteknik · 2011-04-17 · Programmeringsteknik - KTH CSC - 2010 Innehållsförteckning...

Programmeringsteknik

Materialet i detta häfte är skapat av KTH CSC (http://www.kth.se/csc) och används i en distanskurs som man kan läsa som fristående kurs och få universitetspoäng för. Kursen är avsedd för alla som vill lära sig grunderna i programmering men är också konstruerad för att passa in i några av KTH:s utbildningsprogram.

Mer information om kursen finns på: http://www.csc.kth.se/utbildning/kth/kurser/DD100N/

Copyright KTH CSC 2010 för hela häftet. Kopierat med tillstånd av KTH CSC.

Bearbetat av Håkan Lundberg, Cybergymnasiet, www.cybergymnasiet.se.

© KTH CSC

http://www.kth.se/csc

http://www.cybergymnasiet.se/

http://www.csc.kth.se/utbildning/kth/kurser/DD100N/

Programmeringsteknik - KTH CSC - 2010

Innehållsförteckning

1. Programmeringsintro...................................................................................................................4Vad är en dator?...........................................................................................................................4Vad är ett program?.....................................................................................................................5Vad är ett programspråk?............................................................................................................6Installera Python på din dator.....................................................................................................7Kom igång med Python och IDLE..............................................................................................7Tilldelning...................................................................................................................................8Olika slags värden.......................................................................................................................8Uppräkning..................................................................................................................................9Utskrifter...................................................................................................................................10Kommentarer.............................................................................................................................11

2. Styrstrukturer.............................................................................................................................12Inläsning....................................................................................................................................12Villkor.......................................................................................................................................13Strukturen på en if-sats är.........................................................................................................13Konstanter.................................................................................................................................14Else-del i if-sats.........................................................................................................................14Flera villkor...............................................................................................................................15Likhet........................................................................................................................................16While-slingor............................................................................................................................16Hur exekveras programmet?.....................................................................................................17En oändlig while-slinga............................................................................................................18Struktur på while-sats................................................................................................................19När ska man använda en while-sats?........................................................................................19Inlämningsuppgift 1 (Prat i kvadrat).........................................................................................20

3. Listor och Anrop........................................................................................................................21Listor.........................................................................................................................................21Vad är en lista?..........................................................................................................................21Hur använder man en lista?.......................................................................................................22Åter till exemplet......................................................................................................................23Mer om listor.............................................................................................................................25Uppslagslistor............................................................................................................................25Slingor.......................................................................................................................................26Moduler.....................................................................................................................................27Random.....................................................................................................................................28

Sid 2 av 57


4. Funktioner..................................................................................................................................30Vad har man funktioner till?......................................................................................................30Dela upp ett problem i funktioner.............................................................................................30Definiera en funktion................................................................................................................31Anropa en funktion...................................................................................................................31Skicka utdata från en funktion (returvärden)............................................................................32Skicka indata till en funktion (parametrar)...............................................................................35Rekursion..................................................................................................................................37Inlämningsuppgift 2 (Rondelet) ...............................................................................................38Tips............................................................................................................................................39Inlämning..................................................................................................................................39

5. Filer............................................................................................................................................40Filhantering...............................................................................................................................40Textfiler i Python.......................................................................................................................40

6. Klasser.......................................................................................................................................42Objektorientering......................................................................................................................42Attribut......................................................................................................................................42Metoder.....................................................................................................................................43Speciella metoder: konstruktorn och str....................................................................................43Klassen......................................................................................................................................44Exempel: Husdjursprogrammet................................................................................................45Sortering av en lista med objekt................................................................................................47Inlämningsuppgift 3 (Nöjesfält)................................................................................................48

Ordlista...........................................................................................................................................49Kortfattad programmerings- och Pythonordlista......................................................................49A................................................................................................................................................50B................................................................................................................................................50D................................................................................................................................................51E................................................................................................................................................51F................................................................................................................................................51G................................................................................................................................................52H................................................................................................................................................52I.................................................................................................................................................52K................................................................................................................................................53L................................................................................................................................................53M...............................................................................................................................................54N................................................................................................................................................54O................................................................................................................................................55P................................................................................................................................................55R................................................................................................................................................55S................................................................................................................................................55T................................................................................................................................................56U................................................................................................................................................56V................................................................................................................................................57W...............................................................................................................................................57ÅÄÖ..........................................................................................................................................57

Sid 3 av 57


1. Programmeringsintro

Vad är en dator?En dator i dagligt tal består väsentligen av ett tangentbord, en mus och en skärm som ibland sitter i samma låda som själva datorn. I tekniska sammanhang menar man ibland lådan med datorn och ibland endast processorn som sitter i lådan.

Löstagen processor (i svart) med sex rader med kontakter runt om.

Processorn sitter fast på ett kretskort, ofta kallat moderkortet och är kopplat till flera olika minnen. Viktigaste minnena är registren i processorn, där alla beräkningar och tolkningar (t ex om ett tal är större än ett annat) sker, RAM-minnet (Random Access Memory) där program ligger när de körs, och skivminnet (ofta kallat hårddisk) där program och dokument lagras för att vara kvar även när datorn har stängts av (till skillnad från RAM-minnet som töms varje gång strömmen stängs av).

Minneskort med minnen (RAM) i svart

Uppgifter som man brukar se i annonser om datorer är t ex processorhastighet mätt i MHz (MegaHertz), dvs miljoner cykler per sekund eller till och med GHz (GigaHertz), dvs miljarder cykler per sekund. Betyder detta att en 2GHz CPU är dubbelt så snabb som en 1MHz CPU? Inte nödvändigtvis. Det beror också på hur mycket arbete varje CPU utför per cykel.

Datorns prestanda är också i högsta grad beroende av minnets storlek och hastighet. RAM-storlek som mäts i MB (MegaByte), dvs miljoner byte. En byte består av vanligen åtta bitar och kan t ex

Sid 4 av 57


lagra ett tal mellan 0 och 255. En bit är den minsta minnesenheten på en dator och innehåller en etta eller en nolla. Skivminnet mäts också i byte och är något hundratal gånger större än RAM-minnet.

Ibland hör man benämningen "data". I IT-sammanhang betyder data endast information. Personer som använder data (eller ännu värre: "datan") för att referera till själva datorn upplevs ofta som mindre kunniga (se t ex Maria Bloms film Masjävlar) av de som skiljer på datorer och informationen som datorerna behandlar.

Om du glömmer bort vad ett visst ord betyder kan du slå upp det i vår ordlista över pythontermer.

På många ställen i den här kursen finns det testfrågor som du kan använda för att kolla om du har förstått. Prova först att lösa uppgifterna på egen hand. Här är en första uppmjukningsfråga.

Vad är en dator? 1. Detsamma som en processor med minne. 2. Detsamma som en processor, skärm, dator, tangentbord och mus. 3. Detsamma som en data.

Vad är ett program?Ett (dator-) program är en uppsättning instruktioner som styr vad datorn ska göra. Vanligen finns det indata (t ex knapp- eller mustryckningar) som behandlas av datorn enligt instruktionerna i programmet vilket resulterar i utdata (t ex text, diagram, bilder) på skärmen.

Sid 5 av 57


En analogi är stickning där samma indata (garn) med ett program kan bli till utdata i form av ett par sockor och med ett annat program till en tröja.

Precis som själva datorn består ett datorprogram väsentligen av två saker: minne och instruktioner. Minnet kallas för variabler, instruktionerna kallas ofta för satser. Satserna är det som avgör hur variablerna manipuleras (dvs ändrar värde).

Vad är ett datorprogram? (Det kan finnas flera riktiga svar.) 1. Något som styr en dator. 2. Detsamma som en processor, skärm, tangentbord och mus. 3. Något som styr hur en dator manipulerar indata för att presentera utdata. 4. En samling obegripliga ord i godtycklig ordning. 5. En samling av variabler och satser.

Vad är ett programspråk?En dator förstår endast sitt eget datorspråk, maskinkod, som är mycket svårhanterligt även för de flesta erfarna programmerare. För att underlätta för alla som programmerar skriver man därför vanligen program i ett programspråk som t ex Java, C++ eller som vi ska använda i denna kurs: Python. För att kunna få datorn att förstå och utföra program skrivna i Python krävs det att man översätter (kompilerar, tolkar, interpreterar) det till datorns eget språk.

Sid 6 av 57


Installera Python på din datorFör att kunna läsa den här kursen måste du installera Python på din dator. Python finns tillgängligt för många olika operativsystem, bland annat Linux/Unix, Mac OS X och Windows, och är enkelt att installera.

Innan du laddar ned Python, begrunda nedanstående:

Python 3.0 släpptes i början av december 2008, i denna version har bland annat syntaxen för print-kommandot ändrats och även en del andra förändringar genomförts.

Kursmaterialet i denna kurs är anpassat efter Python 2.4 - 2.6 vilket innebär att alla exempel, prov och övningar i boken förutsätter att någon av dessa versioner används.

För dig som ska installera Python på din dator, välj version 2.6.1 tillgänglig via www.python.org.

På webbplatsen python.org hittar du all information du behöver för att kunna ladda ner och installera den senaste versionen av Python på din dator.

Gå till python.org och följ instruktionerna för att installera Python. Om du får problem så kan du, som alltid, ställa en fråga i kursens webbforum eller kontakta kursens handledare.

Kom igång med Python och IDLENästa steg är att börja använda Python och IDLE. IDLE är ett ett utvecklingsverktyg för Python med vars hjälp man enkelt och behändigt kan skriva och testa sina program. One Day of IDLE Toying (http://hkn.eecs.berkeley.edu/~dyoo/python/idle_intro/) är en kort och lättläst introduktion som visar hur man använder IDLE för att skriva sitt första program. Gå dit, läs texten och prova själv på att skriva och köra ett Python-program (svensk översättning finns).

För Python finns det alltså två sätt att skriva program. Antingen skriver man programkod direkt i en pythontolk och ser resultatet av varje kommando efterhand som man skriver in sitt program. Detta fungerar bäst om man vill skriva mycket korta program som bara ska användas en gång eller om man vill testa hur något fungerar i Python.

Det andra sättet är att använda ett redigeringsprogram, till exempel det som är inbyggt i IDLE, och sedan låta pythontolken översätta och köra programmet. Fördelen med detta är att det blir enklare att gå tillbaka och ändra programmet om det inte blev riktigt rätt eller om man kommer på roliga tillägg. När man skriver större program gör man alltid på detta sätt.

Eftersom tolken bara är ett dumt program kräver den att texten i programfilen (eller det du skriver i tolken) mycket strikt följer bestämda regler. Ett väldigt litet pythonprogram som kan kompileras och köras utan fel ser ut så här: print "Hej!"

Om man skriver någonting som kompilatorn inte kan översätta kommer den att tala om var det är fel och vägra att översätta allt. Lyckas översättningen så går programmet att köra. I det här fallet kommer texten Hej! att skrivas ut.

Sid 7 av 57

http://hkn.eecs.berkeley.edu/~dyoo/python/idle_intro/

http://www.python.org/


TilldelningFör att hålla reda på data i ett program används variabler. Alla variabler har ett namn för att kunna skilja dem åt. Du kan jämföra med minnet på en miniräknare. Enklare räknare har bara ett minne och behöver därför inte namnge det. Mer avancerade räknare har flera minnen som namnges med t ex ett nummer. Ett datorprogram kan hålla reda på en stor mängd data. När man programmerar kan man lägga in data som t ex längd vikt och ålder i datorns minne med hjälp av variabler. För att tilldela variablerna värden skriver man i Python t ex:

age = 18length = 180weight = 80

I vänsterledet (vänster om =) skriver man namnet på den variabel som ska få ett nytt värde och i högerledet (höger om =) värdet som tilldelas. Likhetstecknet kallas i programmeringssammanhang för tilldelning (eller tilldelningsoperator). Man kan också skriva variabler i högerledet:

my_cousins_age = age

Då tilldelas my_cousins_age samma värde som age har. Alla variabelnamn i Python måste börja med en (engelsk) bokstav (inte åäö), men efter den kan man blanda bokstäver och siffror.

Högerledet kan innehålla uträkningar som behöver utföras innan tilldelningen sker:

a = 3b = a + 15

Ovanstående två rader ser till att b får värdet 18.

Ett bra sätt att förstå vad som händer i ett program är att stegvis går igenom det för hand och skriva upp alla variabelvärden. Varje variabel har endast ett värde åt gången och kommer inte ihåg vad för värde den haft tidigare.

Vad blir värdet på variabeln d efter följande rader?a = 12b = ac = a + b + 3d = c - b

Vad är det för fel på följande kod?6606 = svenska_flaggans_dag 1. 6606 är ett ogiltigt variabelnamn. 2. Det blir fel för att 6606 inte är svenska flaggans dag. 3. Man kan inte tilldela värdet 6606 ett nytt värde.

Olika slags värdenDet finns olika slags värden man kan tilldela variabler. Som vi tidigare sett kan man tilldela

Sid 8 av 57


variabler värden i form av tal, men man kan också tilldela teckenföljder som t ex namn. I datalitteraturen kallas teckenföljderna för strängar (av engelskans string som bland annat betyder sträng och kedja).

namn1 = 'Oskar'namn2 = "Kajsa"

För att skilja på variabelnamn och strängar omsluter man strängar med apostrofer eller citattecken.

namn3 = 'Sima'namn4 = namn3

I exemplet ovan får namn4 värdet 'Sima'. Hade man skrivit apostrofer runt namn3 hade namn4 istället fått värdet 'namn3'.

Vad blir det för värden på a och b efter följande rader?djur = 'katt'a = djurb = 'djur'

UppräkningMan kan öka värdet på variabler som tidigare har tilldelats ett värde med hjälp av uppräkningsoperatorn +=. Om variabeln innehåller en siffra räknas värdet upp. Efter följande rader

my_age = 19my_age += 1

får my_age värdet 20. Den första raden ger my_age värdet 19 och den andra raden räknar upp my_age med 1. När du trycker på pil upp eller ned i telefonnummerlistan på din mobil utför den en upp- eller nedräkning på samma sätt som andra raden.

Man kan åstadkomma samma sak med satserna:

my_age = 19my_age = my_age + 1

Men så många tecken orkar få programmerare att skriva. Anledningen att variabeln heter my_age istället för min_ålder är att åäö inte fungerar i variabelnamn.

Om variabeln innhåller en sträng läggs den nya strängen till den gamla. Efter satserna:

husdjur = "hund "husdjur += "och katt"

Kommer husdjur att vara "hund och katt".

Sid 9 av 57


Vad är värdet på a och s efter följande rader?a = 100b = 10a += bs = "svaret är "s += "a"

1. a = 10010, s = "svaret är 10010" 2. a = 110, s = "svaret är a" 3. a = 100, s = "svaret är 100" 4. a = 110, s = "svaret är 110" 5. 1 = 110, s = "svaret är 100"

UtskrifterFör att skriva ut värden på skärmen använder man instruktionen print. Prova följande pythonprogram i IDLE:

x = 15print xprint 1001print 14

Genom att använda ett kommatecken så kan man skriva ut flera saker på samma rad.

Exempelvis skriver

print "Charles is", 19, "years old"

ut "Charles is 19 years old" på samma rad. Observera att Python automatiskt lägger till ett blanktecken mellan strängarna vid varje kommatecken. Precis samma sak skrivs ut på samma sätt av:

age = 19print "Charles is", age, "years old"

Vill man att en senare utskrift (t ex en som görs av en print-sats några rader senare) ska göras på samma rad som den man just skriver ut låter man ett komma stå sist på raden:

print "Charles is",age = 2006-1987print age, "years old"

Ovanstående skriver också ut samma sak som tidigare.

Om man vill kombinera strängar utan att lägga till ett blanktecken så kan man istället använda sig av ett vanligt plustecken:

Sid 10 av 57


print "Charles is",age = 2006-1987print age + "."

Utskriften blir då "Charles is 19.".

Kommentarer# Skriv ut Charles ålderprint "Charles is",age = 2006-1987print age, "years old"

Den första raden i det här programmet, raden som börjar med #-tecknet, är en så kallad kommentar. Raden påverkar inte vad som händer när man kör programmet utan är enbart avsedd som information för den som läser programmet. I Python räknas allt från och med #-tecknet till radslut som en kommentar. Man kan till exempel skriva så här:

salary += 1 # Jippi, löneförhöjning!

Kommentarer kan kanske verka överflödiga men är i själva verket mycket viktiga för att man ska kunna förstå och överblicka sina program.

Vad skrivs ut när man kör följande program?# Skriv ut Annas telefonnummernamn = 'Anna'telefon = '06509911122'mobil = '07079911322'print namn, "har telefon", telefon

Sid 11 av 57


2. StyrstrukturerMamma ska resa till mormor över helgen. Hon är orolig för att lille Lasse, som ska vara alldeles ensam hemma, kommer att klä sig för tunt och vill därför ha ett program som hjälper honom med klädseln. För att kunna skriva ett sådant program behöver vi lära oss två saker: hur man läser inmatning från tangentbordet och hur man jämför tal.

InläsningFör att läsa från tangentbordet använder man en input-sats, t ex

temperatur = input()

Efter denna sats kommer variablen temperatur att innehålla det som den som körde programmet skrev på tangentbordet (och avslutade med returtangenten). Tyvärr är det svårt för den som kör programmet att fatta att det är just temperatur som ska matas in eftersom programmet inte frågar efter något. Det fixar man lätt med en print-sats:

# Exempel som visar hur inläsning går till.print "Ge utetemperatur: "temperatur = input()

Den här konstruktionen (skriv ut fråga och läs in svar) är så vanlig att man ordnat ett förkortat skrivsätt för den:

# Exempel som visar hur inläsning kan göras kortare.temperatur = input("Ge utetemperatur: ")

Viktigt att förstå är att input-satser läser inmatningen i den ordning den kommer. Det går inte att hoppa över någon del av inmatningen. Om någon skriver t ex 17[retur]42[retur] och du endast vill läsa det andra talet (42) måste man först läsa det första (17).

Vad får a för värde om inmatningen från tangentbordet är 22 <retur> 42 <retur>? a = input()

Vad får a för värde om inmatningen från tangentbordet är 17 <retur> 12 <retur>? a = input()a = input()

Vad får a för värde om inmatningen från tangentbordet är 22 <retur> 35 <retur>? a = input()b = input()

Vad får a för värde om inmatningen från tangentbordet är 19 <retur> 67 <retur>? b = input()a = input()

Sid 12 av 57


VillkorNär vi väl vet temperaturen kan vi kolla om den är för låg genom att skriva:

temperatur = input("Ge utetemperatur: ")if temperatur < 5: print "Ta på dej en halsduk, lille vän!"

Detta program kommer att se ut så här på skärmen: Ge utetemperatur: 1Ta på dej en halsduk, lille vän!eller Ge utetemperatur: 17

Detta program kommer alltså att skriva ut texten "Ta på dig en halsduk, lille vän!" endast om (svaret på frågan om) utetemperaturen är mindre än 5.

Strukturen på en if-sats ärif <BOOLESKT UTTRYCK> :

<EN ELLER FLERA SATSER SOM SKA EXEKVERAS>

En if-sats startar med reserverade ordet if, efter ordet if ska ett uttryck som resulterar ett booleskt värde (True eller False) komma. Efter uttrycket kommer tecknet kolon (:). Efter kolon kommer de satser som ska exekveras om värdet blir True. Dessa satser ska indenteras (flyttas in några steg) med mellanslags- eller tabulator-tangenten. För att undvika problem bör du inte blanda indentering gjord med mellanslag och tabbar i samma fil.

Vad kommer att skrivas ut av följande program om a = 12 och b = 12? if a < b: print "X",print "Y"

Vad kommer att skrivas ut av följande program om a = 4 och b = 4? if a <= b: print "X",print "Y"

Vad kommer att skrivas ut av följande program om a = 12 och b = 17? if a < b: print "X", print "Y",print "Z"

Vad kommer att skrivas ut av följande program om a = 8 och b = 6? if a <= b: print "X", print "Y",

Sid 13 av 57


print "Z"

KonstanterProgrammerare och andra nördar är kända för sin torra humor. Ett sätt att införa det i programmet är att införa en konstant. En konstant i Python är precis som en variabel, men som en konvention skriver man variabelnamnet med versaler, t ex:

MAMMAS_FRYSPUNKT = 5temperatur = input("Ge utetemperatur: ")if temperatur < MAMMAS_FRYSPUNKT: print "Ta på dej en halsduk, lille vän!"

En konstant ändrar inte funktionen i ett program från användarens sida, men det gör programmet lättare att modifiera för programmeraren (ffa om programmet är stort) och rätt använd kan den också göra programmet tydligare.

Else-del i if-satsOm villkoret temperatur < MAMMAS_FRYSPUNKT är False händer ingenting alls när man kör programmet. Det är trist programmering. Mamma vill gärna ha en uppmuntrande utskrift då och bygger ut if-satsen så här:

MAMMAS_FRYSPUNKT = 5temperatur = input("Ge utetemperatur: ") if temperatur < MAMMAS_FRYSPUNKT: print "Ta på dej en halsduk, lille vän!" else: print "Mammas gullgubbe slipper halsduk!"

Detta program kommer att se ut så här på skärmen: Ge utetemperatur: 2Ta på dej en halsduk, lille vän!eller Ge utetemperatur: 17Mammas gullgubbe slipper halsduk!

Satserna efter else kommer alltså att utföras när villkoret i if-satsen är False.

Vad kommer att skrivas ut av följande program om a = 13 och b = 7? if a <= b: print "A", print "B",else: print "C",print "D"

Vad kommer att skrivas ut av följande program om a = 36?

Sid 14 av 57


MITTEN = 42if a <= MITTEN: print "A", print "B",else: print "C",print "D"

Flera villkorPlötsligt kommer mamma på att det kan bli ännu kallare och vill ha en tredje utskrift om temperaturen är under noll.

# Ett program som visar hur if-elif-else fungerarMAMMAS_FRYSPUNKT = 5CELSIUS_FRYSPUNKT = 0temperatur = input("Ge utetemperatur: ")if temperatur < CELSIUS_FRYSPUNKT: print "Ta på dej halsduk och mössa!"elif temperatur < MAMMAS_FRYSPUNKT: print "Ta på dej en halsduk!"else: print "Mammas gullgubbe slipper halsduk!"

Detta program kommer att se ut så här på skärmen Ge utetemperatur: 3Ta på dej en halsduk!eller Ge utetemperatur: 17Mammas gullgubbe slipper halsduk!eller Ge utetemperatur: -2Ta på dej halsduk och mössa!

Hur många villkor som helst kan kombineras med hjälp av elif. Villkoren kontrolleras i tur och ordning, uppifrån och ned. Det första villkor som blir True får programmet att fortsätta exekveringen på de närmast följande indenterade satserna efter kolon fram till nästa icke-indenterade sats. Därefter hoppas resten av if-satsen över. Om inget villkor blir True (och endast då) utförs de indenterade satserna efter else.

Vad kommer min, max och b att ha för värden efter följande satser om a = -2? min = 5max = 10b = 0if a < min: min = aelif a > max: max = a

Sid 15 av 57


else: b += 1

LikhetNär man vill testa likhet så används dubbla likhetstecken. Enkelt likhetstecken används bara till tilldelning. Exempel:

betyg = 2123if betyg == 2000: print "Du har precis kommit in på högskolan"elif betyg > 2000: print "Du har kommit in på högskolan"else: print "Du har inte kommit in på högskolan"

Vad skrivs ut om x = 5 och y = 3? if x > 2: if y > 4: print "blå" elif x == y: print "gul" else: print "röd"else: print "grön"

While-slingorNär en eller flera satser ska upprepas ett antal gånger är en while-sats ett bra hjälpmedel. Anta att man vill skriva ett program som skriver texten "Python" 5 gånger på skärmen. Detta kan man åstadkomma genom att använda en while-sats enligt nedan. Siffrorna i början på varje rad är för att vi ska kunna referera till raderna i texten. När man programmerar skriver man förstås utan siffror och kolon.

1: antal_varv = 0 2: while antal_varv < 5 :3: print "Python"4: antal_varv += 1

Innan vi går igenom programmet presenterar vi idén bakom programkoden.

För att lösa problemet behöver vi en räknare för att hålla reda på antalet gånger texten "Python" skrivits ut så att programmet kan sluta skriva ut texten efter 5:e gången.

Programmet har alltså följande uppgifter att utföra:

Skapa en räknare och nollställa den

Sid 16 av 57


Kontrollera räknarens värde Skriva ut texten "Python" Uppdatera räknarens värde

Nu ska vi gå igenom programmet i detalj.

I radnummer 1 har vi koden "antal_varv = 0". Där har vi valt variabeln antal_varv som ska fungera som räknare och får startvärdet 0.

Resten av programmet är while-satsen. Syntaxen för en while-sats liknar syntaxen för if-satser som vi har sett tidigare i lektionen om villkor.

Radnummer 2 är "while antal_varv < 5 :" som är följande instruktion för datorn:

"Exekvera alla indragna rader som kommer efter kolon så länge variabeln antal_varv har ett värde som är mindre än 5"

Radnummer 3 (print "Python") är en indragen rad och ingår därför i while-slingan. Den skriver ut texten "Python".

Radnummer 4 (antal_varv += 1) ser till att räknaren ökar värdet med ett.

Uppdatering av antal_varv är ett viktig steg i while-satsen som tillsammans med villkoret "antal_varv < 5" (i rad 2) avgör om texten "Python" ska skrivas ut ytterligare en gång eller inte.

Vad skrivs ut av följande program? i = 0v = 1while i < 5: v = i * v print v i += 1

Hur exekveras programmet?antal_varv=0while antal_varv < 5 : print "Python" antal_varav += 1

I första raden av programmet får variabeln antal_varv värdet 0. Därefter exekveras uttrycket antal_varv < 5 och eftersom att 0 är mindre än 5 är villkoret uppfyllt (True) vilket får till följd att while-slingan startar. Det första som händer i den är att print "Python" exekveras. Därefter exekveras antal_varav += 1 och därmed ändrar antal_varv värde till 1. Nu är slingan slut och därför exekveras uttrycket antal_varv < 5 igen och eftersom att 1 är mindre än 5 går vi ett varv till i while-slingan. Där exekveras print "Python" och antal_varav += 1.

Sid 17 av 57


Ovanstående tre satser upprepas ytterligare tre gånger tills antal_varv får värdet 5. När då uttrycket antal_varv < 5 exekveras, till skillnad mot alla tidigare gånger, blir värdet falskt (False) eftersom att 5 inte är mindre än 5. Och därför avslutas exekvering av while-satsen och i det här fallet avslutas även programmet då det inte finns några fler satser kvar att exekvera.

I vilken ordning exekveras följande program? Awhile B: CD

Vi antar följande förutsättningar: • Programmet går endast tre varv. • A är en godtycklig tilldelningssats. • B är en godtycklig villkorssats som är sann i tre varv. • C och D är godtyckliga utskriftssatser.

1.ABCD 2.ACCCD 3.ABCCCD 4.ABCBCBCD 5.ABCBCBCBD 6.ABCABCABCD

En oändlig while-slingaOm man tar bort rad nummer 4 från programmet får man följande:

antal_varv = 0while antal_varv < 5 : print "Python"

Vi ser att variabeln antal_varv inte kommer att ändras i while-satsen. Detta gör att villkoret (antal_varv < 5) kommer förbli sant under hela programmet alltså kommer texten "Python" att skrivas ut om och om igen oändligt många gånger.

Om du råkar ut för detta när du kör ett program kan du avbryta programmet genom att trycka Ctrl-c. Det gör du genom att först trycka ner tangenten märkt "Ctrl" på tangentbordet och fortsätta hålla den nere och samtidigt som du också trycker ner "C".

Hur många gånger skrivs texten "hej" när man kör följande program? v = 5while v > 5: print "hej" v += 1print "hej"

Sid 18 av 57


Kommer följande program skriva ut texten "hej då"? Om inte, varför? i = 0while i < 10: print "hej"print "hej då"

Struktur på while-satsStrukturen på en while-sats är exakt som strukturen på en if-sats om man bara byter ut if mot while i en if-sats.

while <BOOLESKT UTTRYCK> : <EN ELLER FLERA SATSER SOM SKA EXEKVERAS>

En while-sats startar med reserverade ordet "while", efter ordet "while" ska ett uttryck som resulterar ett booleskt värde (True eller False) komma. Efter uttrycket kommer tecknet kolon (:). Efter kolon kommer de satser som ska exekveras flera gånger.

Vad är det som är fel i följande while-sats? Programmet ska skriva ut "hej" oändligt antal gånger. i = 1WHILE i < 10: print "hej"

1. 'WHILE' och 'print "hej"' måste stå rakt under varandra och ej vara förskjutna. 2. i = 1 ska tas bort. 3. i < 10 ska ändras till i == 1. 4. Ordet 'WHILE' ska stå med små bokstäver.

När ska man använda en while-sats?En while-sats används när en eller flera rader kod ska exekveras ett bestämt eller obestämt antal gånger efter varandra.

Följande är exempel på program där antalet upprepningar är obestämd och beror på användarens inmatning:

tal = input("Gissa ett tal mellan 1 och 100:")while tal != 74 : tal = input("Fel, försök igen:")print "Grattis du gissade rätt!"

I vilka av följande tillfällen kan man med fördel använda sig av while-satser? 1. När man vill att programmet ska skriva ut samma text flera gånger efter varandra. 2. När man vill skriva ut alla tal mellan 5 och 95. 3. När man vill utföra en sak 10 gånger.

Sid 19 av 57


Inlämningsuppgift 1 (Prat i kvadrat)I den första inlämningsuppgiften ska du skriva och skicka in ditt första pythonprogram. Programmet ska skriva ut de första n kvadrattalen: 1*1, 2*2, ... , n*n, där talet n anges av den som använder programmet. Programmet ska också skriva ut summan av dessa kvadrattal. Här är ett exempel på en körning:

Välkommen till prat i kvadrat.Hur många kvadrattal vill du skriva ut? 41 * 1 = 12 * 2 = 43 * 3 = 94 * 4 = 16Summan av kvadrattalen: 30

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

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

Innan du skickar in programmet så ska du testa att det fungerar. Kontrollera speciellt att programmet fungerar korrekt även om användaren skriver in talet 0 eller 1. (I den här uppgiften finns det inget krav på vad som ska hända om användaren matar in ett negativt tal eller skriver in något annat än ett heltal. Om du vill så får du dock gärna försöka upptäcka felaktig inmatning och skriva ut lämpliga felmeddelanden.)

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.

Sid 20 av 57


3. Listor och Anrop

ListorOftast är den som skriver ett program dvs programmeraren inte den som kommer att använda det. Den som skriver programmet har kunskap om programmering men man ställer inga krav om kunskap i programmering för den som ska använda programmet. Detta gör att programmeraren måste skriva programmet på ett sätt så att den kan köras av olika användare med olika förväntningar.

Antag att vi vill skriva ett program som ska läsa in fem stycken namn och när man har matat in alla fem namnen skrivs de ut i omvänd ordning (dvs sista namnet först).

Med den programmeringskunskap du har idag är detta fullt möjligt. Det är bara att använda sig av fem olika variabler för att lagra namnen och sedan skriva ut dem i omvänd ordning, som programmet nedan. (Funktionen raw_input fungerar ungefär som input. Skillnaden är att raw_input inte försöker översätta indata till lämpligt format utan läser in hela raden som en teckensträng som kan bestå av både bokstäver, siffor, mellanslag och andra tecken.)

namn1 = raw_input("Ange ett namn: ")namn2 = raw_input("Ange ett namn: ")namn3 = raw_input("Ange ett namn: ")namn4 = raw_input("Ange ett namn: ")namn5 = raw_input("Ange ett namn: ")print namn5, namn4, namn3, namn2, namn1

Programmeraren har bestämt att 5 och endast 5 namn ska matas in. Programmet fungerar varken för färre eller fler antal namn.

Det vore bättre om programmet ställer en fråga om hur många namn som ska matas in i början av programmet och användarens svar på denna fråga avgör om hur många variabler som ska användas till att lagra alla namn. Men programmeraren kan fortfarande inte veta hur många variabler som ska användas eftersom att olika användare kommer att kunna mata in olika antal namn. Hur ska programmeraren göra?

Lösningen är att använda en lista.

Vad är en lista?En lista är variabel som kan ha flera värden. Varje värde får ett eget index (nummer) som kan användas för åtkomst eller modifiering av värdet. Om en vanlig variabel fungerar som en stol så fungerar en lista som en bänkrad i en biograf när det är numrerad placering. Telefonnummerlistan i din mobil är ett exempel på en lista.

Sid 21 av 57


Hur använder man en lista?Listor skrivs med hjälp av klamrar []

namnlista = 3*[None]

namnlista blir då en variabel som har plats för 3 olika värden. None betyder att alla platserna ska vara lediga. Om man vill tilldela första platsen i variabeln ett värde t ex talet 47 gör man på följande sätt:

namnlista[0] = 47

I ovanstående rad är namnlista namnet på listan. [0] specificerar avsedd plats i listan, 0 är ett index som används för specificera första plats. = 47 som vi vet sedan tidigare är en tilldelningssats. Hela raden gör att första plats i listan får värdet 47. Programmerare är lite lustiga på det sättet att 0 betyder första plats i en lista. Detta gäller i flera programspråk, t ex Java och C++.

Om man vill tilldela andra plats i listan ett nytt värde t ex "hej" använder man därför indexet 1:

namnlista[1] = "hej"

För att skriva ut alla värden som finns i listan kan man skriva som nedan:

print namnlista

Om man endast vill skriva ut värdet på en specifik plats i vektorn får man använda sig av klamrar igen:

print namnlista[2]

Raden ovan skrivet ut värdet som finns på tredje platsen i listan.

Hur många platser har följande lista?

Sid 22 av 57


bilar = 16*[None]

Åter till exempletNu när vi har lärt oss lite om listor ska vi försöka skriva programmet som frågar efter ett antal namn och skriver ut dem i omvänd ordning:

1. antal_namn = input("Hur många namn vill du mata in? ") 2. namnlista = antal_namn*[None] 3. i = 0 4. while i < antal_namn: 5. namnlista[i] = raw_input("Ange ett namn: ") 6. i += 1 7. j = antal_namn - 1 8. while j >= 0: 9. print namnlista[j]10. j -= 1

I rad 1 frågar programmet efter ett tal (antal namn) inmatningen lagras i variabeln antal_namn.

I rad 2 skapar vi en lista som har lika många platser som användarens svar från första raden.

I rad 3 använder vi iterationsvariabeln i som ska användas i while-slingan som finns i rad 4-6.

Rad 4 -6 är en while-slinga som ska upprepa satsen i rad 5 så länge variabeln i är mindre än antalen namn som ska matas in.

Rad 5 frågar användaren efter ett namn och svaret kommer att lagras på i:te platsen i namnlista. I rad 6 vi ökar det värde som i har med 1.

En sammanfattning av den första while-slingan är att variabeln i startar med värdet 0 och i första varvet i slingan kommer namnlista[i] alltså att motsvara namnlista[0] eftersom i är 0. Alltså tilldelas första plats i listan ett nytt värde. Sedan när i ökas med 1 så får variabeln i värdet 1. Och i andra varvet kommer namnlista[i] motsvara namnlista[1] dvs andra plats i listan osv.

Detta upprepas tills i blir lika med antal_namn och alla platser i listan har fått ett värde.

När while-slingan i rad 4-6 är klar kommer listan innehålla så många namn som användaren ville mata in. Nu är det dags att programmet skriver ut alla namn i omvänd ordning. För att skriva ut sista namnet först måste vi ta reda på index för det sista namn som matades in.

Vi vet att index för första namnet är 0, index för andra namnet är 1 och index för tredje namnet är 2 osv. Men vad är index för det sista namnet?

Vi vet att antal namn som har matats in är lika många som värdet antal_namn (rad 1 i programmet). Om antal_namn t ex har värdet 10 så ska sista namnet ha placerats i plats nummer

Sid 23 av 57


9 (= 10 - 1).

I radnummer 7 vill vi tilldela variabeln j ett startvärde, startvärdet ska vara samma värde som index för sista namnet i listan. Med ovanstående kunskap vet vi att j = antal_namn - 1 kommer att vara index för den sista plats i listan.

Rad 8-10 är en while-sats som skriver ut alla element från namnlista i omvänd ordning.

Så här fungerar den andra while-satsen: Variabeln j har ett startvärde som är lika med index för sista platsen. While-satsen ska upprepa print-satsen (rad 9) så länge variabeln j har ett värde som är större eller lika med 0. Första varvet i slingan kommer namnlista[j] att motsvara sista namnet som finns i listan eftersom att j har just ett värde som är lika stort som index för sista namnet. På rad 10 kommer värdet av variabeln j minskas med 1. Alltså, j kommer att ha samma värde som index för näst sista namnet i listan och därför i andra varvet i slingan kommer namnlista[j] att motsvar näst sista namn i listan osv.

Antag att vi har listan ages med ålder på 50 personer. Vilket av följande är korrekt om man vill komma åt femtonde elementet i listan? 1.ages[14] 2.ages14 3.ages15 4.ages, 14 5.ages[15] 6.ages, 15

Antag att vi har listan ages med ålder på 50 personer. Vilket av följande kodexempel summerar alla element i listan ages?

1. i = 0sum = 0while i < 50: sum += ages + i i += 1

2. i = 0sum = 0while i < 50: sum += ages[i] i += 1

3. summera(ages)

4. i = 0

Sid 24 av 57


sum = 0while i < 50 sum += i i += 1

Mer om listorDet finns ytterligare några list-kommandon som är bra att känna till. Man kan lägga till ett nytt element i slutet av en lista med hjälp av append():

namn = ["Adam", "Bertil", "Ceasar"]namn.append("David") # Listan namn utökas till ["Adam", "Bertil", "Ceasar", "David"]

Man kan också slå samman två listor med hjälp av ett vanligt plus-tecken:

a = [1, 2, 3] + [4, 5] # Resultatet blir [1, 2, 3, 4, 5]

Slutligen kan man plocka ut dellistor på följande sätt:

veckodagar = ["mån", "tis", "ons", "tor", "fre", "lör", "sön"]# plockar ut elementen fr o m index 0 t o m index 4 i listanvardagar = veckodagar[0:5] # plockar ut elementen fr o m index 5 t o m index 6 i listanhelgdagar = veckodagar[5:7]

UppslagslistorIbland så har man en mängd data där det inte är naturligt att numrera elementen som i en vanlig lista. Då kan man istället använda en uppslagslista (dictionary). En uppslagslista består av ett antal poster, där varje post har en nyckel och ett värde. I följande exempel så håller vi reda på antalet dagar per månad med hjälp av en uppslagslista. I varje post så finns det en nyckel, som är en textsträng som innehåller månadens namn, och ett värde, som är ett tal som anger antalet dagar i månaden. Man kan använda både strängar och tal som nycklar och värden.

month = {"jan":31, "feb":28, "mar":31, "apr":30, "maj":31, "jun":30, "jul":31, "aug":31, "sep":30, "okt":31, "nov":30, "dec":31}

print month["feb"] # Skriver ut 28month["feb"] = 29 # Ändrar "feb":s värde till 29print month["feb"] # Skriver ut 29

# Tar bort en post och lägger till två nya i uppslagslistan.del month["feb"]month["feb_vanlig"] = 28month["feb_skotte"] = 29

Sid 25 av 57


# Skriver ut False eftersom månaden "qui" inte finns med i uppslagslistan.# (Quintilis döptes om till juli för att ära Julius Caesar.)print month.has_key("qui")

# Metoden keys() ger en lista med alla nycklar i uppslagslistan.# Utskriften blir (observera att en uppslagslista inte är ordnad):# ['mar', 'okt', 'aug', 'sep', 'apr', 'jun', 'feb_vanlig',# 'jul', 'jan', 'feb_skotte', 'nov', 'maj', 'dec']names = month.keys() print names

SlingorDet är så pass vanligt att man går igenom listor eller strängar från början till slut att det finns ett särskilt kommando för detta i Python, den så kallade for-satsen. Utskriften från följande program

tanter = ["Brun", "Grön", "Gredelin"]for tant in tanter: print "Tant", tant

blir

Tant BrunTant GrönTant Gredelin

For-satsen har alltså följande format

for <index> in <lista>: <sats>

där <index> är ett variabelnamn, <lista> en lista och <sats> en sats som kommer att utföras en gång för varje element i listan. I det första varvet av listan så kommer variabeln <index> att innehålla det första elementet i listan, i det andra varvet så innehåller den det andra elementet, och så vidare.

For-kommandot kan också användas för att gå igenom de flesta ordnade typer, till exempel en sträng. Här är ett exempel där vi använder en for-sats för att kontrollera om tecknet W finns med i en sträng:

alfabetet ="ABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ"for bokstav in alfabetet: if bokstav == "W": print "Ja, W fanns med i alfabetet!"

For-satsen är också mycket användbar om man vill gå igenom en lista av tal, sådana listor kan man nämligen snabbt och lätt skapa med hjälp av kommandot range(). Här är ett exempel:

Sid 26 av 57


#Skriver ut: 1 2 3 4 5 6 7 8 9for i in range(1, 10): print i,

Man anger en range med hjälp av startvärde, slutvärde och uppräkning. Observera att startvärdet finns med i listan, slutvärdet är däremot en övre gräns som inte finns med i listan. Här är ett par exempel:

a = range(100) # [0, 1, 2, 3,..., 99]b = range(0, 100, 5) # [0, 5, 10, 15,..., 95]

ModulerStora program delar man upp i mindre delar med bland annat funktioner. Funktionerna kan placeras i olika filer. En fil med en samling av funktioner kallas för modul. För att vi ska kunna använda en viss funktion från en viss modul måste vi importera tillhörande modul innan anropet av funktionen. Importeringen kan man göra med en enkel import-sats som vi förklarar nedan.

Man kan ha stort nytta av modularisering i program. Med modularisering kan man återanvända kod vilket gör att man inte behöver lägga tid på och anstränga sig för att skriva en motsvarande kod som redan har skrivits. Dessutom blir stora program med flera tusen rader kod mer överskådliga om de delas upp på ett bra sätt i moduler. I denna kurs tar vi inte upp hur man modulariserar utan vi nöjer oss med att lära hur man anropar funktioner som finns i moduler.

När man installerar Python medföljer en hel del moduler. För att använda en funktion som finns i en modul måste man importera modulen. Detta gör man med hjälp av reserverade orden from, import och modulnamnet. Information om vilka moduler som följer med och vilka funktioner finns i varje modul kan man hitta på http://docs.python.org/lib/lib.html.

Anta att vi behöver beräkna roten ur 23 i ett program. Vi har från http://docs.python.org/lib/lib.html fått informationen att i modulen math finns en funktion som heter sqrt(x) som beräknar roten ur x och returnerar svaret. För att använda funktionen ska man importera modulen genom att skriva följande sats:

from math import *

Först nu efter importeringen kan vi anropa funktionen sqrt enligt nedan:

sqrt(23)

Observera att import-satsen behöver endast vara med en enda gång för att man ska kunna anropa en funktion flera gånger i ett program. Ett bra ställe för import-satser är därför i början av programmet.

Vad betyder modularisering? 1. Dela upp ett program i fristående delar. 2. Slå ihop två program till ett.

Sid 27 av 57

http://docs.python.org/lib/lib.html

http://docs.python.org/lib/lib.html


3. Slå ihop flera program till två. 4. Slå ihop tre program till ett.

Vad är modularisering bra för? 1. För att man ska kunna återanvända kod. 2. För att man kommer att höja prestanda hos programmet. 3. För att man ska få ett mer överskådligt program. 4. Är ett sätt att gömma undan kod så att andra inte ska kunna förstå programmet.

RandomEtt exempel på en modul som man kan importera är random som förser programmeraren med slumptal. Ibland vill vi att ett program ska vara oförutsägbart. Dvs det ska inte gå att förutse vad som kommer att hända i nästa stund av programmet. Detta beteende är väldigt vanlig i t ex spel där spelet byter strategier eller beter sig olika vid olika tillfällen. T ex ett äventyrsspel där det plötsligt kan dyka upp ett monster. Detta kan man åstadkomma med hjälp av slumpfunktionen random() som finns i modulen random. En modul är en samling med funktioner och annat som kan vara till användning i många program och är ett sätt att organisera funktioner.

För att kunna använda funktionen random() måste man ha importerat modulen random i programmet, detta gör man med den enkla import-satsen:

from random import *

Efter denna sats kan man anropa funktionen random() som genererar ett slumptal (decimal) från och med 0 till 1. Till exempel:

from random import *s_tal = random()

s_tal kommer då att ha ett värde som är mindre än 1 och större eller lika med 0.

Om man vill generera heltal så kan man använda funktionen randrange() som också finns i modulen random.

h_tal=randrange(1,3)

Variabeln h_tal kommer att bli heltalet 1 eller heltalet 2. randrange(a,b) betyder att slumpa ett heltal, heltalet kommer att vara större eller lika med a och mindre än b.

När skriver följande program texten "Det kommer att bli en solig sommar"? from random import *weather = random()if weather < 0.2 : print "Det kommer att bli en solig sommar"else: print "Det kommer att bli en regnig sommar"

Sid 28 av 57


1. Alltid. 2. Endast när slumptalet som genererats av weather = random() är större än 0.2. 3. Endast om det inte regnar när man kör programmet. 4. Aldrig. 5. Endast när slumptalet som genererats av weather = random() är mindre än 0.2.

Sid 29 av 57


4. Funktioner

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? EbbaKlara...färdiga...gå!

Ebba: - - - - - - - - - - - - - - - - - - - - - - - - - @Racersnigeln: - -- - - - - - - - - - - - - - - - - - - @

Det här loppet tog en oväntad vändning, Ebba vann!

Dela upp ett problem i funktionerFö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

Sid 30 av 57


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?

Definiera en funktionFö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 informationsrutandef 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 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 funktionSatserna 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:

Sid 31 av 57



# Visa information om tävlingenvisaInformation()# Läs in namnet på en snigel# Simulera tävlingen# Rita upp en snigels bana# Skriv ut vem som vann

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

Sid 32 av 57


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 snigeldef lasNamn(): namn = raw_input("Vad heter din snigel? ") return namn

# Visa information om tävlingenvisaInformation()# Läs in namnet på en snigeldinSnigelsNamn = lasNamn()# Simulera tävlingen# Rita upp en snigels bana# Skriv ut vem som vann

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

Sid 33 av 57


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” (vara tillgänglig) 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


# Läser in namnet på användarens snigeldef lasNamn(): namn = raw_input("Vad heter din snigel? ") return namn

# Simulerar en tävling mellan två sniglardef 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# Visa information om tävlingenvisaInformation()# Läs in namnet på en snigeldinSnigelsNamn = lasNamn()# Simulera tävlingensnigelbana1, snigelbana2 = tavling()

Sid 34 av 57


# Rita upp en snigels bana# Skriv ut vem som vann

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

Sid 35 av 57


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 (default-vä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


# Läser in namnet på användarens snigeldef lasNamn(): namn = raw_input("Vad heter din snigel? ") return namn

# Simulerar en tävling mellan två sniglardef 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 snigelbanadef ritaBanan(snigelnamn,langd):

Sid 36 av 57


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

# Skriver ut vinnarendef 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 = 30visaInformation()dinSnigelsNamn = lasNamn()snigelbana1, snigelbana2 = tavling()ritaBanan(dinSnigelsNamn, snigelbana1)ritaBanan("Racersnigeln", snigelbana2)utseVinnare(snigelbana1, snigelbana2, dinSnigelsNamn)

RekursionNu 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

Sid 37 av 57


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

Inlämningsuppgift 2 (Rondelet) 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

Sid 38 av 57


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

TipsMedan 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."

InlämningProgrammet 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.

Sid 39 av 57


5. FilerInformation som man vill ha kvar på en dator sparas på fil. Det kan t ex röra sig om ett brev som har skapats med hjälp av ett ordbehandlingsprogram, en bild som har skapats av ett ritningsprogram eller en kamera osv. Filer sparas på långtidsminnen som t ex datorns skivminne (hårddisken). När man sparat en fil på hårddisken kommer filen att finnas kvar där även när man har startat om datorn eller t ex när det blir strömavbrott. Därför är det bra att spara den programkod man skriver på en fil för senare bearbetning. Dels för att det sällan blir rätt första gången, dels för att när man väl provkört kommer man på fler saker man önskar av programmet.

Filer kan delas upp i tre sorter: • Vanliga filer: som innehåller data (t ex text eller bildinformation). • Katalog eller mapp: som innehåller andra filer. • Länkar, genvägar eller alias: En fil som refererar till en fil.

Kataloger används för att organisera filer och program. Kataloger kan innehålla andra kataloger. T ex kan man spara alla filer som har skapats i samband med sommarkursen under katalogen ”sommarkurs”. Strukturen kallas i datorsammanhang ofta för ett filträd.

Länkar används t ex för att man ska kunna hitta samma fil på flera ställen. En bildfil kan ta stor plats och en populär bild kan man vilja ha med på många ställen. För att slippa kopiera bilden lägger man då istället länkar till den. Länkarna tar nästan ingen plats alls.

FilhanteringPå nästan alla datorer finns det ett grafiskt användargränssnitt (det du ser på skärmen) som kan användas för att organisera filer med hjälp av musen, kortkommandon eller ett filhanteringsprogram.

Filer, kataloger och länkar har då grafiska symboler som kallas för ikoner.

I programmeringssammanhang är det väldigt vanligt att använda tangentbordskommandon för filhanteringen, t ex för att utföra:

• Förflyttning i filträdet. • Kopiering av filer. • Radering av filer.

Allt detta kan man också göra i ett pythonprogram. I den här kursen begränsar vi oss dock till att visa hur man kan skapa textfiler och läsa och skriva i sådana filer.

Textfiler i PythonAntag att det redan finns en fil som heter kompisar.txt med följande innehåll: Anna BokCaesar DavidsonErling Franson

Sid 40 av 57


Här är ett pythonprogram som läser innehållet i filen, rad för rad, och lagrar strängarna i en lista med namnet friends.

friends = []file = open('kompisar.txt', 'rU')for line in file: friends.append(line)file.close()

Funktionen open öppnar filen men namnet kompisar.txt för läsning (r betyder "read", U betyder "Universal newline mode" och är en mekanism i Python som översätter de olika tecknen för radslut som förekommer i olika operativsystem till standardtecknet \n). Med hjälp av en for-sats går vi igenom filen rad för rad. När man är klar med filen så bör man stänga den med hjälp av funktionen close. Så länge en fil är öppen så har ditt program ensamrätt på den här filen och andra processor på datorn kan inte komma åt den. Om man glömmer att göra close() så sker det automatiskt när programmet avslutas.

Om man vill skapa en helt ny fil med namnet kollegor.txt så kan man göra så här. Om det redan finns en fil med namnet kollegor.txt så skriver man istället över innehållet i den filen. Var försiktig.

file = open('kollegor.txt', 'w')file.write('Gustav Hast\n')file.write('Ingemar Johansson\n')file.close()

I det här fallet så ger man parametern 'w' (som betyder 'write') till open-funktionen. Observera att man själv måste skriva ut radslutstecken om man vill att filen ska innehålla flera rader. Tecknet \n är ett specialtecken som används i strängar för att markera ett radslut.

Sid 41 av 57


6. Klasser

ObjektorienteringObjektorienterad programmering är ett sätt att kombinera data och funktioner för att bilda objekt. Objekten är ofta modeller av verkliga ting. Om vi vill skriva ett program för att simulera ett rymdskepp kan vi till exempel ha hastighet och lägeskoordinater som data. Rymdskeppets funktioner kan vara att accelerera i en viss riktning och att rotera.

För att kunna använda objekt i sitt program måste man först definiera en klass. Klassen beskriver vilka data ett objekt ska kunna innehålla och vilka funktioner det ska ha. Om vi definierat en klass för rymdskepp kan vi sedan skapa hur många rymdskepps-objekt vi vill!

Fråga: Vi vill skriva ett program för att lägga patiens. Vilken av följande klasser ska vi definiera i programmet?

1. Poäng 2. Spader 3. Kort

Det stora exemplet i det här avsnittet kommer att handla om ett virtuellt husdjur. Ett husdjur kan ju ha många egenskaper, men vi väljer ut två att ta med i vår klass: namn och skick (ett heltal som talar om hur den känner sig just nu). Användaren får själv välja namn på sitt husdjur, och husdjurets skick ska påverkas av hur den behandlas.

AttributDe variabler som används för att lagra data som hör till objektet kallas attribut. Våra husdjursobjekt ska alltså ha attributen namn och skick. Om man har flera objekt av samma typ är attributens värde helt oberoende av varandra. Två olika husdjur får ha olika namn och olika skick.

Det finns en synlig skillnad mellan attribut och vanliga variabler. Inuti klassen använder man alltid ordet self när man vill komma åt ett attribut. Man kan till exempel skriva så här:

self.namn = "Fido"

Med self menar man objektet självt.

Fråga: Anta att vi jobbar med ett program för vitvaruhandeln. Vilka av följande alternativ skulle passa som attribut för ett spis-objekt?

1. bredd 2. energiklass 3. ugnsvolym

Sid 42 av 57


MetoderFunktionerna som hör till ett objekt kallas metoder. För att en funktion ska bli en metod måste den definieras inuti klassen. Den första parametern i en metod måste alltid vara self. Via self kan metoden använda objektets attribut.

Säg att vi vill ha en metod som ger vårt husdjur bannor (i uppfostrande syfte). Metoden ska visa bannorna, och även minska värdet på skick eftersom husdjuret blir på sämre humör.

def banna(self): print print "- Fy på dig", self.namn, "!" self.skick -= 3

Som synes skriver man en metod precis som en funktion, sånär som på ordet self. Samma regler för parametrar och returvärden gäller.

Husdjursklassen ska så småningom få metoder som gör följande: • skapar ett husdjursobjekt och ger attributen värden • visar i vilket skick husdjuret är • bannar husdjuret • matar husdjuret • leker med husdjuret • tar avsked av husdjuret

Fråga: I en internetbutik vill vi ha ett objekt som representerar en kundvagn. Vilka av följande kan tänkas bli metoder i ett kundvagns-objekt?

1. lägga ner en vara i kundvagnen 2. beräkna totalpriset för alla varor i kundvagnen 3. räkna ut dagens vinst för internetbutiken

Speciella metoder: konstruktorn och strMetoder får man döpa precis som man vill. Men det finns ett par metodnamn som har speciell betydelse för Python. Här tar vi upp två av dessa. Metodnamnen börjar och slutar med två understrykningstecken, så det finns ingen risk att man råkar välja namnen av misstag.

Konstruktorn är en speciell metod som man skriver för att initiera objekt, dvs ge objektets attribut de värden de ska ha från början. Konstruktorn anropas automatiskt varje gång ett objekt skapas. I Python måste man döpa sin konstruktor till __init__ (alltså init med två understrykningstecken både före och efter).

Konstruktorn för vårt husdjursobjekt kommer att se ut så här:

def __init__(self, djurnamn): self.namn = djurnamn self.skick = 0

Sid 43 av 57


Den här konstruktorn har två parametrar, self (som ju alltid måste vara med) och djurnamn. Raden self.namn = djurnamn skapar attributet namn och initierar det till värdet av parametern djurnamn. På samma sätt skapar raden self.skick = 0 attributet skick och initierar det till noll. Varje gång man gör ett nytt objekt kommer konstruktorn att anropas.

Den andra specialmetoden vi ska ta upp här heter __str__, och det speciella med den är att den anropas varje gång man försöker skriva ut ett objekt med print. Här kan man alltså tala om hur man vill att objektets data ska skrivas ut. Exempel:

def __str__(self): return self.namn + "*" + str(self.skick)

Metoden __str__ är särskilt användbar under tiden man arbetar med programmet, för att det blir enklare att göra kontrollutskrifter.

Fråga: Vilket av följande måste en konstruktor ha? 1. parametern self 2. en parameter för varje attribut 3. ett returvärde

KlassenFör att kunna skapa ett objekt måste man först definiera en klass. Det är i klassen man skriver de metoder som objektet ska ha. Klasser brukar ha namn som börjar med versal, så att man lätt ska kunna se att det är en klass. Så här långt har vi hunnit i vår husdjursklass hittills:

# En klass som beskriver ett virtuellt husdjur.# Attribut:# namn - djurets nanm# skick - ett heltal som beskriver djurets skickclass Husdjur:

# Konstruktorn def __init__(self, djurnamn): self.namn = djurnamn self.skick = 0

# För utskrift med print def __str__(self): return self.namn + "*" + str(self.skick)

# Ger husdjuret bannor. Skick minskas. def banna(self): print print "- Fy på dig", self.namn, "!" self.skick -= 3

Med en klass är det likadant som med en funktion - det händer inget förrän man använder den i

Sid 44 av 57


huvudprogrammet. För att skapa ett Husdjurs-objekt kan vi skriva:

djur = Husdjur("Muffin")

Det som händer här är att konstruktorn __init__ anropas, så att attributen skapas och initieras. Sen returneras ett Husdjurs-objekt, som lagras i variabeln djur.

Nu har vi ett husdjursobjekt i variabeln djur. Hur anropar vi en av djurets metoder? Just nu finns bara metoden banna att välja på:

djur.banna()

När vi vill komma åt ett attribut inuti klassen använder vi ju en punkt, och ett liknande skrivsätt använder man alltså när man vill anropa en metod från ett objekt.

Fråga: Kan man skriva Husdjur.banna()?

Exempel: HusdjursprogrammetHär följer hela programmet, först Husdjurs-klassen, och sedan huvudprogrammet. Lägg märke till att alla metoderna i klassen är indenterade.


# Konstruktorn, initierar attributen namn och skick. def __init__(self, djurnamn): self.namn = djurnamn self.skick = 0

# Visar husdjurets namn och skick def visaSkick(self): print self.namn, "är ", if self.skick > 5: print "glad: (^_^)" elif self.skick > 0: print "ledsen: (T_T)" else: print "hungrig: ('o')" print

# Ger husdjuret bannor. Skick minskas. def banna(self): print print "- Fy på dig", self.namn, "!" self.skick -= 3

# Ger husdjuret mat. Skick ökar. def mata(self, mat): print

Sid 45 av 57


for i in range(mat): print "GLUFS", self.skick += mat

# Leker med husdjuret. Skick kan öka eller minska. def leka(self): print if self.skick < 0: self.skick -= 1 print self.namn, " vill inte leka." else: self.skick += 1 print "~~~~~~~~~~~ WHEEEEEEE! ~~~~~~~~~~~"

# Skriver ut avskedet. def avsked(self): print print "Hejdå,", self.namn, "kommer att sakna dig!"

# Här slutar Husdjursklassen

# -------- Här börjar huvudprogrammet -----------djurnamn = raw_input("Vad vill du döpa ditt husdjur till? ")djur = Husdjur(djurnamn)djur.visaSkick()svar = raw_input(" Vill du \n banna \n mata \n leka med \n ditt husdjur? " )while svar: if svar[0]=="m": bullar = input("Hur många bullar? ") djur.mata(bullar) elif svar[0]=="b": djur.banna() elif svar[0]=="l": djur.leka() else: print "Hursa? " djur.visaSkick() svar = raw_input("Vill du \n banna \n mata \n leka med \n ditt husdjur?")djur.avsked()

Provkör programmet och svara på följande frågor.

Fråga: Hur många objekt skapas i programmet?

Fråga: När metoden visaSkick skriver ut att husdjuret är trött - vilka värden har attributet skick då?

Fråga: Hur avslutar man programmet?

Fråga: Hur många metoder finns det i klassen Husdjur?

Fråga: Kan man få programmet att krascha?

Sid 46 av 57


Sortering av en lista med objektOftast skapar man fler än ett objekt i sitt program. Då är det praktiskt att spara objekten i en lista. En lista med objekt kan enkelt sorteras efter sina attribut. Men på något sätt måste man ange vilket attribut man vill sortera på. Är det namn eller skick?

Så här kan sortering av en lista skrivas:

lista.sort(key = lambda x:x.attr)

Parametern key i sort visar att man vill ange vilket attribut man vill sortera på. Uttrycket lambda x:x.attribut är som en liten funktion i miniatyr där parametern står före kolonet och returvärdet efter. Om vi tänker oss att x är objektet så är attr det av objektets attribut som vi vill sortera på.

Om det attribut man sorterar på är en sträng görs sorteringen efter bokstavsordning. Är attributet ett tal så blir objekten sorterade i stigande ordning. Vi förenklar Husdjursklassen en aning och visar med exemplet nedan hur sorteringen kan göras i praktiken:

import random


# Konstruktorn, initierar attributen namn och skick. def __init__(self, djurnamn): self.namn = djurnamn self.skick = random.randrange(-5,6) # För utskrift av ett objekt med print def __str__(self): return self.namn + "*" + str(self.skick) # ------- Här slutar Husdjursklassen ---------

# En funktion för utskrift av listandef skrivListan(listan): for o in listan: print o, print "\n"

# -------- Här börjar huvudprogrammet ---------

djurlista = [Husdjur("Missan"), Husdjur("Blixten"), Husdjur("Fido"), Husdjur("Miso")]

Sid 47 av 57


print "Så här ser listan ut från början:"skrivListan(djurlista)

djurlista.sort(key = lambda husdjur:husdjur.namn)print "Nu är listan sorterad efter namn, i bokstavsordning:"skrivListan(djurlista) djurlista.sort(key = lambda husdjur:husdjur.skick)print "Nu är listan sorterad efter skick, i stigande ordning:"skrivListan(djurlista)

Fråga: Hur gör man om man vill sortera i avtagande istället för i stigande ordning? Svar: Man kan enkelt vända på listan efter sorteringen med djurlista.reverse()

Inlämningsuppgift 3 (Nöjesfält)Du ska skriva ett program som simulerar ett nöjesfält. Använd objekt för att representera attraktionerna. En attraktion kan till exempel ha namn, minimilängd (för att få åka), antal passagerare och magpirrfaktor. Den ska kunna göra reklam för sig, startas, stoppas och haverera.

Skriv också ett huvudprogram där användaren får välja mellan tre olika attraktioner. Vald attraktion ska startas, kanske haverera (slumpa fram haverier) och stannas. När attraktionen är igång ska det synas på skärmen, till exempel med Iiiih från berg-och-dalbanan, skratt från lustiga huset och så vidare.

Kravet för att bli godkänd är att du med ditt program visar att du kan skriva en egen klass med attribut och metoder, och använda den i ett program. I övrigt har du fria händer!

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

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

<Programkod>

Innan du skickar in programmet så ska du testa att det fungerar. Se till att du har provat alla klassens metoder, och fått se alla utskrifter som ditt program gör.

När du har testat ditt program grundligt så går du till studentportalen och klickar dig fram till Inlämningsuppgift 3 och där lämnar du in filen Uppgift3.py. Observera att filen Uppgift3.py 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.

Sid 48 av 57


Ordlista

Kortfattad programmerings- och Pythonordlista

= är »tilldelningsoperatorn« (assignment operator). Den används för att ge en variabel ett värde. Variablen står först på raden, sen likhetstecknet, och sist det värde som variabeln ska få. Exempel x = 5

== är »lika med«-operatorn som ger True om de två värden som jämförs är lika, och annars False. Exempel if x == 5:

not är »negerings«-operatorn som ger True om den står framför ett uttryck som har värdet False, och False om den står framför ett uttryck som har värdet True. Exempel if not sluta: # sluta har värdet True eller False

!= är »skilt från«-operatorn som ger True om de två värden som jämförs är olika, och annars False. Exempel if x != 5:

< är »mindre än«-operatorn som ger True om värdet av det första uttrycket är mindre än värdet av det andra uttrycket, och annars False. Exempel if x < 5: # Om x är mindre än 5

<= är »mindre än eller lika med«-operatorn som ger True om värdet av det första uttrycket är mindre än eller lika med värdet av det andra uttrycket, och annars False. Exempel if x <= 5 # Om x är mindre än eller lika med 5

> är »större än«-operatorn som ger True om värdet av det första uttrycket är större än värdet av det andra uttrycket, och annars False. Exempel if x > 5: # Om x är större än 5

>= är »större än eller lika med«-operatorn som ger True om värdet av det första uttrycket är större än eller lika med värdet av det andra uttrycket, och annars False. Exempel if x >= 5 # Om x är större än eller lika med 5

and är »och«-operatorn som ger True om bägge uttrycken är True, annars False.

or är »eller«-operatorn som ger True om minst ett av uttrycken till är True, annars False.

() är vanliga (runda) parenteser som används till parameterlistan i funktioner och aritmetiska uttryck.

[] är hakparenteser (square brackets) som man använder för att ange index (elementnummer) i listor.

% är resten (modulo) vid heltalsdivision. Ex: 7 % 3 blir 1 medan 6 % 3 blir 0 och 5 % 3 blir 2.

Sid 49 av 57


' (apostrof, Unicode U+0027) används för att skriva strängar. Exempel: 'k', '\t' (tabulatortecken), '\u0b87' (Unicodetecken nummer b87).

" (citattecken, Unicode U+0022) används också för att skriva strängar. Exempel: "hejsan".

+ - * / är tecknen som används som operatorer för de fyra räknesätten. Observera att om bägge operanderna i en division är heltal blir det heltalsdivision (ingen avrundning: 9/10 blir 0). Se prioritetsordning.

+= och -= är förkortade skrivsätt för uppräkning och nedräkning.

# är kommentartecknet. Allt som står efter detta tecken på en rad ignoreras av Python-tolken, nästan, see åäö.

; semikolon används för att skilja på Python-satser som står på samma rad.

Aadress är ett unikt tal som representerar en minnesposition i datorns internminne.

algoritm, instruktionsföljd för lösning av problem.

array se lista.

assignment, se tilldelning

avlusa, hitta och rätta fel i program.

Bbibliotek, se katalog

binära tal är det sätt som en dator lagrar information (även text). Talen representerar en tvåpotens. Ex: Det binära talet 10001 (skrivs också 100012) betyder egentligen 1*24 + 0*23 + 0*22 + 0*21 + 1*20 = 1710 (utläses sjutton i basen 10, eller 17 decimalt och betyder analogt 1*101 + 7*100).

bit, minsta minnesenheten i en dator. Innehåller hög eller låg spänning, eller olika magnetiseringsriktningar för att representera värdet noll eller ett. Flera (vanligen åtta) bitar som gruppers ihop bildar en byte (bitgrupp).

block, en följd indenterade kodrader

browser (eng) webbläsare, t ex Mozilla, Safari och MS Internet Explorer.

bug (eng) lus, fel i program. Enligt uråldriga programmerarsägner uppstod namnet på femtiotalet när ett fel i en dator visade sig ha orsakats av en insekt (bug) som kortslöt några ledningar.

Sid 50 av 57


byte, bitgrupp om vanligen 8 bitar.

Ddebugga, se avlusa.

directory, se katalog.

division, se /

Eeditor, se redigeringsprogram.

elif, se if

eller, villkorsoperator se ||

else, se if

evaluera betyder ungefär beräkna, men kan användas även om det inte ingår några tal, t ex att evaluera ett uttryck som resulterar i en sträng.

exekvering. Vad en dator gör när den utför ett program, dvs går igenom programkoden och utför den.

exekveringsavbrott. När ettfel som uppstår under körning av ett program får programmet att krascha. Kan t ex bero på indata som programmet inte är anpassat för eller att man går utanför en listas gränser. Använd spårutskrifter för att ta reda på var och varför det blir fel.

expression se uttryck

FFalse, booleskt värde som representerar ett falskt påstående (icke uppfyllt villkor). Se även True.

falskt, se False.

felsökning, se avlusning, exekveringsavbrott och kompileringsfel.

fil, datorernas motsvarighet till pappersdokument. En fil kan innehålla t ex en text, ett program, en film, ett ljud, eller en bild.

filnamn, till skillnad mot pappersdokument måste alla filer namnges. Hur detta görs beror på vilket operativsystem datorn använder. Specialtecken som åäö kan ställa till problem i filnamn eftersom åäö hanteras olika i olika operativsystem.

flöde, se programflöde.

Sid 51 av 57


flyttal, se reella tal.

for en slinga för att gå igenom en följd värden, t ex element i en lista eller rader i en fil. Exempel for x in range(10, 0, -1):

function invocation se funktionsanrop.

funktion, är en namngiven grupp av variabeldeklarationer och satser som kan anropas vid behov. I funktionsdeklarationen anger man vilken kod som skall utföras när funktionen anropas. Funktionsdeklarationen innefattar funktionens namn, en parameterlista (som kan vara tom), och ett block som innehåller koden.

funktionsanrop medför att den kod som finns i funktionen utförs. Anropsparametrarna används för att förse funktionen med indata. Funktionen kan dessutom vidarebefordra utdata till den anropande koden genom en retursats (return).

Ggemen bokstav är detsamma som liten bokstav. Se även versal.

gränssnitt är kontaktytan mellan två enheter, t ex människa och maskin, borrmaskin och borrar.

HHTML, Hyper Text Markup Language, språk som används för att göra layout av framför webbsidor. Se http://www.atiger.pp.se/sida.html.

hårdkoda, progammerarslang för att frångå principerna om att göra program anpassningsbara. Jämför med att skruva fast möbler i golv och väggar i stället för att bara ställa dit dem.

Iif...else används i villkorssatser. De indenterade satserna som står före else utförs endast om villkoret efter if blir True, annars utförs de indenterade satserna efter else. Både else och satsen efter else kan utelämnas. Flera villkor kan kombineras med elif. Exempelif x > 5: print ”x är större än 5.”elif x < 5: print ”x är mindre än 5.”else: print ”x är lika med 5.” implementera, göra program körbara på dator (till skillnad från t ex skissa på papper).

import används för att importera paket och enskilda funktioner till ett Pythonprogram.

Sid 52 av 57


indentering innebär att man flyttar in rader med mellanslag eller tabulator-tecken.Exempel if x > 5: print ”x är stärre än 5.” # Denna rad är indenterad

ingenting är ett värde som är svårt att representera på en dator eftersom alla minnesutrymmen innehåller någonting. För tal används vanligen värdet 0; för strängar är det vanligt att använda en tom sträng (""). I Python kan man dessutom använda None för att representera att en variabel inte har något värde.

initialize se initiera

initiera en variabel innebär att ge den ett startvärde.

inläsning från tangentbord görs vanligen med raw_input() eller input(). Se även utmatning.

inmatning, se inläsning.

input(), funktion i Python som läser indata från tangentbordet och tolkar det som det vore ett uttryck i Python. Bra för att läsa tal. Vill man läsa inmatningen utan tolkning, t ex för att läsa text använder man istället raw_input()

inte, se not

iteration, datorjargong för upprepning, vanligen i samband med while- och for-slingor.

Kkatalog, (directory, bibliotek) förvaringsutrymme för filer och kataloger.

koda, programmerarjargong för skriva programkod.

kommentar, rad i Python som börjar med # och därför ignoreras av Python-tolken. Används för att förklara saker för programmeraren som inte framgår direkt av koden.

kompilator översätter ett program från källkod (människoläsbart format) till maskinkod.

kompilera, översätta källkodsprogram med en kompilator.

kompileringsfel. Fel som uppstår när en kompilator inte kan översätta källkoden.

källkod är det normala sättet att representera ett program i ett format läsbart för människor. Alla Pythonexempel i denna kurs är källkod. Se även maskinkod.

LLista är en ordnad följd av element. Varje element har ett unikt nummer från 0 till n-1, där n är listans storlek. För att manipulera enskilda element i en vektor måste man använda ett heltalsindex

Sid 53 av 57


för att komma åt det. Vanligen använder man for-slingor för att gå igenom alla element i en lista. Exempel lista = [”en”, ”liten”, ”lista”, ”med”, ”strängar”]

litteral är källkodsrepresentationen av ett värde av primitiv typ, strängtyp, eller None. Exempel: "hello", 'k', 8, 1.0E4, True, None.

logiska uttryck, uttryck med värdet True eller False. Se t ex and, or och not.

logiskt fel, fel som beror på att programmeraren inte tänkt igenom programmet ordentligt. Programmet går att kompilera och köra utan felavbrott, men det gör fel saker. Använd spårutskrifter för att hitta felet.

loop se slinga, while eller for.

läsa, vad ett program gör för att komma åt nya indata. Ett program kan läsa från tangentbordet, musen och filer.

Mmaskinkod, program som kompilerats för att passa en viss datortyp (och kan därmed inte flyttas till andra sorters datorer.

matematiska uttryck, se +-*/

method invocation se funktionsanrop

metod är en funktion som är definierad i en klass.

metodanrop, se funktionsanrop.

metoddeklaration, se metod och funktion.

minne finns av två sorter: primärminne (internminne) och sekundärminne (externminne). I primärminnet befinner sig programmet när det körs och där finns också alla variabler som används. På sekundärminnet (t ex disketter och CD-skivor) lagras information i filer.

modulo rest vid heltalsdivision, se %

Nnegation, se not

None är en litteral som anger att en variabel saknar värde. Se även ingenting.

nyckelord eller reserverat ord är ett fördeklarerat ord i Python som inte får användas som identifierare: and, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is, lambda, not, or, pass, print, raise, return, try, while, yield.

Sid 54 av 57


Ooch, se and

operator är en symbol som representerar en operation i ett programspråk. Additionsoperatorn + och tilldelningsoperatorn = är exempel på operatorer i Python.

or, se eller.

Pparameter är antingen en anropsparameter, det värde som skickas till en funktion vid ett funktionsanrop, eller en formell parameter, den identifierare man använder för att namnge en parameter i funktionsdeklarationen. Den formella parametern får sitt värde från anropsparametern vid funktionsanropet och är en lokal variabel i funktionen.

parse analysera eller tolka. I datorsammanhang vanligen att tolka en följd av tecken eller ord.

print, se utskrift.

prioritetsordning anger i vilken ordning operationer ska utföras. T ex ska 3+4*5 evalueras till 23 (inte 35) eftersom multiplikation har högre prioritet än addition.

program, instruktionsföljd för dator.

programflöde, ordningsföljden i vilken satserna i ett program utförs.

Rrandom, modul som innehåller funktioner för slumptal.

random() funktion i random som returnerar ett slumptal mellan 0 och 1.

raw_input(), funktion i Python som läser indata från tangentbordet som en sträng. Vill man tolka inmatningen som det vore ett uttryck i Python, t ex om man vill läsa tal, använder man istället input()

read, se inläsning

redigeringsprogram (editor), program som kan användas för att ändra innehållet i filer.

Ssammansatt villkor är villkor som kombineras med and eller or. Se logiskt uttryck.

sant, se True.

sats är den minsta kompletta operationen i ett program, motsvaras oftast av en rad i programmet.

Sid 55 av 57


slinga (loop, snurra) är ett antal satser i ett program som utförs för alla element i en följd eller så länge ett villkor är sant. I Python skapar man slingor med for eller while.

slumptal kan fås t ex med hjälp av random().

snurra, se slinga

snygg kod är kod som är korrekt, lättläst och lätt att ändra.

spårutskrift utskrift som används för att man ska se vad som händer när programmet körs, så att man ska kunna hitta fel i programmet.

statement se sats

syntax är regler för hur satser i ett program ska skrivas i programspråket.

Ttilldelning (assignment) ger en variabel ett nytt värde. En tilldelning kan göras med tilldelningsoperatorn =. När man använder tilldelningsoperatorn kommer uttrycket i högerledet att evalueras och det resulterande värdet kopieras till variabeln i vänsterledet. Se även = i början av detta index. Exempel: n = 17 # n får värdet 17 i = 42 * n # i får värdet 714 v[2] = i-14 # tredje elementet i v får värdet 700 v[n] = 4711 # artonde elementet i v får värdet 4711

tom sträng representeras av två citattecken ("").

True, booleskt värde som representerar ett sant påstående (uppfyllt villkor). Se även False.

UUnicode är den standardiserade 16-bitars teckenkod som används bland annat för att representera tecken i Python. Unicode innehåller de tecken som behövs för att kunna skriva texter på alla vanligt förekommande språk.

upprepa, se slinga.

utmatning, se utskrift.

utskrift, ge information till användaren genom att skriva text (till skillnad från att rita ut något). För skärmutskrift används vanligen print

uttryck (expression) är en av beståndsdelarna i en sats. Ett uttryck består av operatorer och operander. Operanderna kan vara variabler, funktionsanrop, metodanrop eller litteraler. Det går att beräkna värdet av ett uttryck.

Sid 56 av 57


Vvariabel är en identifierare (ett namn) i ett program som representerar en minnesposition där ett värde lagras när programmet körs.

vektor se lista.

villkor eller booleska uttryck kan bildas med booleska värden (True och False) eller variabler och funktioner (med booleska värden) och med jämförelseoperatorer. Resultatet är ett värde som antingen är True eller False. Används i bland annat if-satser och while-slingor. Exempel Om minaPengar innehåller ett tal så är uttrycket minaPengar > 0 sant (True) om minaPengar har ett värde större än noll. Uttrycket är falskt (False) om minaPengar är noll eller negativt. Flera villkor kan kombineras med logiska operatorer (not, and, or). Värdet av ett villkor kan sparas i en variabel.

villkorssats (conditional statement) är en sats som gör det möjligt att välja mellan ett eller flera alternativa satser beroende på om ett villkor är uppfyllt eller inte. I Python skapar man villkorssatser med if.

Wwhile-slinga, ett sätt att åstadkomma upprepning. Exempel while True:

ÅÄÖÅäö brukar ställa till det i alla programmeringsspråk. Man kan inte använda åäö i variabelnamn. Ibland får man dessutom problem när man använder det i utskrifter. Ofta försvinner dessa problem om man först i programmet skriver en kommentar: #-*-coding: iso-8859-1-*-

Sid 57 av 57

Programmeringsteknik · 2011-04-17 · Programmeringsteknik - KTH CSC - 2010 Innehållsförteckning...

Documents

Transcript of Programmeringsteknik · 2011-04-17 · Programmeringsteknik - KTH CSC - 2010 Innehållsförteckning...