Programmeringsteknik - Nya sidor [sv]

FAQ

KTH.SE:u1ndpe5c — Fri, 29 Jun 2007 14:16:06 GMT

Sammanfattning:

==FAQ==

# '''Jag vill inte ha ny rad mellan min utskrifter. SVAR''': Skriv ett komma(,) efter print-satsen, t ex <code>print "Strumpor och",</code>
# '''Felmeddelandet "TypeError: cannot concatenate 'str' and 'int' objects" SVAR''': Om du skriver ut både strängar och tal i samma print-sats kan du behöva konvertera talen till strängar: <code>print frukten + " kostar " + str(pris)</code>
# '''Hur gör man formatterad utskrift? SVAR''': Exempel:
#:<pre>
#:print " Sko Storlek Pris"
#:print "%10s%8i%12.2f"%(skonamn,storlek,pris)
#:</pre>
#:Här är skonamn en sträng som skrivs ut i tio positioner (%10s), storlek ett heltal som skrivs ut i åtta positioner (%8i) och pris ett flyttal som skrivs ut i tolv positioner med två decimaler (%12.2f). Dokumentation finns på [http://docs.python.org/lib/typesseq-strings.html]
# '''Felfönstret "Already executing" dyker upp. SVAR''': När du kör program från IDLE tänk på att avbryta en gammal körning (t ex med ctrl+c) innan du kör programmet igen.
# ''' En if-sats fungerar inte. SVAR''': Tänk på att använda rätt datatyper. En sträng med en etta "1" är inte samma som heltalet 1. Om du läst in rader från en fil och jämför med dem i if-satsen kan problemet vara ett "\n" sist i den inlästa raden som måste städas bort med <code>raden.strip()</code>
# '''Felmeddelandet "invalid_syntax" SVAR''': Om du inte ser felet direkt kan det vara raden innan som är fel.
## Har du glömt kolon(:) på raden innan om du använder if, while eller for?
## Har du tabbat in raderna efter kolon?
## Saknas ett citattecken, en parentes <code>()</code> eller en klammer <code>[]</code> på raden innan?
## Kolla tabbar, även kommentarer med tre <code>'</code>-tecken måste tabbas rätt! Matcha med det stycke ovan som ska ha samma intabbning.
## Python har rätt, det finns ett fel någonstans!
# ''' "None" skrivs ut på skärmen. SVAR''': En funktion utan return-sats returnerar None. Troligen har du råkat anropa en sån funktion i en print-sats, t ex <code>print skriv_ut()</code> Lösningen är att anropa funktionen utan print (eller låta funktionen returnera den sträng som ska skrivas ut).
# ''' Nyckeln jag söker efter i en dictionary fungerar inte. SVAR''': Om du läst in nycklarna från en fil kan problemet vara ett "\n" sist i den inlästa raden som måste städas bort med <code>raden.strip()</code>
# ''' När jag läst in en rad från fil och skriver ut den på skärmen så skrivs en extra tomrad ut. SVAR''': Varje rad du läser in från filrn har ett radbrytningtecken "\n" i slutet. Du får enklast bort detta genom att på varje rad du läser från filen använda funktionen strip(). I stället för: <code>raden = filen.readline()</code> skriver du: <code>raden = filen.readline.strip()</code>
# '''När jag läser in filen så läses inget in, men det har fungerat förut. SVAR''': Kontrollera att filen finns. Öppna filen (med t ex WordPad) och kolla så den innehåller något. Spara och stäng filen igen.
# '''Jag använder sys.exit() för att avbryta programmet, men då får jag en massa röd text i IDLE. SVAR''': Lägg in en
#:<pre>
#:try: ... except SystemExit:
#:</pre>
#:runt ditt anrop av main så slipper du den röda texten.
# '''Jag har skrivit en klass och får felmeddelandet "NameError: global name 'namn' is not defined" SVAR''': Har du kommit ihåg att skriva <code>self</code> framför alla förekomster av dina attribut?
# '''Jag försöker skriva ut en rad streck med en slinga, men får mellanslag mellan varje tecken, så här - - -, istället för det jag vill ha ---. Hur ska jag göra för att Python inte ska lägga in mellanslagen automatiskt? SVAR''': I modulen sys finns en variabel som inför varje print håller reda på om ett mellanslag ska skrivas ut eller inte. Man kan själv ställa om variabeln så här:
::<pre>
::import sys
::for i in range(5):
:::print "-",
:::sys.stdout.softspace = False</pre>

10. P-uppgift: redovisning

KTH.SE:u1ndpe5c — Wed, 27 Jun 2007 14:52:46 GMT

Sammanfattning: /* Redovisning */

==Redovisning==

''P-uppgiften är individuell och får inte lösas i grupp.''

När du är godkänd på samtliga moment på kursen (sex tester och sex
inlämningsuppgifter) är det dags att lämna in det färdiga programmet
som görs på vanligt sätt under rubriken "P-uppgift Slutinlämning".
Glöm inte bort att skicka med alla filer till programmet dvs även
text-filer. Du kontaktas därefter för att bestämma datum för den
muntliga redovisningen som görs på KTH i Stockholm.

Under redovisningen är det du som ska visa vad och hur du har gjort
för att lösa uppgiften och du ska också kunna motivera dina val.
Naturligtvis avnjuter vi också en provkörning av programmet med all
möjlig och omöjlig indata.

Granskningen kontrolleras vid samma tillfälle så den behöver ej vara
godkänd innan redovisningen.

Glöm ej att ta med legitimation. Tänk också på att tiderna är
ungefärliga så ni kan få vänta något.

9. P-uppgift: granskning

KTH.SE:u1ndpe5c — Wed, 27 Jun 2007 14:52:29 GMT

Sammanfattning: /* Inlämningsuppgift: granskning */

==Granskning==

Innan det färdiga programmet kan redovisas för en handledare ska det testas (granskas) av en kurskamrat. Vid testen ska din granskare kritiskt granska ditt program, testköra det och fylla i ett granskningsprotokoll. Denna granskning är ett obligatoriskt moment. (Varje kursdeltagare måste granska en uppgift, och alla uppgifter som ska redovisas måste granskas först.) Syftet med granskningen är att du genom att kritiskt granska en annans program ska få en ökad förståelse för hur man ska (och inte ska) programmera.

Här är granskningsprotokollet som ni ska fylla i. Förklaringar till de olika punkterna finns lite längre ned på den här sidan.

<pre>
Namn:
Födelsedag:
Uppgift:

Användarvänlighet

_ Informativa utskrifter / lättbegripligt grafiskt gränssnitt
_ Enkel inmatning

Programmerarvänlighet

_ Vettiga namn
_ Kommentarer
_ Konsekvent språk
_ Konsekvent typografi
_ Felhantering

Strukturering

_ Lämplig uppdelning i funktioner
_ Lämplig uppdelning i klasser (ej obligatoriskt)
_ Temporära variabler så lokalt som möjligt
_ Återanvändbara funktioner/klasser
_ In- och utdata till funktioner
_ Flexibelt/utbyggbart program
_ Ingen kodupprepning
_ Ingen hårdkodning

Följande punkter är nödvändiga (måste alltid åtgärdas)

_ Uppfyller kraven i lydelsen
_ Detaljförståelse

Granskare:
</pre>

===Användarvänlighet===

====Informativa utskrifter====
Programmet ska tala om för användaren vad programmet gör i varje steg och vad för inmatning som förväntas. Ett dåligt exempel kan se ut så här.

<pre>Ge tal1 : 26
och tal2 : 54
29 31 37 41 43 47 53</pre>

Man ska inte behöva titta i en manual eller ännu värre, i själva programkoden för att förstå vad som händer. Programmet måste vara självinstruerande.

<pre>Hej och välkommen till primtalsprogrammet. Programmet
skriver ut alla primtal i ett intervall du definierar.

Ange undre gränsen i intervallet: 26
Ange högre gränsen i intervallet: 54
De primtal som finns mellan 26 och 54 är:
29 31 37 41 43 47 53</pre>

Den senare varianten är mycket lättare att förstå när man kör programmet.

====Enkel inmatning====

Inmatningen ska inte vara onödigt krånglig.

<pre>...
Vill du boka en biljett?ja
Varifrån åker du? Arlanda
Vart ska du åka? Kastrup
Vilken månad ska du åka? Mars
Vilken dag ska du åka? 25
Vill du boka returbiljett?ja
Vilken månad ska du tillbaka? April
Vilken dag ska du tillbaka? 5
Det går tyvärr inget flyg den 25 mars.
Försök igen

Vill du boka en biljett?ja
Varifrån åker du? Arlanda
Vart ska du åka? Kastrup
Vilken månad ska du åka? Mars
...</pre>

Förutom att vara väldigt sen med att kläcka ur sig att det inte finns något flyg den önskade resdagen så verkar det inte finnas något sätt att boka en mängd biljetter. Att boka en klassresa med det systemet skulle vara väldigt enerverande.

===Programmerarvänlighet===

====Vettiga namn====

Programmet ska ha intuitiva namn på variablerna. För den som skrivit programmet är allt självklart, men inte för andra.

Nedanstående programkod är ganska svår att tyda

<pre>namn = 0
kalle = 0
while kalle < len(pelle):
if pelle[kalle] > namn:
namn = pelle[kalle]
kalle = kalle + 1</pre>

Här följer samma kod med andra variabelnamn.

<pre>max = 0
i = 0
while i < len(lista):
if lista[i] > max:
max = lista[i]
i = i + 1</pre>

Man ser nu lättare vad koden gör, nämligen sparar undan det högsta värdet i listan till variablen max. Fortfarande är inte namnet på listan optimalt. Vad för slags värden innehåller den? Är det löner, skottstatistik eller vad?

När det gäller en funktion eller metod brukar ett bra namn oftast vara ett verb som beskriver vad den gör eller vad den returnerar. Booleska funktioner (som returnerar True/False) bör ha ett namn som talar om hur läget är det fall den returnerar True.

Namnet på en klass kan vara ett substantiv som beskriver vad objektet representerar. Variabler och är också substantiv.

Att komma på bra namn kräver en del arbete!

====Kommentarer====

Alla klasser och funktioner måste kommenteras. Syftet med klassen/funktionen ska framgå. Det ska räcka att läsa kommentaren för att förstå hur en funktion ska användas (man ska inte behöva sätta sig in i hela koden).

För att kunna förstå och sätta sig in i hur en klass fungerar är det särskilt viktigt att man förklarar och kommenterar alla attribut (klassvariabler) som används i klassen.

In- och utdata till funktioner måste kommenteras. Det gäller både returvärden och
parametrar. Om funktionen är en metod och den ändrar något attribut ska detta också kommenteras.

Kommentarerna ska inte förklara hur Python fungerar. Förutsättningen är att den som läser källkoden redan vet hur man programmerar. Kommentarer som förklarar t ex att en if-sats gör ett val och att en slinga upprepar något ska inte vara med vid redovisningen. Den som redovisar måste själv veta sådant utan anteckningar.

====Konsekvent språk====

