Introduktion till programmering, del 4- Enkla program och funktioner

Åter onsdag! Vid det här laget är vi rena programmeringsproffsen, eller hur? 😉

Förra veckan tittade vi på Grundläggande begrepp och datatyper, i detta inlägg ska vi gå in på enkla program och funktioner.

Om man ska förenkla hela programmeringstänket så finns det egentligen bara tre moment: Inmatning, beräkning och utmatning. Man behöver såklart inte ha alla moment, ett program kanske bara gör en utskrift eller kanske rent av ingenting alls?

Ett exempel på inmatning är att användaren ombeds skriva in något på skärmen, exempelvis i kommandotolken:

Program som arbetar i Kommandotolken är enklast möjliga att programmera då man inte behöver lägga så mycket tid på att designa användarinterface (uppskattningsvis kan annars ca 70% av all kod i ett program vara relaterad till att rita gränssnittet och reagera på användarens input).

Därför är enklare program, som exempelvis “Hello World”, ofta textbaserade.

Beräkning är vad som sker bakom kulisserna. Det kan vara så att inmatad data används (t.ex. i ett program som kör en matematisk funktion), eller så kanske något helt annat beräknas som sköts automatiskt. Så länge man inte väljer att visa användaren feedback för hur beräkningen går görs den i bakgrunden, men kan däremot dröja en stund om det är en komplicerad sådan.

Utmatning hanterar visning av status, resultat eller vad man nu vill delge användaren. I exempelvis ett matematisk funktion kan man förvänta sig att utmatningen är resultatet av beräkningen. I grafiska program är utmatning i princip utbytt mot utritning, där koden istället ritar upp och uppdaterar innehållet i p.

Kommandotolken i Python

Att installera Python är enkelt. På Windows laddar man helt sonika ner lämplig installationsfil från Pythons hemsida (om du inte vet om du har x86-64, ta den vanliga, den fungerar på alla). Python är som regel förinstallerat på Raspberry Pi, men vill man installera det i Debian-baserad Linux-dist skriver man:

sudo apt-get install python

Det varierar lite vilken version som är inkluderad bland paketen, vill du installera en specifik version blir det lite bökigare så då hänvisar jag till Google 😉

När man startar öppnas en ny kommandotolk där man kan skriva kommandon som direkt interpreteras (körs). Alternativt kan man köra IDLE där man dels har en texteditor där man kan skriva, spara och öppna källkodsfiler och även köra dessa (görs med F5 eller via menyn). IDLE är till och med skrivet i Python och kan köras med kommandot “python […]\Python\Lib\idlelib\idle.py“. Det går såklart också bra att lusläsa koden för programmet, om man känner för att grotta ner sig. Här är en bild på båda editorn och interpretatorfönstret, där koden körs:

Om man skriver ett kommando i interpretatorn är det inte säkert att man får någon feedback. kommandot “print(“hej”)” skriver ut “hej” på skärmen, och print-kommandot är gjort just för syftet att skriva ut.  Matematiska beräkningar, som t.ex. “1+1” returnerar också en utskrift, svaret. Att tilldela ett värde till en variabel, däremot, lämnar ingen utskrift. Så skriver man “a = 1” får man direkt en ny rad. Skriver man sedan “a” så skrivs värdet på a, 1, ut.

Grundläggande Python

Hello World i Python är extremt trivial, som du kanske förstår av mina exempel ovan. Det är faktiskt bara en rad kod:

print("Hello World!")

Inte så pjåkigt jämfört med exemplen i tidigare avsnitt, eller hur?

Om vi nu vill implementera såväl beräkning som inmatning i programmet blir det lite mer invecklat, men knappt. För att hämta input från användaren kan man använda kommandot input(), men en nackdel med det är att det användaren fyller i körs som ett kommando vilket kanske inte alltid är önskvärt (gäller för Python 2.x, i 3.x fungerar input() som önskat). Använd då istället raw_input(), som tolkar indatan som en textsträng. Ger man en av dessa ett argument i form av en textsträng, kommer denna sträng stå före inmatningen. Så följande kod:

print ("Hej " + raw_input("Vad heter du? : ") + "!")

Ger detta resultat:

Ganska smidigt för bara en rad kod, eller hur? Nu är det lite svårläsligt, särskilt för en nybörjare. Dessutom måste man ta hänsyn till datatyper, detta hade inte fungerat om inte allt inom paranteserna var eller returnerade strängar. “+”-tecknen inuti parantesen används för att slå ihop värdena, så i fallet med strängar är alltså “Hej” + “!” samma sak som “Hej!”.

Men då kanske du undrar, varför skrivs inte “Hej “ ut innan användaren får göra sin inmatning? Jo, innan print-kommandot anropas måste hela innehållet i parantesen vara evaluerat, eller beräknat. Så den fastnar på raw_input()-kommandot och skriver då ut frågan först.

I princip kan man säga att vi här har alla tre delarna i ett program, men låt oss dela upp koden så att det blir lite tydligare:

namn = raw_input("Vad heter du? : ")
hej = "Hej " + namn + "!"
print (hej)

Här tar vi inmatningen först, och lagrar denna i en sträng “namn”. Därefter lägger vi ihop den strängen med “Hej ” och “!” och får då den färdiga strängen “Hej <namn>!” och till slut skriver vi ut denna med print-kommandot. Detta är också ordningen som koden interpreteras i i det första programmet, med skillnaden att Python lägger datan i temporära variabler under tiden den arbetar med dem.

Vår första funktion

Låt säga att vi villa hämta inmatning i form av heltal och addera dem. Då är inte raw_input() så bra, för den returnerar textsträngar. Vi vill ju ha heltal!

Sanningen är att det inte finns någon funktion för att hämta in heltalsvärden direkt, utan man måste omsluta värdet man vill omvandla med int(). Men ska vi göra detta för två tal så blir det onödigt mycket kod! Usch!

Därför skapar vi en funktion istället. När man skapar en funktion behöver man, lämpligt nog, överväga tre saker. Inmatning, beräkning och utmatning. Vad matar vi in, vad ska hända med inmatningen, vad förväntar vi oss att få tillbaka?

Inmatning: Prompt-meddelande för vår input-funktion.

Beräkning: Omvandla inmatad sträng till heltal.

Utmatning: Returnera resultatet.

Ordvitsar och abbriveringar är ju kul, så eftersom vi hämtar in heltal får funktionen heta “intput”. Den kunde lika gärna heta “havregryn”, men bra kodstandard hjälper läsaren maximalt genom att ha vettiga namn på funktioner och variabler.

def intput( prompt="" ):
    data = raw_input(prompt)
    data = int(data)
    return data

“def” säger bara att nu vill vi definiera en funktion. I parantesen anger man all indata man vill ha, i vårt fall promptmeddelandet. Om man inte anger någon sträng vill vi ändå hämta in värden, så vi anger ett standardvärde (en tom sträng) som används om användaren inte skickar in något annat. Det går såklart bra att ha vilket standardvärde som helst, t.ex. “input: “.

Notera sen också att resten av koden är indenterad! Skulle den stå på samma rad skulle den inte ingå i vår funktion. Först hämtar vi in ett tal i textformat, och på andra raden omvandlar vi denna till ett heltal med int(). Sista raden avslutar funktionen och skickar tillbaka “data”. Värt att notera är att man kan ha olika return-kommandon på olika platser i koden (t.ex. i en if-sats), men så fort en return-rad körs så avslutas funktionen.

“Men!”, utropar du, “Det händer ju inget när jag kör koden!”. Mycket riktigt, vi har ju bara definierat funktionen. Vill man använda sig av den måste man anropa den, exempelvis så här:

intput("Ange tal ett: ") + intput("Ange tal två: ")

Och så var vi klara med vårt program som kan addera två heltal!

Nu känner jag att jag börjar bli väldigt bra på cliffhangers här. Tanken var ju att vi skulle titta på import och GPIO på Raspberry Pi i detta avsnitt, men det får vi spara till nästa vecka eftersom det var viktigare att förklara lite om grunderna först. Lattja runt med Pythons inmatning och utskrifter så länge, vettja! 😉

Uppdatering: Nästa del finns nu upplagd här!