Språkvalet ska vara konsekvent. Alla variabel-, klass- och funktionsnamn på ett språk. Alla kommentarer på ett språk. Det är OK att ha engelska variabel/metodnamn och kommentera på svenska. Undvik svengelska (sejva svenska språket).

====Konsekvent typografi====

Programmet ska ha en genomgående typografi. Namn som är sammansatta av flera ord kan t ex skrivas ihop genom att inleda varje nytt ord med stor bokstav, eller genom att skilja orden åt med understrykning. Variabel- och metodnamn brukar inledas med med liten bokstav och klasser med stor bokstav.

<pre>class EnBraKlass
def enMetodSomTarTreParametrar(x, y, z)</pre>

====Felhantering====

Extrauppgiften för betyg C innehåller oftast felhantering, dvs att programmet kan hantera fel som kan uppstå. T ex kan det vara en slinga som upprepar inmatning tills korrekta värden kommer in. Ofta är den bästa lösningen att man skriver en funktion som tar hand om inläsningen.

<pre>Ange täljare: 1000
Ange nämnare: 0
Oj oj, nämnaren får inte vara noll. Försök igen.
Ange nämnare: 10

1000 delat med 10 blir 100</pre>

Man kan också behöva lägga till särfall (exceptions) för att ta hand om fel som annars skulle ge felavbrott.

===Strukturering===

====Lämplig uppdelning i klasser====

Data som hör ihop (t ex namn, födelsedata och adressuppgifter för en person) kan samlas genom att dom får vara attribut i en klass. Funktioner som hör ihop kan bli metoder i en klass. Olika klasser för olika uppgifter.

====Lämplig uppdelning i funktioner/metoder====

Bäst är det med specialiserade funktioner som bara gör en sak.

<pre>def lasFranFilen():
filnamn = raw_input("Vad heter filen?")
infil = open(filnamn,"r")
lista = infil.readLines()
lista2 = []
for element in lista:
if type(element) == type(0):
lista2.add(element)
return lista2</pre>

Koden ovan gör flera saker; frågar efter en fil, läser in alla data från filen, stoppar in heltalen i en heltalsvektor och returnerar denna. Det vore bättre att dela upp dessa uppgifter på flera funktioner så att funktionsanropen blir:

<pre>namn = fragaFil()
fildata = laesFranFil(filnamn)
intresseantaTal = konvertera(fildata)</pre>

Programmet blir då mer flexibelt: Funktionen fragaFil kan skrivas om till ett grafiskt GUI där man klickar på rätt fil. Funktionen laesFranFil kan användas i andra sammanhang då man vill läsa från fil. Man kan skicka fildatat till en ny metod som kontrollerar data innan man anropar konvertera.

====Temporära variabler så lokalt som möjligt====

Se till att tillfälliga variabler skapas så lokalt som möjligt. En variabel som bara används inuti en slinga i en metod ska inte vara ett attribut i klassen, utan en lokal variabel i metoden.

====Återanvändbara funktioner/klasser====

En del uppgifter kan delas upp i klasser som går att återanvända i andra program. T ex kan en klass som representerar ett spelkort användas i olika kortspelsprogram.

Funktioner ska om möjligt vara skrivna så att dom går att använda i andra sammanhang. Ett knep är att se till att alla indata ges som parametrar. Ett annat är att specialisera funktionerna, så att varje funktion bara gör en liten del.

====In- och utdata till funktioner====

Var noga med in och utdata till funktionerna. En del funktioner som t.ex. bara skriver ut på skärmen kan vara parameterlösa och inte returnera något. Övriga funktioner bör ha alla indata som parametrar och utdata som returvärden.

====Flexibelt/utbyggbart program====

Skriv ditt program så att det lätt att utöka och bygga ut. Några exempel: I ett program som samlar data om pokemon ska man kunna lägga till fler pokemon utan att gå in och ändra i programmet. Om ett program läser in från fil ska det vara lätt att byta till en annan fil. Om man vill lägga till en beräkning så ska det vara enkelt att stoppa in en funktion för det, utan att behöva ändra på många ställen i programmet.

====Ingen kodupprepning====

Ett vanligt nybörjarfel när man programmerar är att använda taktiken klippa och klistra när samma sak ska göras på flera ställen i programmet. Detta leder dock till kod som är väldigt svår att underhålla. Om man ändrar på ett ställe måste man göra samma ändring på flera parallellställen. Det går i regel att skriva om koden till en funktion med parametrar och returvärde.

====Ingen hårdkodning====

Förekommer talet 5 på flera ställen i programmet? Om man behöver använda siffervärden kan dessa deklareras som konstanter.

<pre>ANTALSPELARE = 5;
PI =3.14;</pre>

===Följande punkter är nödvändiga (måste alltid åtgärdas för godkänt)===

====Uppfyller kraven i lydelsen====

Programmet måste uppfylla kraven i P-uppgiftslydelsen. Det är inte tillåtet att förenkla uppgiften. Den som vill göra några förändringar måste förankra det med kursledaren först, och kunna visa en bekräftelse (ett ebrev t.ex.) på att kursledaren godkänt kravförändringar.

====Detaljförståelse====

Den som redovisar ska kunna redogöra för alla detaljer i koden, t ex vad variablerna innehåller, vad funktionerna gör och vad som skulle hända om handledaren tog bort en rad ur programmet.

==Inlämningsuppgift: granskning==

Hitta en studiekamrat som har kommit lika långt som du i kursen så att ni kan granska varandras program.
Använd gärna forumet som heter "Hitta granskare". Observera att det är obligatoriskt både att granska någon annans program och att få sitt eget program granskat.

Var inte för snäll när du går igenom programmet. Granskningen kan underkännas om du inte ens försökt kritisera programmet som du granskat. Och den som blir granskad är tacksam för alla fel du upptäcker, eftersom dom kan åtgärdas för redovisningen.

Skapa en fil med namnet granskningsprotokoll.txt, klistra in mallen ovan,
fyll i protokollet (skriv in namn och sätt ett kryss på alla moment som är
godkända) och lämna in det på vanligt sätt under rubriken "P-uppgift Granskning".
Filen måste vara i textformat.

Granskningen kommer att rättas i samband med den muntliga redovisningen slutinlämningen.

8. P-uppgift: prototyp

KTH.SE:u1ndpe5c — Wed, 27 Jun 2007 14:51:57 GMT

Sammanfattning:

==Prototyp==

När ditt kodskelett har blivit godkänt så är det dags att börja arbeta med en prototyp av programmet. Prototypen behöver inte implementera all funktionalitet. I biblioteksexemplet har vi valt att starta med inläsning och utskrift till fil. Vi har också lagt till de två första funktionerna i menyn: att söka på titel och att söka på författare.

När man jobbar med att skriva kod så upptäcker man ofta att den ursprungliga kodskelettet måste modifieras. Studera koden i exemplet nedan noggrannt och lägg märke till ändringarna.

* Klassen Bibliotek har bytt namn till Catalog, ett namn som beskriver klassen bättre. Ett objekt av den här klassen representerar ju inte ett helt bibliotek utan bara en bibliotekskatalog.

* Många av metoderna i Catalog-klassen har ändrats. När vi började skriva koden så märkte vi att många av de ursprungliga metoderna i klassen Bibliotek gjorde två helt skilda saker: de gjorde både operationer på biblioteksdatabasen samtidigt som de skötte det textbaserade användargränssnittet. En bättre lösning är att metoderna i klassen Catalog endast hanterar databasoperationerna. Användargränsnittet har vi implementerat separat med hjälp av ett antal funktioner.

* Vi har nu bestämt hur data ska lagras på fil och varit noga med att dokumentera detta i programmet. Denna viktiga information saknades helt i kodskelettet.

* Lägg märke till att det finns en extra utskrift (som inte ska vara med i det färdiga programmet) i huvudprogrammet. Just efter att vi har läst in data från filen och skapat en ny Catalog så skriver vi ut innehållet i listan <code>books</code>. Den här typen av testutskrifter är mycket användbara för att kolla att programmet fungerar som man har tänkt sig och för att leta efter eventuella fel.

* När vi skrev koden så upptäckte vi ibland att vi upprepade samma kod på flera ställen. Det brukar vara en tydlig indikation på att det är lämpligt att introducera en ny funktion. Ett exempel är hjälpfunktionen <code>are_equal</code> som kollar om två strängar är lika så när som på små och stora bokstäver samt överflödiga blanktecken i början och slutet av strängarna. Den här funktionen la vi till eftersom samma kod dök upp i de båda funktionerna <code>search_title</code> och <code>search_author</code>.

* Når vi skrev programmet så upptäckte vi att det fanns ett stort antal utskrifter som alla började med blanktecken: <code>print ' text...'</code>. För att slippa skriva om samma sak, en form av onödig hårdkodning, och för att lättare kunna ändra programmet i framtiden så införde vi istället konstanten <code>INDENT = ' '</code>.

* Eftersom vi har planer på att göra extrauppgiften för betyg A, att lägga till ett grafiskt användargränssnitt, så har vi försökt att skilja ut den kod som hanterar kommunikationen till användaren från den kod som hanterar logiken för databasen. På det sättet blir det mycket enklare när vi ska byta ut textgränssnittet mot ett grafiskt gränssnitt. Målet är inte bara att få programmet att fungera, utan också att utforma det på ett sådant sätt att det är lätt att förstå och modifiera i framtiden.

<pre># -*- coding: iso8859-1 -*-

# Titel: Bibliotek (prototyp)
# Författare: Stefan Nilsson
# Datum: 2007-06-29
#
# Det här är ett program för hantering av enklare biblioteksrutiner.
#
# Programmet lagrar böckerna i en fil med namnet "bibliotek.txt"
# mellan körningarna. Varje rad innehåller en bok beskriven på
# följande format:
#
# <AUTHOR>/<TITLE>
#
# eller
#
# <AUTHOR>/<TITLE>/Utlånad
#
# om boken är utlånad. Exempel på datafil:
#
# Bälter/Programmeringsteknik med Python/Utlånad
# Bälter/Pythonvetaren

# -------- En klass som beskriver en bok. --------
# Attribut:
# author - namnet på författaren
# title - bokens titel
# isBorrowed - en variabel som är True om boken är utlånad.
#
class Book:
# Skapar en ny bok.
def __init__(self, author, title):
self.author = author
self.title = title
self.isBorrowed = False

# Returnerar en sträng som beskriver boken.
# Format: <author>: <title> (utlånad)
def __str__(self):
author_and_title = self.author + ': ' + self.title
if self.isBorrowed:
return author_and_title + ' (utlånad)'
else:
return author_and_title

# -------- En klass som beskriver en bibliotekskatalog. --------
# Attribut:
# books - en lista som innehåller samtliga böcker.
#
class Catalog:
# Skapar en bibliotekskatalog med de böcker som finns i filen.
def __init__(self, filename):
self.books = list()
file = open(filename, 'rU')
for line in file:
parts = line.strip().split('/')
if (len(parts) >= 2):
book = Book(parts[0], parts[1])
if len(parts) == 3:
book.isBorrowed = True
self.books.append(book)
file.close()

# Sparar hela bibliotekskatalogen i en fil.
def save(self, filename):
file = open(filename, 'wU')
for book in self.books:
file.write(book.author + '/' + book.title)
if book.isBorrowed:
file.write('/Utlånad')
file.write('\n')
file.close()

# Returnerar boken om den finns, annars None.
# Skiljer inte på små och stora bokstäver.
def find_title(self, title):
for book in self.books:
if are_equal(title, book.title):
return book
return None

# Returnerar en lista på böcker av en viss författare.
# Return en tom lista om det inte finns några böcker.
# Skiljer inte på stora och små bokstäver.
def find_author(self, author):
book_list = list()
for book in self.books:
if are_equal(author, book.author):
book_list.append(book)
return book_list

# -------- Hjälpfunktioner --------

# Returnerar True om s1 och s2 är lika.
# Skiljer inte på små och stora bokstäver och tar bort
# eventuella blanktecken i början och slutet av strängen.
def are_equal(s1, s2):
return s1.strip().upper() == s2.strip().upper()

# -------- Funktioner för textgränssnitt --------

INDENT = ' ' # Tomma tecken i början av indragna rader

# Skriver ut valmenyn.
def print_menu():
print INDENT, 'T söka på Titel.'
print INDENT, 'F söka på Författare.'
print INDENT, 'L Låna bok.'
print INDENT, 'Å Återlämna bok.'
print INDENT, 'N lägga in Ny bok.'
print INDENT, 'B ta Bort bok.'
print INDENT, 'A lista Alla böcker.'
print INDENT, 'S Sluta.'

# Läser in och returnerar första bokstaven i användarens val.
# Omvandlar liten bokstav till stor.
def choose():
choice = raw_input('Vad vill du göra? ')
return choice[0].upper()

# Söker på titel.
def search_title(catalog):
title = raw_input('Vilken titel vill du söka efter? ')
book = catalog.find_title(title)
if (book == None):
print INDENT, 'Hittade ingen bok med den titeln.'
else:
print INDENT, book

# Söker på författare.
def search_author(catalog):
author = raw_input('Vilken författare vill du söka efter? ')
book_list = catalog.find_author(author)
if len(book_list) == 0:
print INDENT, 'Hittade inga böcker av den författaren.'
else:
print INDENT, 'Hittade', len(book_list), 'böcker'
for book in book_list:
print INDENT, book

# Lånar en bok.
def borrow_book(catalog):
return

# Återlämnar en bok.
def return_book(catalog):
return

# Lägger till en ny bok.
def add_book(catalog):
return

# Tar bort en bok.
def delete_book(catalog):
return

# -------- Huvudprogram --------

print 'Välkommen till biblioteksprogrammet!'

FILENAME = 'bibliotek.txt'
catalog = Catalog(FILENAME)

# Testutskrift
print 'Antal böcker:', len(catalog.books)
for book in catalog.books:
print book

print_menu()

choice = choose();
while choice != 'S':
if choice == 'T':
search_title(catalog)
if choice == 'F':
search_author(catalog)
choice = choose()

catalog.save(FILENAME)

print INDENT, 'Välkommen åter!'</pre>

==Inlämningsuppgift: prototyp==

Skriv en prototyp till din P-uppgift och lämna in den på vanligt sätt under rubriken "P-uppgift Prototyp".

7. P-uppgift: kodskelett

KTH.SE:u1ndpe5c — Wed, 27 Jun 2007 14:51:29 GMT

Sammanfattning:

==P-uppgift==

Kursens sista moment är en större, personlig programmeringsuppgift i Python; en P-uppgift. Uppgifterna är tänkta att vara något så när svåra och tidskrävande, räkna med 40-80 timmar. Betyget i kursen ges av detta moment.

P-uppgiften redovisas i fyra steg, kodskelett, prototyp, granskning och slutredovisning (se nedan). Slutredovisningen görs på KTH och du kan boka en tid när du är klar med de tre första momenten.

Uppgiftslydelsen till din P-uppgift hämtar du från studentportalen. (Du måste dock vara klar med testet i avsnitt 1 innan du kan hämta din P-uppgift.)

P-uppgifterna är uppdelade i en grunduppgift och tre extrauppgifter som du kan göra för att få högre betyg. Extrauppgifterna för betyg B och C går att lösa med hjälp av de delar av Python som vi gått igenom hittills i kursen.

I extrauppgiften för betyg A ska du göra ett grafiskt användargränssnitt till ditt program och det ingår i uppgiften att lära sig detta på egen hand, till exempel genom att läsa på nätet om Pythons inbyggda GUI-verktyg som heter Tkinter. En samling bra länkar finns under rubriken
[[huvudsida#GUI-länkar|GUI-länkar]] på kursens [[huvudsida]].

==P-uppgiftens delmoment==

===Kodskelett===

Innan programmet skrivs ska en specifikation i form av ett kodskelett lämnas in. Syftet är att du ska tänka igenom problemet innan du försöker lösa det. Kodskelettet ska innehålla följande delar:

* En inledande kommentar som kortfattat beskriver vad programmet gör och hur det är implementerat.
* Funktioner (utan kod) med kommentarer.
* Klasser med attribut och metoder (om du använder klasser), men utan kod.

===Prototyp===

En prototyp är en första körbar version av programmet som innehåller den mest grundläggande funktionaliteten. I det här skedet behöver programmet ännu inte har fullt utbyggd felhantering, eventuella extrauppgifter behöver inte vara implementerade och vissa delar av programmet kan innehålla funktioner som ännu inte utför sin uppgift. Syftet med att lämna in en protyp är att vi ska kunna ge tips och råd om förbättringar och ändringar redan innan programmet är helt klart.

===Granskning===

Innan det färdiga programmet kan redovisas för en handledare på KTH ska det testas (granskas) av en kurskamrat. Vid testen ska din granskare kritiskt granska ditt program, testköra det och fylla i ett granskningsprotokoll. Denna granskning är ett obligatoriskt moment. (Varje kursdeltagare måste granska en uppgift, och alla uppgifter som ska redovisas för handledare måste granskas först.) Syftet med granskningen är att du genom att kritiskt granska en annans program ska få en ökad förståelse för hur man ska (och inte ska) programmera.

===Slutredovisning===

När du är klar med de tre första momenten så är det dags att välja en tid för slutredovisning på KTH. Uppgiftslydelsen, en utskrift av programmet samt granskningsprotokollet ska medföras till slutredovisningen. Observera att vi (för att förhindra fusk) jämför din lösning mot en databas som innehåller alla tidigare inlämningar som gjorts på kursen.

Betyget på kursen bestäms i samband med slutredovisningen. Det finns sex betygssteg, A-F, där A är det högsta betyget. A-E är alla godkända betyg och F är underkänt. Man får betyg

* F om man har fler än 3 påpekanden eller inte uppfyller samtliga nödvändiga punkter i granskningsprotokollet.
* E om man har 1-3 påpekanden och uppfyller samtliga nödvändiga punkter i granskningsprotokollet.
* D om man har ett perfekt program (ett program utan påpekanden).
* C om man har uppfyllt villkoren för betyg D och dessutom har gjort extrauppgift C.
* B om man har uppfyllt villkoren för betyg C och dessutom har gjort extrauppgift B.
* A om man har uppfyllt villkoren för betyg B och dessutom har gjort extrauppgift A.

==Krav på P-uppgiftslösningen==

Utöver kraven på funktionalitet som finns i uppgiftslydelsen gäller detta alltid:

* Programmet ska vara kommenterat upptill med författare, datum och ev revisionsdatum. Överkommentera inte programmet i övrigt. Tänk på att det är kvalitet och inte kvantitet på kommentarer som räknas.
* Programmet ska vara användarvänligt och presentera sig vid programstart. Tydliga instruktioner ska ges på skärmen. Det ska vara lätt att förstå vad programmet skriver ut. Det är tillåtet att anta att indatafiler är felfria om inte annat anges i uppgiftslydelsen.
* Programmet ska vara vettigt uppdelat i funktioner, och eventuellt klasser. Funktioner ska inte vara alltför långa (max en skärmsida). Det ska vara lätt att i efterhand gå in och förstå och ändra i programmet. Robust, flexibelt och lättläst är nyckelord.
* Varje variabel och funktion ska vara försedd med kommentarer. Ange vad variabeln representerar och vad funktionen gör. För funktioner bör man också ange vad indata (parametrar) och utdata (retur-värde) betyder. Det ska räcka att läsa kommentar och funktionshuvud för att förstå hur en funktion ska användas.
* Namn på variabler och funktioner ska vara vettiga. Alla deklarerade namn ska vara på samma språk, liksom alla kommentarer (engelska namn och svenska kommentarer är OK). Koden skall vara snyggt formaterad.
* Nästan identiska kodstycken ska inte upprepas. Gör i stället generella funktioner. Inför inte i onödan begränsningar. Inför konstanter för sådant som man kan tänkas vilja ändra framöver (om man skulle vilja arbeta vidare med din lösning) och för tal som inte ska ändras och går att beskriva med namn.

==Fiktiv P-uppgift==

I de sista avsnitten av kursen kommer vi att gå igenom ett exempel som visar hur en P-uppgiften kan se ut och hur de olika inlämningsmomenten är tänkta att fungera. Den fiktiva uppgiften går ut på att göra ett program för hantering av enklare biblioteksrutiner. Uppgiftslydelsen ser ut så här:

===Bibliotek===

LÄS ANVISNINGARNA PÅ KURSENS WEBBPLATS INNAN DU BÖRJAR MED UPPGIFTEN!

'''Varudeklaration:''' Datastrukturer, sökning, sortering, filhantering, grafik.

Skriv ett program för hantering av enklare biblioteksrutiner. Programmet ska kunna söka efter
böcker både med avseende på författare och titel. Man ska även kunna låna och lämna tillbaka
böcker, lägga in nya böcker i registret och ta bort gamla böcker, samt skriva ut en lista på
skärmen över alla böcker. Böckerna ska sorteras med avseende på författare.

Böckerna ska lagras på en textfil som du får skriva in själv. Din fil behöver inte innehålla
fler än tio böcker men ditt program ska gå att använda även för ett stort antal böcker.

'''Exempel:'''
<pre>Välkommen till biblioteksprogrammet!
T söka på Titel.
F söka på Författare.
L Låna bok.
Å Återlämna bok.
N lägga in Ny bok.
B ta Bort bok.
A lista Alla böcker.
S Sluta.

Vad vill du göra? F
Vilken författare vill du söka efter? Bälter
Hittade 2 böcker
Bälter: Programmeringsteknik med Python (utlånad)
Bälter: Pythonvetaren

Vad vill du göra? L
Ange titeln på den bok du vill låna: Pythonvetaren

Vad vill du göra? s
Välkommen åter!</pre>

'''Tips:''' Skriv programmet i etapper. Börja med att läsa in böckerna från fil och skriva ut dem igen. Utöka sedan programmet stegvis.

'''Extrauppgift, betyg C:''' Inför felkontroll för användarens inmatning och filers existens.

'''Extrauppgift, betyg B:''' Låt programmet hålla reda på vem som lånat boken och vilket datum den ska återlämnas. Användaren ska kunna be om en lista på alla personer som lånat böcker, och vilka de lånat. Böcker som borde varit tillbakalämnade ska markeras.'Man ska också kunna få en lista på enbart personer som har böcker hemma vars datum gått ut tillsammans med dessa böcker och hur mycket personen är skyldig i böter. Kolla upp bötesregler på biblioteket!

'''Extrauppgift, betyg A:''' Gör ett grafiskt användargränssnitt till programmet.

==Kodskelett till bibliotek==

I kodskelettet hoppar vi över extrauppgifterna. Eftersom uppgiften handlar om att lagra böcker i en databas så kan det vara lämpligt att ha en klass som heter Book som innehåller all information om en bok. Databasen kan vi representera som en lista av Book-objekt. De olika valaternativen i menyn implementerar vi med hjälp av funktioner. Eftersom kodskelettet kommer att utgöra basen för vårt program så ser vi till att programmet går att kompilera redan nu trots att det ännu inte innehåller fungerande kod. Det är därför samtliga metoder innehåller kommandot <code>return</code> i stället för riktig kod.

Observera att det ska finnas kommentarer till samtliga klasser, metoder och funktioner. Kommentaren i början av en klass ska beskriva vad klassen represerar samt en förklaring av klassens samtliga attribut (klassvariabler).

Exempel på ett kodskelett för den fiktiva P-uppgiften:

<pre># -*- coding: iso8859-1 -*-

# Titel: Bibliotek
# Författare: Stefan Nilsson
# Datum: 2007-06-28
#
# Det här är ett program för hantering av enklare biblioteksrutiner.
# Programmet lagrar böckerna i en fil med namnet "bibliotek.txt"
# mellan körningarna.

# En klass som beskriver en bok:
# author - namnet på författaren
# title - bokens titel
# isBorrowed - en variabel som är True om boken är utlånad.
class Book:
# Skapar en ny bok.
def __init__(self, author, title):
self.author = author
self.title = title
self.isBorrowed = False

# Returnerar en sträng som beskriver boken
def string(self):
return

# En klass som beskriver en bibliotekskatalog:
# books - en lista som innehåller samtliga böcker.
class Bibliotek:
# Skapar en bibliotekskatalog med de böcker som finns i filen.
def __init__(self, filename):
self.books = list()

# Sparar hela bibliotekskatalogen i en fil.
def save(self, filename):
return

# Skriver ut valmenyn.
def meny(self):
return

# Läser in och returnerar användarens val.
def choose(self):
return

# Söker på en titel.
def findTitle(self, title):
return

# Söker på en författare.
def findAuthor(self, author):
return

# Lånar en bok.
def borrowBook(self, book):
return

# Återlämnar en bok.
def returnBook(self, book):
return

# Lägger till en ny bok:
def addBook(self, book):
return

# Tar bort en bok:
def deleteBook(self, book):
return

# Returnerar en lista över alla böcker:
def listBooks(self):
return

# Huvudprogram

FILENAME = 'bibliotek.txt'
bibliotek = Bibliotek(FILENAME)

# choice = '';
# while choice != 'S':
# bibliotek.meny()
# choice = bibliotek.choose()
# # Utför detta val.

bibliotek.save(FILENAME)</pre>

Det här kodskelettet är inte avsett att vara varken perfekt eller komplett. Det är inte bara koden som saknas; vi kommer också att behöva modifiera både funktioner och kommentarer efterhand som projektet fortskrider.

==Inlämningsuppgift: kodskelett

Skriv ett kodskelett till din P-uppgift och lämna in den på vanligt sätt under
rubriken "P-uppgift Kodskelett".

6. Klasser

KTH.SE:u1ndpe5c — Wed, 27 Jun 2007 14:49:29 GMT

Sammanfattning: /* Exempel: Husdjursprogrammet */

==Objektorientering==

Objektorienterad 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.

[[Bild:Rymdskepp.jpg|Två rymdskepp|center]]

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?'''
# Poäng
# Spader
# Kort
'''Svar:'''Klassen Kort, så att vi kan skapa många kort-objekt som kan användas i patiensen. 

[[Bild:Husdjursobjekt.jpg|frame|right]]
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.

==Attribut==

De variabler som används för att lagra data som hör till objektet
kallas ''attribut''. Våra husdjursobjekt ska alltså ha attributen
<code>namn</code> och <code>skick</code>. 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:
<pre>
self.namn = "Fido"
</pre>

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?'''
[[Bild:Spis.jpg|frame|right]]
# bredd
# energiklass
# ugnsvolym
'''Svar:'''Alla alternativen skulle passa bra som attribut! 

==Metoder==

Funktionerna 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.

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

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:
[[Bild:GauginPuppies.jpg|left|frame]]
* 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?'''
# lägga ner en vara i kundvagnen
# beräkna totalpriset för alla varor i kundvagnen
# räkna ut dagens vinst för internetbutiken
'''Svar:'''Alla utom sista alternativet - det hör
inte till själva kundvagnen.

==Speciella metoder: konstruktorn och str==

Metoder 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 <code>__init__</code> (alltså init
med två understrykningstecken både före och efter).

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

<pre>
def __init__(self, djurnamn):
self.namn = djurnamn
self.skick = 0
</pre>

[[Bild:Tegel.jpg|frame|right]]

Den här konstruktorn har två parametrar, self (som ju alltid måste vara med)
och djurnamn. Raden <code>self.namn = djurnamn</code> skapar attributet ''namn'' och
initierar det till värdet av parametern djurnamn. På samma sätt skapar
raden <code>self.skick = 0</code> 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 <code>__str__</code>, och det
speciella med den är att den anropas varje gång man försöker skriva ut ett
objekt med <code>print</code>. Här kan man alltså tala om hur man vill
att objektets data ska skrivas ut. Exempel:

<pre>
def __str__(self):
return self.namn + "*" + str(self.skick)
</pre>

Metoden <code>__str__</code> ä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?'''
# parametern self
# en parameter för varje attribut
# ett returvärde
'''Svar:'''Parametern self är det enda som måste vara med. Attributen kan få värden via parametrar (som namn ovan), men det är inte nödvändigt. Konstruktorn ska inte ha något returvärde.

==Klassen==

Fö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:

<pre>
# En klass som beskriver ett virtuellt husdjur.
# Attribut:
# namn - djurets nanm
# skick - ett heltal som beskriver djurets skick
class 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

</pre>

Med en klass är det likadant som med en funktion - det händer
inget förrän man använder den i huvudprogrammet. För att skapa
ett Husdjurs-objekt kan vi skriva:

<pre>
djur = Husdjur("Muffin")
</pre>

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

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

<pre>
djur.banna()
</pre>

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()?'''

'''Svar:'''Nej, man kan bara banna ett husdjursobjekt, inte hela klassen. 

==Exempel: Husdjursprogrammet==

Här följer hela programmet, först Husdjurs-klassen, och sedan huvudprogrammet.
Lägg märke till att alla metoderna i klassen är indenterade.
<pre>
# En klass som beskriver ett virtuellt husdjur.
# Attribut:
# namn - djurets nanm
# skick - ett heltal som beskriver djurets skick
class Husdjur:

# 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 "trött: (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
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()
</pre>

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

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

'''Svar:'''Bara ett - variabeln djur. 

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

'''Svar:'''Attributet skick har något av värdena 1,2,3,4 eller 5

* '''Fråga: Hur avslutar man programmet?'''

'''Svar:'''När man trycker på Retur avslutas programmet. Lägg gärna till en print-sats som upplyser användaren om det! 

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

'''Svar:'''Det finns sex metoder, inklusive konstruktorn.

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

'''Svar:'''Javisst, prova att skriva tre (istället för 3) när du matar husdjuret med bullar. Här skulle det behövas lite felhantering!

==Sortering av en lista med objekt==

Oftast 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:

<pre>
lista.sort(key = lambda x:x.attr)
</pre>

Parametern <code>key</code> i sort visar att man vill ange vilket attribut
man vill sortera på. Uttrycket <code>lambda x:x.attribut</code> ä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:

<pre>
import random

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

# 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 listan
def skrivListan(listan):
for o in listan:
print o,
print "\n"

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

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

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

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

==Test==

Dags för test nummer 6. Testet hittar du som vanligt under rubriken Examination
på kursens förstasida. Även detta test rättas automatiskt och du har möjlighet
att göra om testet flera gånger om du inte lyckas på första försöket.

==Inlämningsuppgift 3 (Nöjesfält)==

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

[[Bild:Rollercoaster.jpg|frame|right]]
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 <code>Uppgift3.py</code>. Följ den här mallen:

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

<Programkod></pre>

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.

Ordlista

KTH.SE:u1xsetv1 — Tue, 26 Jun 2007 11:40:25 GMT

Sammanfattning:

==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.

'''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.

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

'''<''' ä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.

'''<='''ä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.

'''>''' ä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.

'''>='''ä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.

'''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.

' (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 åäö.

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

==A==
'''adress''' är ett unikt tal som representerar en minnesposition i datorns internminne.

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

'''array''' se [[#l|l]]ista.

'''assignment''', se [[#t|t]]illdelning

'''avlusa''', hitta och rätta fel i program.

==B==
'''bibliotek''', se [[#k|k]]atalog

'''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.

'''byte''', bitgrupp om vanligen 8 bitar.

==D==
'''debugga''', se [[#a|a]]vlusa.

'''directory''', se [[#k|k]]atalog.

'''division''', se [[#operatorer|/]]

==E==
'''editor''', se [[#r|redigeringsprogram]].

'''elif''', se [[#i|if]]

'''eller''', villkorsoperator se [[#operatorer|<nowiki>||</nowiki>]]

'''else''', se [[#i|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 [[#u|uttryck]]

==F==
'''False''', booleskt värde som representerar ett falskt påstående (icke uppfyllt villkor). Se även
[[#T|T]]rue.

'''falskt''', se [[#f|False]].

'''felsökning''', se [[#a|avlusning]], [[#e|exekveringsavbrott]] och [[#k|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 [[#p|programflöde]].

'''flyttal''', se [[#r|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.

'''function invocation''' se [[#f|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).

==G==
'''gemen''' 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.

==H==
'''hexadecimalt''' tal har basen sexton. Siffrorna tio till femton representeras med bokstäverna
1010 = A16, 1110 = B16, osv. Basen 16 skrivs ibland H, t ex kan 1710 skrivas 11H .

'''HTML''', 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.

==I==
'''if...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.

'''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.

'''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 [[#i|i]]nitiera

'''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 [[#u|u]]tmatning.

'''inmatning''', se [[#i|i]]nlä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 [[#operatorer|not]]

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

==K==
'''katalog''', (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.

==L==
'''Lista''' ä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
för att komma åt det. Vanligen använder man for-slingor för att gå igenom alla
element i en lista.

'''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 [[#s|s]]linga, [[#w|w]]hile eller [[#f|f]]or.

'''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.

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

'''matematiska uttryck''', se [[#operatorer|+-*/]]

'''method invocation''' se [[#f|f]]unktionsanrop

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

'''metodanrop,''' se [[#f|f]]unktionsanrop.

'''metoddeklaration,''' se [[#m|m]]etod.

'''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 [[#operatorer|%]]

==N==
'''negation,''' se [[#operatorer|not]]

'''None''' är en litteral som anger att en variabel saknar värde. Se även [[#i|i]]ngenting.

'''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.

==O==
'''och,''' se [[#operatorer|and]]

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

'''or,''' se [[#e|e]]ller.

==P==
'''parameter''' ä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 [[#u|u]]tskrift.

'''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.

==R==
'''random''', 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 [[#i|i]]nläsning

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

==S==
'''sammansatt villkor''' är villkor som kombineras med and eller or. Se [[#l|logiskt uttryck]].

'''sant,''' se [[#t|T]]rue.

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

'''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 [[#s|s]]linga

'''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 [[#s|s]]ats

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

==T==
'''tilldelning''' (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 [[#f|F]]alse.

==U==
'''Unicode''' ä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 [[#s|s]]linga.

'''utmatning,''' se [[#u|u]]tskrift.

'''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.

==V==
'''variabel''' ä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 [[#l|l]]ista.

'''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.

==W==
'''while'''-slinga, ett sätt att åstadkomma upprepning.

==ÅÄÖ==
Åäö 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:
<nowiki>#-*-coding: iso-8859-1-*-</nowiki>

5. Filer

KTH.SE:u1ndpe5c — Tue, 26 Jun 2007 09:53:39 GMT

Sammanfattning:

==Filer==

Information 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.

==Filhantering==

På 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. Följande bilder visar hur olika ikoner ser ut i ett Mac/OS X operativsystem:

[[Bild:800176.jpg]] [[Bild:800177.jpg]] [[Bild:800178.jpg]]

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 Python==

Antag att det redan finns en fil som heter <code>kompisar.txt</code> med följande innehåll:

<pre>Anna Bok
Caesar Davidson
Erling Franson</pre>

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 <code>friends</code>.

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

Funktionen <code>open</code> öppnar filen men namnet <code>kompisar.txt</code> för läsning (<code>r</code> betyder "read", <code>U</code> 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 <code>\n</code>). Med hjälp av en <code>for</code>-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 <code>close</code>. 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 <code>close()</code> så sker det automatiskt när programmet avslutas.

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

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

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

==Test==

Dags för test nummer 5. Testet hittar du som vanligt under rubriken Examination
på kursens förstasida. Även detta test rättas automatiskt och du har möjlighet
att göra om testet flera gånger om du inte lyckas på första försöket.

0. Kursinformation

KTH.SE:u1ndpe5c — Tue, 26 Jun 2007 09:24:35 GMT

Sammanfattning: /* Examination */

==Välkommen till kursen==

I den här distanskursen på 6hp får du lära dig grunderna i
programmering i programspråket Python. Kursen läses helt i
egen takt på distans via nätet. Enda undantaget är den
avslutande muntliga redovisningen som sker vid KTH,
Vallhallavägen, Stockholm. Laborationerna redovisas dels via
nätet och dels vid den avslutande muntliga redovisningen.

==Målgrupp==

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.

Kursen är i stort sett identisk med en kurs som går på KTH
för S, Open, CL, Media och I. Läser du kursen nu så kommer du alltså att få det lite lugnare när den går för ditt program
(eller så kan du hoppa på någon annan rolig kurs då).

Om du går på något av programmen T, BD, M, P, K eller Bio
kommer du att få tillgodoräkna dig 3hp av kursen i numeriska
metoder och programmering. Dessutom har du klarat av
ytterligare 3hp i din strävan mot examen.

Om du går E, F eller D så är kursen en mycket god
förberedelse för programmeringskursen i årskurs 1, men den
kan inte ersätta den kursen eller räknas in i examen.

==Kursmål==

Kursens övergripande mål är att självständigt och i grupp
kunna lösa problem genom att konstruera program på upp till
femhundra rader i ett modernt programspråk.

Efter godkänd kurs ska du kunna

* följa reglerna i programspråkets syntax,
* tillämpa och redogöra för regler för god programmeringsstil (såsom användarvänlighet, kommentarer, felhantering, strukturering, flexibilitet),
* upptäcka och korrigera programmeringsfel,
* modifiera givna program,
* överföra data mellan fil och program,
* identifiera behovet av och använda styrstrukturer (villkorssatser och slingor),
* dela upp ett större problem i hanterliga delar och konstruera funktioner för dessa,
* använda de datastrukturer som finns inbyggda i programspråket, samt välja datastrukturer som passar för det aktuella problemet,
* utveckla enkla grafiska användargränssnitt,
* granska andras program

för att ha möjlighet att

* använda programmering för att lösa problem,
* tillämpa problemlösningsmetodiken även inom andra områden än programmering,
* diskutera programutveckling med experter,
* bedöma kommersiella program.

==Anmälan och registrering==

Antagning och registrering sker efter att du börjat jobba med
kursmaterialet och slutfört det första momentet.

Grundläggande behörighet (avslutad gymnasieutbildning eller
motsvarande inklusive svenska, matematik och engelska) krävs
för att bli antagen. Även om du inte uppfyller behörighetskraven
just nu, har du möjlighet att arbeta med kursen.
Poängen på kursen kommer då att registreras när du,
eventuellt senare, uppfyller behörighetskraven.
Du kan direkt sätta igång och arbeta i kursen så
fort du erhållit användarnamn för inloggning.

Det är ditt eget ansvar att styrka din behörighet. Det gör du genom att kontrollera att dina meriter finns registrerade på www.studera.nu eller skicka in vidimerade kopior på handlingar som styrker din behörighet enligt anvisningarna på kursens informationssida http://www.kth.se/rcn/kursutbud/datavetenskap/1.13634

Programstudenter på KTH anmäler sig till kursen genom att få kursen vald av sin studievägledare.

För att bli formellt registrerad på kursen i Ladok (högskolans
databas) måste du vara behörig samt bekräfta din studieplats.
Detta gör du genom att logga in till kursen och påbörja dina
studier.
Du måste också räknas som aktiv på kursen. Detta innebär att
du måste slutföra det första avsnittet för att få en formell
registrering på kursen. Om du inte slutför det
avsnittet i kursen kommer ingen antagning eller registrering att
äga rum.

Du bestämmer själv när du vill starta och hur länge du håller
på. Det finns inga bundna tider och du kan anpassa dig helt
efter dina övriga planer. Det finns inte heller några formella
krav på att du slutför kurserna inom en given tid (såvida du
inte söker studiemedel och då måste uppfylla CSN:s krav på
prestationer innan du söker studiemedel nästa gång).

===Omregistrering===

Om du har påbörjat kursen en tidigare termin så har du kvar
din studieplats och är välkommen att fortsätta arbeta med
kursen under läsåret tills du är färdig. Om du önskar
utnyttja denna möjlighet är det bara att fortsätta att jobba
i kursen genom att logga in med ditt användarnamn.

===Avregistrering===

Följande gäller för avregistrering på högskolekurser: Har
studenten inte alls, eller knappt, börjat kan vi avregistrera.
Sker avanmälan inom tre veckor från kursstart registreras
"tidigt avbrott" vilket gör det möjligt att söka om till
samma kurs (i de fall där det är viktigt). Vid senare datum
registreras "avbrott" som medför att man begär omregistrering
om man vill återuppta sina studier på kursen.

==Examination==

Under kursens gång finns det sex stycken automaträttade test.
Det finns också tre stycken inlämningsuppgifter som skickas
in och rättas av en assistent. Observera att lösningar till samtliga uppgifter
ska göras individuell.

Kursen avslutas med ett större programmeringsprojekt,
en så kallad P-uppgift, som redovisas i fyra steg: tre
inlämningar och en avslutande redovisning som man gör
personligen på KTH i Stockholm.

För att bli godkänd på kursen måste man vara klar
med de sex testen och alla inlämningsuppgifter samt
besöka KTH för en muntlig redovisning av P-uppgiften.
Samtliga moment utom den avslutande muntliga redovisningen
görs på distans.

Kursmomenten rapporteras på följande sätt till Ladok:

* LAB1 (1,5hp) blir man godkänd på när man gjort inlämningsuppg 1-3.
* LAB2 (1,5hp) blir man godkänd på när man gjort test 1-6.
* LAB3 (3hp) blir man godkänd på när man gjort samtliga uppgifter i bilda samt den muntliga redovisningen på KTH.

Betyget på kursen bestäms helt av den avslutande P-uppgiften.
Det finns sex betygssteg, A-F, där A är det högsta betyget.
A-E är alla godkända betyg och F är underkänt.
De exakt reglerna för betygsättningen hittar du i
avsnitt 7-10 som handlar om P-uppgiften.

Macintosh OS X: Öppna terminalfönster

KTH.SE:u1xsetv1 — Mon, 25 Jun 2007 14:12:46 GMT

Sammanfattning: Ny sida: ==Öppna terminal på Macintosh== På OS X-datorer fås ett terminalfönster med programmet "X11" (eller Terminal om du inte har X11). I Finder (klicka på den glada blå gubben i D...

==Öppna terminal på Macintosh==

På OS X-datorer fås ett terminalfönster med programmet "X11" (eller Terminal om du inte har X11). I Finder (klicka på den glada blå gubben i Dock) trycker du ner kommando-A (dvs tryck i turordning utan att släppa någon tangent: äppel/sevärdhetstangenten bredvid mellanslagstangenten–skift-A). I mappen som öppnas finns det en mapp som heter "Verktygsprogram" ("Utilities" om du har en engelsk version) och i den finns programmet X11 (och/eller Terminal). Dubbelklicka som vanligt för att starta det.

Köra Pyton i Windows

KTH.SE:u1xsetv1 — Mon, 25 Jun 2007 14:08:51 GMT

Sammanfattning: Ny sida: ==Köra Python på en Windowsdator== När du startar python får du en kommandotolk. Där du kan skriva in pythoninstruktioner och de utförs direkt. Så här ser det ut om man vill...

==Köra Python på en Windowsdator==

När du startar python får du en kommandotolk. Där du kan skriva in pythoninstruktioner och de utförs direkt. Så här ser det ut om man vill skriva ut "Hej".

[[Bild:python_tolk.jpg]]

Om man vill skriva större program och spara programmet måste man starta en texteditor där man skriver in programinstruktionerna. Man kan använda notepad eller den inbyggda editorn som man startar så här:

[[Bild:python_start_edit.jpg]]

Skriv programmet i det nya fönstret.

[[Bild:python_edit.jpg]]

Spara programmet i en fil.

[[Bild:python_save.jpg]]

Döp programmet med filändelsen .py i exemplet nedan sparas programmet som mitt_program.py.

[[Bild:python_file_name.jpg]]

Kör ditt program genom att välja run module i Run-menyn.
[[Bild:python_run_module.jpg]]

Programmet körs i fönstret med pythontolken.

[[Bild:python_run_result.jpg]]

Python hjälp

KTH.SE:u1xsetv1 — Mon, 25 Jun 2007 14:04:54 GMT

Sammanfattning: Ny sida: ==Att få hjälp med Python== Du kan läsa mer om Python med den inyggda hjälpen. I Windows startar du hjälpen antingen via start-knappen eller inifrån Python: [[Bild:st...

==Att få hjälp med Python==

Du kan läsa mer om Python med den inyggda hjälpen. I Windows startar du hjälpen antingen via start-knappen eller inifrån Python:

[[Bild:start_python_help.jpg]]

Välj tutorial från startsidan och sedan det avsnitt du vill läsa mer om.

[[Bild:python_help_start.jpg]]

Starta Python i Windows

KTH.SE:u1xsetv1 — Mon, 25 Jun 2007 14:00:03 GMT

Sammanfattning: /* Att starta Pyton */

==Att starta Python==

När du installerat Python kan du starta Python via startknappen. Beroende på operativsystem, språk och inställningar kan det se lite olika ut. På Windows 2000 ser det ut så här:
[[Bild:starta_python.jpg]]

Windows: Installation och start av Python

KTH.SE:u1xsetv1 — Mon, 25 Jun 2007 13:41:53 GMT

Sammanfattning: /* Installation */

==Installera Python-tolk på Windowsdator==
Här följer instruktioner för hur du installerar Python på en Windowsdator.

Efter installationen kan du klicka på någon av följande länkar för att få mer information om hur du använder Python.

[[Starta Python i Windows]]

[[Köra Pyton i Windows]]

[[Python hjälp]]

==Installation==

Gå till [http://www.python.org Pythons hemsida]. Välj download i menyn till vänster. Tryck på länken Windows installer.

[[Bild:Ladda_ner.jpg]]

Kör installationsprogrammet genom att trycka på run

[[Bild:Run_inst.jpg]]

Vänta medan programmet laddas ner.

[[Bild:Venta.jpg]]

När installationsprogrammet startar kan det hända att du får en varning att inte köra programmet. Kör programmet ändå.
[[Bild:varning.jpg]]

Installationsprogrammet ställer en rad frågor. Den första frågan gäller var du ska installera python. Om du vill ändra på den föreslagna sökvägen gör du det här annars trycker du next för att komma vidare.

[[Bild:var_installera.jpg]]

Om du inte vill installera allting kan du välja bort paket annars trycker du next för att komma vidare.

[[Bild:vad_installera.jpg]]

Vänta medan programmet installeras.

[[Bild:venta_igen.jpg]]

Tryck på finish för att avsluta installationen

[[Bild:klar.jpg]]

Länk till instruktioner för Python-tolk

KTH.SE:u1xsetv1 — Mon, 25 Jun 2007 13:11:36 GMT

Sammanfattning: /* Python tolk */

==Python tolk==

För att kunna provköra exemplen och egen kod behöver du en Python-tolk. Du som har en Linux eller Macintosh OS X-dator har redan en sådan på datorn. Om du använder en Windows-dator måste du först installera den. Du klarar dig även utan tolk än så länge, men det blir roligare när man kan prova själv. Det finns också en hel utvecklingsmiljö till Python som heter IDLE och är gratis. Mer information om Python kan du hitta på [http://www.python.org/ Pythons hemsida]. IDLE går att hämta [http://www.python.org/download/ här] och fungerar på såväl Windows, Mac OS X som Linux.

För att komma åt tolken behöver du dessutom öppna ett terminalfönster. Ett terminalfönster används för att skriva kommandon direkt till datorn utan att använda det grafiska gränssnittet. 

Nedan finns länkar till öppnings- och installationsanvisningar för olika operativsystem.

[[Windows: Installation och start av Python]]

[[Macintosh OS X: Öppna terminalfönster]]

==Starta Python, alla datortyper==

Oavsett vilken datortyp du har, när du väl har öppnat ett terminalfönster kan du starta Python på två olika sätt. Dels kan du låta tolken köra ett redan skrivet program genom att skriva "python filnamn" i terminalfönstret (där filnamnet är namnet på det program du vill köra). Dels kan du starta tolken i interaktiv mod genom att skriva enbart "python" och trycka retur i terminalfönstret (observera att Unix-datorer (som Linux och OS X) skiljer på versaler och gemena (stora och små bokstäver) i terminalfönstret). Detta går att göra även i Windows från ett terminalfönster (se 4.3 hur man öppnar ett sådant) men om du ändå har installerat IDLE enligt ovan är det enklare att använda det.

Startar du på det första sättet gäller det att hålla reda på var filen finns (mer om det i avsnitt 4 Filhantering), men det går enkelt att ändra i programmet med något redigeringsprogram. Startar du på det andra sättet kommer varje sats du skriver att tolkas omedelbart av tolken, vilket kan vara både bra och dåligt. En nackdel är dock att ändringar i ett program kan bara korrigeras genom att du skriver om programmet rad för rad.

4. Filhantering

KTH.SE:u1xsetv1 — Mon, 25 Jun 2007 11:00:51 GMT

Sammanfattning: /* Inlämningsuppgift 2 (Rondelet) */

==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.

[[Bild:Snigeltavling.jpg]]

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:

<pre>
---------------------------------------------------
| VEM HAR DEN SNABBASTE SNIGELN? |
| |
| Här får din snigel tävla mot en vältränad |
| racersnigel. Skriv in namnet på din snigel |
| så sätter tävlingen igång! |
---------------------------------------------------
Vad heter din snigel? Ebba
Klara...färdiga...gå!

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

Det här loppet tog en oväntad vändning, Ebba vann!
</pre>

==Dela upp ett problem i funktioner==

För att programmet ska bli enklare att skriva bestämmer vi
först vilka funktioner vi ska ha. Det är inte alls självklart
hur programmet ska delas upp i funktioner; samma problem
kan lösas på många olika sätt! Vi vill se till att varje
funktion har ett enda uppdrag.

Här är ett förslag på uppdelning:

# Skriv ut informationsrutan och läs in namnet på snigeln
# Simulera tävlingen och rita upp banorna
# Skriv ut vem som vann

Ettan och tvåan består av flera olika moment. Vi gör det
ännu enklare för oss genom att dela upp i ännu mindre delar:

# Skriv ut informationsrutan
# Läs in namnet på en snigel
# Simulera tävlingen
# Rita upp en snigels bana
# Skriv ut vem som vann

Vi börjar med att skriva in dessa moment som kommentarer i
filen snigel.py, för att vi ska hålla reda på vad som
är kvar att göra. Då får vi också en kommentar för varje
funktion, så att det syns vad som händer var.

[[Bild:Books.jpg|thumb]]
'''Fråga: Tänk om vi ville skriva ett program för stavningskontroll, i vilka funktioner skulle vi då dela upp det?'''

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

==Definiera en funktion==

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

<pre>
def visaInformation():
</pre>

[[Bild:Huvud.jpg|thumb|left]]
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:

<pre>
# Skriver ut informationsrutan
def visaInformation():
print """
---------------------------------------------------
| VEM HAR DEN SNABBASTE SNIGELN? |
| |
| Här får din snigel tävla mot en vältränad |
| racersnigel. Skriv in namnet på din snigel |
| så sätter tävlingen igång! |
---------------------------------------------------"""
</pre>

(För att kunna skriva en sträng som sträcker sig över flera rader
så startar och avslutar vi strängen med tre stycken "-tecken.
Vanliga trängar, som börjar och slutar med enkelt
citattecken, kan nämligen inte innehålla radbrytningar.)

Lägg till koden ovan i din fil snigel.py och provkör.

Men vad nu - programmet skriver inte ut något alls?
Gå vidare till nästa avsnitt för att få reda på varför!

==Anropa en funktion==

Satserna i funktionskroppen utförs inte om inte funktionen
anropas. Anropet ska stå längst ner i programmet, under
funktionsdefinitionerna. Den delen av programmet kallar vi
huvudprogrammet.

Anropet består bara av funktionens namn följt av ett parentespar.
Om du lägger till anropet sist i ditt program ska alltihop se ut så här:

<pre>
# Skriver ut informationsrutan
def visaInformation():
print """
---------------------------------------------------
| VEM HAR DEN SNABBASTE SNIGELN? |
| |
| Här får din snigel tävla mot en vältränad |
| racersnigel. Skriv in namnet på din snigel |
| så sätter tävlingen igång! |
---------------------------------------------------"""

# Läs in namnet på en snigel
# Simulera tävlingen
# Rita upp en snigels bana
# Skriv ut vem som vann

visaInformation()
</pre>

Spara i filen snigel.py och provkör!

==Skicka utdata från en funktion (returvärden)==

[[Bild:Brev.jpg|right|Ett brev]]
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:

<pre>
def lasNamn():
namn = raw_input("Vad heter din snigel? ")
return namn
</pre>

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.

<pre>
dinSnigelsNamn = lasNamn()
</pre>

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.

<pre>
# Skriver ut informationsrutan
def visaInformation():
print """
---------------------------------------------------
| VEM HAR DEN SNABBASTE SNIGELN? |
| |
| Här får din snigel tävla mot en vältränad |
| racersnigel. Skriv in namnet på din snigel |
| så sätter tävlingen igång! |
---------------------------------------------------"""

# Läs in namnet på en snigel
def lasNamn():
namn = raw_input("Vad heter din snigel? ")
return namn

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

visaInformation()
dinSnigelsNamn = lasNamn()
</pre>

Men hur ska vi veta om det fungerade eller inte?
Jo, vi lägger in en kontrollutskrift
<pre>
print "Din snigel heter alltså", dinSnigelsNamn
</pre>
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

<pre>
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
</pre>

I return-satsen allra sist kan vi se att två värden
returneras, åtskilda med kommatecken. Givetvis måste vi då också
ta emot två värden i huvudprogrammet.

Den distans (i centimeter) som sniglarna ska tillryggalägga
representeras av konstanten DISTANS. En variabel som ska
ha ett konstant värde under hela programmet brukar man
skriva med stora bokstäver, VERSALER. Python bryr sig inte om det, men
andra människor som läser programmet kan se vad man menar.
Vi definierar DISTANS överst i huvudprogrammet, och frågar
oss om den kommer att synas inuti funktionen?

Lägg in den nya funktionen i snigel.py, enligt nedan. Glöm inte
att lägga in kontrollutskrifter av snigelbana1 och snigelbana2
innan du provkör!

<pre>
import random

# Skriver ut informationsrutan
def visaInformation():
print """
---------------------------------------------------
| VEM HAR DEN SNABBASTE SNIGELN? |
| |
| Här får din snigel tävla mot en vältränad |
| racersnigel. Skriv in namnet på din snigel |
| så sätter tävlingen igång! |
---------------------------------------------------"""

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

# Simulerar en tävling mellan två sniglar
def tavling():
snigelbana1 = 0
snigelbana2 = 0
print "Klara...färdiga...gå! \n"
while snigelbana1 < DISTANS and snigelbana2 < DISTANS:
snigelbana1 += random.randrange(5)
snigelbana2 += random.randrange(5)
return snigelbana1, snigelbana2

DISTANS = 30
visaInformation()
dinSnigelsNamn = lasNamn()
snigelbana1, snigelbana2 = tavling()
</pre>

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:
<code>
Ebba: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @
</code>
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 <code>ritaBanan</code>.
Här följer tre olika exempel på hur en sån funktion skulle kunna anropas:
<pre>
ritaBanan("Ebba", 31)
ritaBanan("Racersnigeln", 28)
ritaBanan(dinSnigelsNamn, snigelBana1)
</pre>

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 <code>snigelnamn</code>
respektive <code>langd</code>. Så här ser funktionen ut.
<pre>
def ritaBanan(snigelnamn,langd):
print snigelnamn.rjust(12) + ":",
for i in range(1,langd):
print "-", # slemspåret
print "@" # snigeln
</pre>

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:
<pre>
ritaBanan(dinSnigelsNamn,snigelbana1)
ritaBanan("Racersnigeln",snigelbana2)
</pre>

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:

<pre>
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."
</pre>

Den sista parametern har fått ett skönsvärde, alltså ett värde som
används om vi inte skickar in något på den platsen. Då kan man om man
vill utelämna den parametern i anropet, på det här viset:
<pre>
utseVinnare(snigelbana1, snigelbana2, dinSnigelsNamn)
</pre>

Nu sätter vi ihop alltihop och provkör:
<pre>
import random

# Skriver ut informationsrutan
def visaInformation():
print """
---------------------------------------------------
| VEM HAR DEN SNABBASTE SNIGELN? |
| |
| Här får din snigel tävla mot en vältränad |
| racersnigel. Skriv in namnet på din snigel |
| så sätter tävlingen igång! |
---------------------------------------------------"""

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

# Simulerar en tävling mellan två sniglar
def tavling():
snigelbana1 = 0
snigelbana2 = 0
print "Klara...färdiga...gå! \n"
while snigelbana1 < DISTANS and snigelbana2 < DISTANS:
snigelbana1 += random.randrange(5)
snigelbana2 += random.randrange(5)
return snigelbana1, snigelbana2

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

# Skriver ut vinnaren
def utseVinnare(langd1, langd2, namn1, namn2="Racersnigeln"):
print langd1, langd2
print "\n"
if langd1 >= DISTANS and langd2 >= DISTANS:
print "Det blev oavgjort."
else:
if langd1 >= DISTANS:
print "Det här loppet tog en oväntad vändning," , namn1, "vann!"
else:
print namn2, "vann, som vanligt."

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

==Rekursion==
[[Bild:Droste.jpg|Bild på kakaopaket|thumb]]

Nu börjar vi om med ett helt nytt problem. Vi vill skriva ett
program som räknar ut summan av dom första n heltalen, t ex
1+2+3+4=10. Det här är ett så enkelt problem, så det räcker
med en enda funktion. Hur ska vi beräkna summan då? Vi
förenklar problemet lite: Säg att vi ska räkna ut summan av de
fem första heltalen. Då kan vi först räkna ut summan av de fyra
första heltalen och sen lägga till fem. Men summan av de
fyra första heltalen är ju lätt att räkna ut - det är ju
summan av de tre första heltalen plus fyra. Och så vidare...

Vi skriver summaberäkningen som en funktion, och låter den
räkna enligt mönstret summa(n) = summa(n-1) + n.
Funktionen har n som parameter, och programmet ser ut så här:

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

Provkörde du? Isåfall kan det vara bra att komma ihåg att man kan avbryta
ett program med Ctrl-C. Det som händer här är att funktionen summa
anropar sig själv i all oändlighet. Vad beror det på?

Jo, vi har glömt att tala om när beräkningen ska avbrytas. Anropar
vi med n=3, så kommer funktionen att försöka räkna ut
summa(2), summa(1), summa(0), summa(-1) och så vidare.

Vi vill ju att det minsta talet i summan ska vara 1, och det måste
vi ange i funktionen. Nytt försök:

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

Det här fungerade väl bra? Att lösa ett problem genom att låta en
funktion anropa sig själv kallas rekursion. Det man behöver är:
* ''Rekursiv tanke:'' som reducerar problemet till ett enklare problem med samma struktur
* ''Basfall:'' det måste finnas ett fall som inte leder till rekursivt anrop

==Test==

Dags för test nummer 4. Testet hittar du som vanligt under rubriken Examination
på kursens förstasida. Även detta test rättas automatiskt och du har möjlighet
att göra om testet flera gånger om du inte lyckas på första försöket.

==Inlämningsuppgift 2 (Rondelet) ==

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

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

# Textens fyra första ord
# Resten av första meningen
# Textens fyra första ord igen
# Andra meningen
# Tredje meningen
# Fjärde meningen
# 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:

<pre>
DIKTAUTOMATEN

Skriv in fyra meningar och få ut en rondelet!

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

DET FANNS INGEN FIL

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

===Tips===

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

<pre># 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."</pre>

Det finns en användbar metod i Python som heter <code>split()</code> 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 <code>split()</code>:

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

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

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

===Inlämning===

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

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

<Programkod></pre>

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

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

3. Listor och Anrop

KTH.SE:u1xsetv1 — Mon, 25 Jun 2007 09:41:46 GMT

Sammanfattning:

==Listor==

Oftast ä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 <code>raw_input</code> fungerar ungefär som <code>input</code>. Skillnaden är att <code>raw_input</code> 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.)

<pre>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</pre>

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.

===Hur använder man en lista?===

Listor skrivs med hjälp av klamrar []

<pre>namnlista = 3*[None]</pre>
[[Bild:800156.jpg]]

<code>namnlista</code> 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:

<pre>namnlista[0] = 47</pre>
[[Bild:800157.jpg]]

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:

<pre>namnlista[1] = "hej"</pre>
[[Bild:800158.jpg]]

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

<pre>print namnlista</pre>

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

<pre>print namnlista[2]</pre>

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

'''Hur många platser har följande lista?'''
<pre>bilar = 16*[None]</pre>
'''Svar:''' 16

===Åter till exemplet===

Nu 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:

<pre> 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</pre>

I rad nr 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 att namnlista[i] alltså 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 den 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 9(=10-1).

I rad nummer 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 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 att namnlista[j] 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 att namnlista[j] 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?'''
# ages[14]
# ages14
# ages15
# ages, 14
# ages[15]
# ages, 15
'''Svar:''' 1. ages[14]

'''Antag att vi har listan <code>ages</code> med ålder på 50 personer. Vilket av följande kodexempel summerar alla element i listan <code>ages</code>?'''
1. <pre>i = 0
sum = 0
while i < 50:
sum += ages + i
i += 1</pre>
2. <pre>i = 0
sum = 0
while i < 50:
sum += ages[i]
i += 1</pre>
3. <pre>summera(ages)</pre>
4. <pre>i = 0
sum = 0
while i < 50
sum += i
i += 1</pre>
'''Svar:''' kodexempel 2

===Mer om listor===

Det 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 <code>append()</code>:

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

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

<pre>a = [1, 2, 3] + [4, 5] # Resultatet blir [1, 2, 3, 4, 5]</pre>

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

<pre>veckodagar = ["mån", "tis", "ons", "tor", "fre", "lör", "sön"]
vardagar = veckodagar[0:5] # plockar ut elementen fr o m index 0 t o m index 4 i listan
helgdagar = veckodagar[5:7] # plockar ut elementen fr o m index 5 t o m index 6 i listan</pre>

Om du vill lära dig ännu mer om listor så finns det en länk på kursens [[huvudsida]] under rubriken [[Huvudsida#Pythonlänkar|Pythonlänkar]].

==Uppslagslistor==

Ibland 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.

<pre>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 28
month["feb"] = 29 # Ändrar "feb":s värde till 29
print month["feb"] # Skriver ut 29

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

# 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</pre>

==Slingor==

[[Bild:Loop.jpg|right|frame]]

Det ä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

<pre>tanter = ["Brun", "Grön", "Gredelin"]
for tant in tanter:
print "Tant", tant</pre>
blir
<pre>Tant Brun
Tant Grön
Tant Gredelin</pre>

For-satsen har alltså följande format
<pre>for <index> in <lista>:
<sats></pre>
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:

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

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 <code>range()</code>. Här är ett exempel:
<pre>#Skriver ut: 1 2 3 4 5 6 7 8 9
for i in range(1, 10):
print i,</pre>

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:

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

==Moduler==

Stora 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 <code>from, import</code> 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 <code>math</code> finns en funktion som heter <code>sqrt(x)</code> 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:

<pre>from math import *</pre>

Först nu efter importeringen kan vi anropa funktionen <code>sqrt</code> enligt nedan:

<pre>sqrt(23)</pre>

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?'''
# Dela upp ett program i fristående delar.
# Slå ihop två program till ett.
# Slå ihop flera program till två.
# Slå ihop tre program till ett.
'''Svar:''' 1

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

==Random==

[[Bild:dice.jpg|left|frame]]

Ett 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. Mera information om modulen Random hittar du bland [[Huvudsida#Pythonlänkar|pythonlänkarna]] på kursens [[huvudsida]].

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:

<pre>from random import *</pre>

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

<pre>from random import *
s_tal = random()</pre>

<code>s_tal</code> 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 <code>randrange()</code> som också finns i modulen random.

<pre>h_tal=randrange(1,3)</pre>

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

'''När skriver följande program texten "Det kommer att bli en solig sommar"?'''
<pre>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"</pre>
# Alltid.
# Endast när slumptalet som genererats av <code>weather = random()</code> är större än 0.2.
# Endast om det inte regnar när man kör programmet.
# Aldrig.
# Endast när slumptalet som genererats av <code>weather = random()</code> är mindre än 0.2.
'''Svar:''' 5

==Test==

Dags för test nummer 3. Testet hittar du som vanligt under rubriken
Examination på kursens förstasida. Även detta test rättas automatiskt
och du har möjlighet att göra om testet flera gånger om du inte
lyckas på första försöket.

2. Styrstrukturer

KTH.SE:u1xsetv1 — Wed, 20 Jun 2007 16:02:10 GMT

Sammanfattning: /* Inlämningsuppgift 1 (Prat i kvadrat) */

''Mamma 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äsning==

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

<pre>temperatur = input()</pre>

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:

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

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:

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

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>?
<pre>a = input()</pre>
'''Svar:''' 22

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

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

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

==Villkor==

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

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

Detta program kommer att se ut så här på skärmen:

<pre>Ge utetemperatur: 1
Ta på dej en halsduk, lille vän!</pre>

eller

<pre>Ge utetemperatur: 17</pre>

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 är:

<pre>if < BOOLESKT UTTRYCK> :
< EN ELLER FLERA SATSER SOM SKA EXEKVERAS></pre>

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 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?'''
<pre>if a < b:
print "X",
print "Y"</pre>
'''Svar:''' "Y"

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

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

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

==Konstanter==

Programmerare 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:

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

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-sats==

Om 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:

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

Detta program kommer att se ut så här på skärmen:

<pre>Ge utetemperatur: 2
Ta på dej en halsduk, lille vän!</pre>

eller

<pre>Ge utetemperatur: 17
Mammas gullgubbe slipper halsduk!</pre>

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?'''
<pre>if a <= b:
print "A",
print "B",
else:
print "C",
print "D"</pre>
'''Svar:''' "C D"

'''Vad kommer att skrivas ut av följande program om a = 36?'''
<pre>MITTEN = 42
if a <= MITTEN:
print "A",
print "B",
else:
print "C",
print "D"</pre>
'''Svar:''' "A B D"

==Flera villkor==

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

<pre># Ett program som visar hur if-elif-else fungerar
MAMMAS_FRYSPUNKT = 5
CELSIUS_FRYSPUNKT = 0
temperatur = 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!"</pre>

Detta program kommer att se ut så här på skärmen

<pre>Ge utetemperatur: 3
Ta på dej en halsduk!</pre>

eller

<pre>Ge utetemperatur: 17
Mammas gullgubbe slipper halsduk!</pre>

eller

<pre>Ge utetemperatur: -2
Ta på dej halsduk och mössa!</pre>

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?'''
<pre>min = 5
max = 10
b = 0

if a < min:
min = a
elif a > max:
max = a
else:
b += 1</pre>
'''Svar:''' min = -2 , max = 10 samt b = 0

==Likhet==

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

<pre>betyg = 2123
if 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"</pre>

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

==While-slingor==

[[Bild:Tape_measure.jpg|right]]

Nä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.

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

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:

* Skriva ut texten "Python"
* Skapa en räknare och nollställa den
* Kontrollera räknarens värde
* Uppdatera räknarens värde

Nu ska vi gå igenom programmet i detalj.

I rad nummer 1 har vi koden "<code>antal_varv = 0</code>". Där har vi valt variabeln antal_varv som ska fungera som räknare och får startvärdet 0.

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

Rad nummer 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"

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

Rad nummer 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?'''
<pre>i = 0
v = 1
while i < 5:
v = i * v
print v
i += 1</pre>
'''Svar:''' 0 0 0 0 0

==Hur exekveras programmet?==

<pre>antal_varv=0
while antal_varv < 5 :
print "Python"
antal_varav += 1</pre>

I första raden av programmet får variabeln <code>antal_varv</code> värdet 0. Därefter exekveras uttrycket <code>antal_varv < 5</code> 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 <code>antal_varav += 1</code> och därmed ändrar <code>antal_varv</code> värde till 1. Nu är slingan slut och därför exekveras uttrycket <code>antal_varv < 5</code> igen och eftersom att 1 är mindre än 5 går vi ett varv till i while-slingan. Där exekveras <code>print "Python"</code> och <code>antal_varav += 1</code>. Ovanstående tre satser upprepas ytterligare tre gånger tills <code>antal_varv</code> får värdet 5. När då uttrycket <code>antal_varv < 5</code> 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?'''
<pre>A
while B:
C
D</pre>
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.

# ABCD
# ACCCD
# ABCCCD
# ABCBCBCD
# ABCBCBCBD
# ABCABCABCD

'''Svar:''' 5. ABCBCBCBD

==En oändlig while-slinga==

Om man tar bort rad nummer 4 från programmet får man följande:

<pre>antal_varv = 0
while antal_varv < 5 :
print "Python"</pre>

Vi ser att variabeln <code>antal_varv</code> inte kommer att ändras i while-satsen. Detta gör att villkoret (<code>antal_varv < 5</code>) 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?'''
<pre>v = 5
while v > 5:
print "hej"
v += 1
print "hej"</pre>
'''Svar:''' En gång

'''Kommer följande program skriva ut texten "hej då"? Om inte, varför?'''
<pre>i = 0
while i < 10:
print "hej"
print "hej då"</pre>
'''Svar:''' Nej, eftersom while-satsen är en oändlig slinga och print "hej då" är inte en del av while-satsen.

==Struktur på while-sats==

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

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

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.'''
<pre>i = 1
WHILE i < 10:
print "hej"</pre>

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

'''Svar:''' 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:

<pre>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!"</pre>

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

==Test==

Nu är det dags för kursens andra test.
Under rubriken Examination på kursens förstasida hittar
du samtliga test och inlämningsuppgifter.
Testet rättas automatiskt och du har möjlighet att göra om
testet flera gånger om du inte lyckas på första försöket.

==Inlämningsuppgift 1 (Prat i kvadrat)==
''Inlämningsuppgiften är individuell och får inte lösas i grupp.''

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:

<pre>Välkommen till prat i kvadrat.
Hur många kvadrattal vill du skriva ut? 4
1 * 1 = 1
2 * 2 = 4
3 * 3 = 9
4 * 4 = 16
Summan av kvadrattalen: 30</pre>

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

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

<Programkod></pre>

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

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

1. Programmeringsintro

KTH.SE:u1xsetv1 — Wed, 20 Jun 2007 12:54:45 GMT

Sammanfattning: /* Installera Python på din dator */

==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.

<table>
<tr><td>
[[Bild:797710.jpg]]
</td></tr>
<tr><td>
''Löstagen processor (i svart) med sex rader med kontakter runt om.''
</td></tr>
</table>

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

<table>
<tr><td>
[[Bild:797711.jpg]]
</td></tr>
<tr><td>
''Minneskort med minnen (RAM) i svart''
</td></tr>
</table>

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 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.
Det går också utmärkt att diskutera frågorna på kursens forum.
Här är en första uppmjukningsfråga.

'''Vad är en dator?'''

# Detsamma som en processor med minne.
# Detsamma som en processor, skärm, dator, tangentbord och mus.
# Detsamma som en data.

'''Svar:''' ->2. Detsamma som en processor, skärm, dator, tangentbord och mus.<-

Lösningen till uppgiften är skriven med osynligt bläck på föregående rad. Om du vill titta på svaret så håller du ned vänster musknapp och markerar den osynliga texten som finns mellan tecknen -> och <-.

==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.

[[Bild:791439.jpg]] 
[[Bild:791440.jpg]]

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.

[[Bild:791441.jpg]] 
[[Bild:791442.jpg]]

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

# Något som styr en dator.
# Detsamma som en processor, skärm, tangentbord och mus.
# Något som styr hu en dator manipulerar indata för att presentera utdata.
# En samling obegripliga ord i godtycklig ordning.
# En samling av variabler och satser.

'''Svar:''' 1, 3 och 5 är alla rätt.

==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.

==Installera Python på din dator==

Fö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 http://www.python.org

P-uppgiften redovisas normalt i Python 2.4 - 2.6 men om du vill använda Python
3.0 så kan detta vara möjligt. Kommunicera då detta i förväg med rättande lärare.

På webbplatsen [http://www.python.org 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 [http://www.python.org 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 IDLE==

Nä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.
[http://hkn.eecs.berkeley.edu/~dyoo/python/idle_intro/ One Day of IDLE Toying]
ä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:

<div class="codebox"><pre>print "Hej!"</pre></div>

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.

==Tilldelning==

Fö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:

<pre>age = 18
length = 180
weight = 80</pre>

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 tom tilldelningsoperator). Man kan också skriva variabler i högerledet:

<div class="codebox"><pre>my_cousins_age = age</pre></div>

Då tilldelas <code>my_cousins_age</code> samma värde som <code>age</code> 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:

<pre>a = 3
b = a + 15</pre>

Ovanstående två rader ser till att <code>b</code> 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 <code>d</code> efter följande rader?'''
<pre>a = 12
b = a
c = a + b + 3
d = c - b</pre>

'''Svar:''' <code>d</code> = 15 

'''Vad är det för fel på följande kod?'''
<pre>6606 = svenska_flaggans_dag</pre>
# 6606 är ett ogiltigt variabelnamn.
# Det blir fel för att 6606 inte är svenska flaggans dag.
# Man kan inte tilldela värdet 6606 ett nytt värde.

'''Svar:''' 1 och 3 är båda korrekta svar.

==Olika slags värden==

Det finns olika slags värden man tilldela variabler. Som vi tidigare sett kan man tilldela 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).

<pre>namn1 = 'Oskar'
namn2 = "Kajsa"</pre>

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

<pre>namn3 = 'Sima'
namn4 = namn3</pre>

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

'''Vad blir det för värden på a och b efter följande rader?'''
<pre>djur = 'katt'
a = djur
b = 'djur'</pre>
'''Svar:''' a får värdet 'katt' och b får värdet 'djur'.

==Uppräkning==

Man 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

<pre>my_age = 19
my_age += 1</pre>

får <code">my_age</code> värdet 20. Den första raden ger <code>my_age</code> värdet 19 och den andra raden räknar upp <code>my_age</code> 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:

<pre>my_age = 19
my_age = my_age + 1</pre>

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

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

<pre>husdjur = "hund "
husdjur += "och katt"</pre>

Kommer <code>husdjur</code> att vara "hund och katt"

'''Vad är värdet på a och s efter följande rader?'''
<pre>a = 100
b = 10
a += b
s = "svaret är "
s += "a"</pre>
# a = 10010, s = "svaret är 10010"
# a = 110, s = "svaret är a"
# a = 100, s = "svaret är 100"
# a = 110, s = "svaret är 110"
# 1 = 110, s = "svaret är 100"

'''Svar:''' Det korrekta svaret är 2: a = 110, s = "svaret är a".

==Utskrifter==

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

<pre>x = 15
print x
print 1001
print 14</pre>

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

<pre>print "Charles is", 19, "years old"</pre>

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:

<pre>age = 19
print "Charles is", age, "years old"</pre>

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:

<pre>print "Charles is",
age = 2006-1987
print age, "years old"</pre>

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:

<pre>print "Charles is",
age = 2006-1987
print age + "."</pre>

Utskriften blir då "Charles is 19.".

==Kommentarer==

<pre># Skriv ut Charles ålder
print "Charles is",
age = 2006-1987
print age, "years old"</pre>

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:

<pre>salary += 1 # Jippi, löneförhöjning!
</pre>

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?'''
<pre># Skriv ut Annas telefonnummer
namn = 'Anna'
telefon = '06509911122'
mobil = '07079911322'
print namn, "har telefon", telefon</pre>
'''Svar:''' Anna har telefon 06509911122

==Test==

Börja med att presentera dig genom att skriva ett
inlägg under rubriken Intro i kursens forum. Om du inte har lust
att berätta om dig själv så kan du alltid skriva ett kort inlägg:
<pre>Hej, jag heter Stefan och har skostorlek 41.</pre>
Du får gärna ljuga om skostorleken med det är bra om namnet stämmer!

Nu är det dags att göra kursens första test.
Under rubriken Examination på kursens förstasida hittar
du samtliga test och inlämningsuppgifter.
Testet rättas automatiskt och du har möjlighet att göra
om testet flera gånger om du inte lyckas på första försöket.

Om det är något som du undrar över i det här avnsnittet eller
i testet så är det fritt fram att fråga och diskutera i kursens forum.
Men undvik att avslöja de rätta svaren på testfrågorna!