3. Moment03 - Selektioner och operatorer

I alla programmeringsspråk så är selektioner ett centralt begrepp. Selektioner eller villkorssatser brukar vi kalla det på svenska, Control Structures heter det på engelska. Oavsett vad det kallas så handlar det om val och att tala om för programmet att göra olika saker beroende på ett specifikt villkor.

I detta moment kommer vi lära oss att förstå strukturen kring villkorssatser men också lära oss att skriva de villkor som styr dem.

3.1 if

Den absolut vanligaste selektionen är att bara använda en if-sats. Genom att skriva en if-sats och ett uttryck så får du din kod att utföra en operation. If-sats är grunden till alla selektioner och eftersom if betyder om på svenska så blir det ganska enkelt att förklara vad som skall hända. Om ålder är större än 17 så....

Vi gör ett enkelt exempel;

# Fråga efter ålder och lagra denna i variabeln age
age = int(input("Ange din ålder: "))

# Om age är större än 17 ...
if age > 17:
    # ... Skriv ut meddelande
    print("Du är myndig och får rösta")

# Skrivs ut oavsett om if-satsens villkor är rätt eller ej
print("Programmet avslutas")

Det uttryck som skrivs ihop med en if-sats skrivs alltid på ett sådant sätt att det ger ett svar som är sant eller falskt, true/false, och detta uttryck får datatypen boolean vilket vi snabbt nämnde i förra momentet. Mer om uttryck och operatorer kommer senare i detta moment.

Resultatet beror på vad du matar in, men här kommer två exempelutskrifter.

Ange din ålder: 16
Programmet avslutas

Ange din ålder: 22
Du är myndig och får rösta
Programmet avslutas

Som du ser på rad 5 i koden ovanför så bygger vi upp ett villkor med if och sedan skrivs ett uttryck. Efter uttrycket så skriver vi ett kolon och efter detta kolon kommer nu all kod som är indenterad (inflyttad med tab) tillhöra villkoret. Du som har kodat i andra språk tidigare har säkerligen sett andra alternativ för hur man skriver selektioner men i Python är det kolon : och indentering som avgör vad som tillhör en selektion eller inte.

Här kommer två exempel som ser väldigt lika ut men där utskriften blir annorlunda.

# resultatet på ett matteprov
result = 14

# Mindre än 20 poäng var underkänt på provet
if result > 19:
    print("Du är godkänd")
    print("Grattis till ett bra resultat")

I detta fall ges ingen utskrift allt. Vi förändrar koden ytterst lite och tar bort indenteringen på rad sju vilket gör att koden ser ut på följande sätt...

# resultatet på ett matteprov
result = 14

# Mindre än 20 poäng var underkänt på provet
if result > 19:
    print("Du är godkänd")
print("Grattis till ett bra resultat")

... och ger detta resultatet.

Grattis till ett bra resultat

Detta visar hur viktigt det är att vara noggrann i sin kodning när det gäller selektioner.

Innan det är dags att göra två uppgifter med selektioner så skall vi kika på en användbar funktion och det är möjligheten att läsa av datorns/serverns tid. Kika på exemplet nedan.

# Importerar localtime från time
from time import localtime, strftime

# localtime() hämtar tiden och skapar en "tuple"
t = localtime()

# Utskrift av hela "tuple" för localtime()
# Denna utskrift är inte användbar för utskrift men visar vad som lagras.
print(t)

# Utskrift av timmar, minuter och sekunder
print(t.tm_hour)   # timmar från t
print(t.tm_min)    # minuter från t
print(t.tm_sec)    # sekunder från t

# Utskrift av datum snyggt formaterat
print(strftime('%Y-%m-%d %H:%M:%S', t))

Utskriften blir då på följande sätt.

time.struct_time(tm_year=2025, tm_mon=04, tm_mday=21, tm_hour=07,
tm_min=44, tm_sec=34, tm_wday=1, tm_yday=110, tm_isdst=1)
07
44
34
2025-04-21 07:44:34

Vill du läsa mer och lära dig mer om vilka formateringsmöjligheter som finns för datum och tid så kan du läsa det här.

from time import localtime, strftime            # Skapar en tuple
from datetime import datetime, date             # Skapar ett objekt av typen datetime

t = localtime()
print("\nt: localtime")
print(t)
print(type(t))

d = datetime.now()
print("\nd: datetime")
print(d)
print(type(d))

d1 = date.fromisoformat("2012-06-24")
d2 = date.fromisoformat("2014-09-25")

print("\nd: Specifikt datum")
print(d1)
print(d1.strftime('%Y-%m-%d %H:%M:%S'))
print(type(d1))

print(d2 - d1)

t: localtime
time.struct_time(tm_year=2025, tm_mon=04, tm_mday=21, tm_hour=07,
tm_min=44, tm_sec=34, tm_wday=1, tm_yday=110, tm_isdst=1)
<class 'time.struct_time'>

d: datetime
2025-04-21 07:44:34.866
<class 'datetime.datetime'>

d: Specifikt datum
2012-06-24
2012-06-24 00:00:00
<class 'datetime.date'>
823 days, 0:00:00

När användaren skall mata in något till programmet så är det viktigt att vi är tydliga vad som förväntas. Om vi ställer en fråga som skall besvaras med ja så kommer det bli skillnad om användaren skriver ja, Ja eller JA. Några jobbade med denna typ av uppgifter i förra momentets inlämningsuppgift men det är dags att ta det en gång till. Det exempel som visades då kommer här igen.

# Inmatning från användaren
svar = "  ja "

# Tar bort ev whitespace i början och slutet av inmatningen
svar = svar.strip()

# Tar fram första bokstaven i svaret
# 0 står för indexet/positionen för den bokstav vi letar efter
svar = svar[0]

# Gör om första bokstaven till versal (stor bokstav)
svar = svar.upper()

# Skriver ut svaret
print(svar)

# Tar emot en inmatning
age = input("Ange hur gammal du är: ")      # datatyp str

# ta bort felaktiga white-space
age = age.strip()                           # datatyp str

# gör om age till int
age = int(age)                              # datatyp int

# utskrift
print(f"Din ålder är {age} år.")

# Det går också att göra i en enda rad,
# först inmatning, sedan strip() och slutligen typkonvertering
# använd denna om du förstår hur den fungerar och kan använda den
age = int(input("Ange hur gammal du är: ").strip())

# utskrift
print(f"Din ålder är {age} år."))

3.2 else

När vi nu kan få programmet att göra någonting om ett villkor gäller så behöver vi ju kunna göra något annat om villkoret inte gäller. Det är då vi lägger till vår else-sats. Vi kan läsa ut det som annars vilket då skulle innebär att att Om något gäller så gör detta, annars gör detta.

Vi bygger vidare på vårt tidigare exempel.

# Fråga efter ålder och lagra denna i variabeln age
age = int(input("Ange din ålder: "))

# Om age är större än 17 ...
if age > 17:
    # ... Skriv ut meddelande
    print("Du är myndig och får rösta")
else:               # ... annars
    print("Du är minderårig och får inte rösta")

# Skrivs ut oavsett om if-satsens villkor är rätt eller ej
print("Programmet avslutas")

Resultatet beror på vad du matar in, men här kommer två exempelutskrifter.

Ange din ålder: 16
Du är minderårig och får inte rösta
Programmet avslutas

Ange din ålder: 22
Du är myndig och får rösta
Programmet avslutas

Det är viktigt att tänka på att if-satsen skall ha ett uttryck medan else-satsen inte har något uttryck. Detta beror på att else tar hand om alla alternativ som inte är godkända för if-satsens uttryck. Om du vill ställa många uttryck så skall vi kika på det i nästa avsnitt.

3.3 elif

Ibland så räcker det inte endast med en if-sats och en else-sats utan vi behöver få in flera alternativ. I python så heter detta kommando elif som är en ihopdragning av else och if, else if är ett vanligt kommando i de flesta programmeringsspråk.

Vad som är viktigt att tänka på är att en selektion måste bestå av en if-sats, den kan bestå av max en else-sats och kan innehålla hur många elif-satser som helst.

Dags att kika på ett exempel;

# Fråga efter ålder och lagra denna i variabeln age
age = int(input("Ange din ålder: "))

if age < 18:            # Om age är mindre än 18 ...
    print("Du är minderårig och bör gå i skolan")
elif age > 64:          # ... annars om age är större än 64 ...
    print("Du är troligtvis pensionär")
else:                   # ... annars
    print("Jobba, jobba, jobba")

Troligtvis vet du hur utskriften blir men är du osäker så kopiera koden och testa.

Något att tänka på är att elif-satserna behöver ett uttryck och om vi väljer att bygga stora selektioner så finns det alltid en risk att vi skriver uttryck som tar ut varandra eller överlappar varandra. Det går inte att först fråga om age > 20 och sedan om age >15 eftersom i vår selektion så kan det bara bli ett val som används. Om det är två eller flera uttryck som är korrekta så kommer interpretatorn välja det första uttryck som är sant. För att hitta dessa problem och kunna åtgärda dem så är det viktigt att testa dina program innan du är klar. Speciellt viktigt är det att testa gränserna för dina uttryck. I exemplet ovan så hade jag iaf testat åldrarna 17, 18, 64 och 65, då bör jag ha fått med mig alla alternativ och kunnat se att programmet fungerar som det skall. I nästa moment så kommer vi kolla på hur vi kan upprepa denna koden med en massa olika åldrar och då hade vi med några rader kod kunnat testa alla åldrar från 0 till 100 för att se att vårt program beter sig som vi vill.

Vi tar ett större exempel med flera elif-satser så att du får se hur det kan se ut.

# Fråga efter ålder och lagra denna i variabeln age
age = int(input("Ange din ålder: "))

# Skriv ut
print(f"Du är {age} år gammal, ", end="")

if age < 2:                 # om age < 2 ...
    print("du är nog hemma med dina föräldrar.")
elif age < 6:               # ... annars om age < 6
    print("du går på förskolan.")
elif age < 12:              # ... annars om age < 12
    print("går i skolan och har förhoppningsvis många läxor.")
elif age < 20:              # ... annars om age < 20
    print("tonåring och läser på högstadie, gymnasie eller högskolan.")
elif age > 64:              # ... annars om age större än 64
    print("du är troligtvis pensionär.")
else:                       # ... annars
    print("jobba, jobba, jobba!")

Det viktigaste här är att vi kollar åldrarna i rätt ordning. Matar jag in åldern 1 år så skulle de fyra första uttrycken vara korrekta men Python väljer det som är först. Hade vi då blandat ordningen så hade vilken av de fyra första kunnat vara ok, så min ettåring skulle kunna vara tonåring och läsa på högstadiet, gymnasiet eller högskolan om vi inte hade varit noggranna.

3.4 Operatorer

I våra selektioner ovan så har vi skrivit uttryck. Alla uttryck som vi skapar måste ge svaret SANT eller FALSKT. Inga andra svar kommer fungera. För att kunna skriva enkla eller svårare uttryck så behöver vi kunna använda olika operatorer.

3.4.1 Jämförelseoperatorer

Jämförelseoperatorer känner du igen från matematiken. Dessa operatorer gör precis vad de säger, de används för att jämföra olika värden.

tal = 14

print(tal == 12)   # False
print(tal != 12)   # True
print(tal < 12)    # False
print(tal > 12)    # True
print(tal <= 12)   # False
print(tal >= 12)   # True

Som du ser i exemplet så går det att skriva ut svaret för uttrycket men oftast så vill vi ju att något skall ske i samband med ett uttryck.

3.4.2 Logiska operatorer

Logiska operatorer används för att kunna skapa sammansatta uttryck där vi vill göra flera jämförelser.

I tabellen står det uttryck1 & 2, det kan lika gärna vara en variabel av datatypen boolean.

3.4.3 Sammansatta exempel

Att lära sig bygga sammansatta uttryck är viktigt för att skriva bra kod. I många fall så går det att komma runt med flera mindre uttryck men vi vill ju skriva effektiv kod och då är detta bra att kunna. Här kommer några exempel;

# Fråga efter ålder och lagra denna i variabeln age
age = 19

if age < 18 or age > 65:
    print("Du är ungdom eller pensionär")
else:
    print("Du är vuxen")

Du kan göra uttrycken väldigt långa, men ofta stjälper det mer än hjälper. Vi kommer senare i momentet titta på alternativa lösningar.

age = 17
score = 15.5
likeChallange = True

if age > 15 and age < 20 and score > 15 or likeChallange:
    print("Du är redo att läsa på Teknikprogrammet")
else:
    print("Vilket program passar dig?")

age = 19
score = 20
likeChallange = True

# istället för "age > 15 and age < 20"
if 15 < age < 20 :
    print("Du är redo att läsa på Teknikprogrammet")
else:
    print("Vilket program passar dig?")

# & istället för "and"
if 15 < age < 20 & score > 15:
    print("Du är redo att läsa på Teknikprogrammet")
else:
    print("Vilket program passar dig?")

# Tecknet pipe (|, option + 7 i macOS, AltGr + "större än, mindre än" i Windows) istället för "or", 
# lägg märke till att jag måste använda parentes då | har lägre prioritet än or.
# Använd gärna men testa så att det fungerar som du vill.
if (15 < age < 20 & score > 15) | likeChallange:
    print("Du är redo att läsa på Teknikprogrammet")
else:
    print("Vilket program passar dig?")

3.5 Metoder för att underlätta problemlösning

Innan vi börjar skriva kod är det viktigt att planera och strukturera våra program. Detta hjälper oss att förstå problemet bättre och undvika misstag senare. Två vanliga metoder för att göra detta är pseudokod och aktivitetsdiagram.

Pseudokod är ett sätt att beskriva hur ett program ska fungera genom att använda enklare språk och strukturer som liknar programmeringsspråk men utan att följa några specifika syntaxregler. Det fokuserar på logiken och stegen i programmet.

Aktivitetsdiagram är grafiska representationer som visar flödet av aktiviteter eller steg i ett program. De hjälper till att visualisera processen och hur olika delar av programmet hänger ihop.

I det här avsnittet kommer vi att fokusera på pseudokod och hur det kan användas för att planera våra program.

3.5.1 Pseudokod

Pseudokod är ett verktyg som programmerare använder för att planera och beskriva algoritmer innan de skriver den faktiska koden. Det är ett informellt sätt att skriva ned programlogik som är lätt att läsa och förstå, både för programmerare och andra intressenter.

Varför använda pseudokod?

• Enkelhet: Det låter oss fokusera på logiken utan att oroa oss för syntaxen i ett specifikt programmeringsspråk.
• Kommunikation: Det är lättare att diskutera och dela idéer med andra när man använder ett gemensamt, enkelt språk.
• Planering: Hjälper till att identifiera problem och tänka igenom lösningar innan kodningen börjar.

Pseduokod är en skriftlig beskrivning av lösningen där vi med så normalt språk som möjligt skall beskriva lösningen i punktform. Om varje punkt är formulerad så att den endast gör en instruktion så kan pseudokoden vara grunden till en välkommenterad kod.

Jag kommer visa hur pseudokod används genom att beskriva en uppgift som vi har pratat om tidigare. Uppgiften jag vill jobba med är den som vi gick igenom i kapitel 3.3 där vi skapade vår första if-elif-else-sats där vi frågar efter åldern på en person och avgör om denna personen är minderårig, pensionär eller myndig.

Pseudokod kan vi skriva olika detaljerat, det kan vara värt att skriva en mer överskådlig beskrivning av lösningen, speciellt om det är en större applikation som skall skrivas, för att sedan gå in på djupet och skriva den mer detaljerad.

Detta sätt att skriva är helt ok, hela lösningen av uppgiften finns bland dessa fyra punkter. Nu visar jag ett annat sätt att skriva samma lösning på. Den är lite mer detaljerad.

Nu valde jag att skriva det med punkter där jag indenterade vad som händer om ett villkor gäller, vilket gör att det väldigt mycket liknar vår selektion (if/elif/else), och att det troligtvis känns enklare att bygga en korrekt kod för den som håller på att lära sig.

Hur skriver man effektiv pseudokod?

• Var tydlig och koncis: Använd enkla meningar och undvik onödig information.
• Använd nyckelord: Vid selektioner används "om, annars om, annars" och vid iterationer används "för, medan, så länge som", vi återkommer till iterationer i nästa moment.
• Fokusera på logik: Beskriv vad som ska göras, inte hur det ska göras i kod.

Fördelar med pseudokod

• Språkoberoende: Kan användas oavsett vilket programmeringsspråk som ska användas senare.
• Lätt att förstå: Även de som inte är bekanta med programmeringsspråkets syntax kan följa logiken.
• Flexibilitet: Lätt att ändra och förbättra innan man börjar med den faktiska kodningen.

Om du nu kikar igenom uppgiften i kapitel 3.3 så ser du att kommentarerna i den koden är väldigt lika de punkter som jag skrivit i vår pseudokod. Att lösa uppgiften med pseudokod först och sedan använda dessa punkter som kommentarer under tiden vi bygger vår applikation är ett smidigt sätt att hitta lösningen först och undvika att få problem med själva koden.

3.6 Nästlade selektioner

En nästlad selektion är ibland något vi behöver använda oss av. Det handlar om att det finns en selektion inne i en annan selektion. Ibland går det att undvika detta genom att skriva om våra uttryck. Men ibland är det inte möjligt att göra det, eller ens önskvärt ifall vi får väldigt komplicerade uttryck som resultat. Vi bygger vidare på några av våra tidigare exempel för att visa hur det fungerar.

Vi gör ett enkelt exempel;

# Fråga efter ålder och lagra denna i variabeln age
age = int(input("Ange din ålder: "))

# if age < 18
if age < 18:            # Alla minderåriga
    print("Du är minderårig ", end="")
    if age < 2:                 # under 2 år
        print("och är nog hemma med dina föräldrar.")
    elif age < 6:               # under 6 år
        print("och du går i förskolan.")
    elif age < 12:              # under 12 år
        print("och går i skolan, förhoppningsvis har du många läxor.")
    else:                       # Övriga minderåriga
        print(" men tonåring och läser på högstadie, gymnasie eller högskolan.")
elif age < 20:          # Alla under 20
    print("Du är myndig, tonåring och läser på gymnaiet eller högskolan.")
elif age > 64:          # Alla över 64
    print("du är troligtvis pensionär.")
else:                   # Alla andra
    print("jobba, jobba, jobba!")

Här gäller det att vara extra noggrann eftersom det enda sätt som vi kan visa vilken kod som tillhör en selektion är att den koden är indenterad ett steg. Det innebär att under vår selektion if age < 18 så flyttar vi in koden ett steg med tab (indenterar) och sedan vid nästa selektion så indenterar vi ett steg till. Det här går att göra i väldigt många steg men det brukar tillslut innebära att koden är näst intill oläslig.

Nästlade selektioner används oftare än vad du kan tro, men du kommer också stöta på andra kontrollstrukturer som kan/bör nästlas och det är inte sällan som en eller flera loopar nästlas och inne i varje sådan loop finns det en eller flera nästlade selektioner. Så det är lika bra att lära sig när det fortfarande är relativt enkelt.

3.6.1 Pseudokod

Hur markerar vi i vår pseudokod att det är en nästlad selektion? Det enklaste sättet är att visa det genom ett extra djup i vår punktlista. Samtidigt så är det inte alltid vi som avgör att det kommer bli en nästlad selektion utan det kan vara något som kodaren vill välja. Hur som helst så har vi nu kontrollen på pseudokoden och själva kodningen så då kan vi visa hur vi tänkte när vi kodade lösningen.

# importerar modulen sys
import sys

# funktionen exit() stänger av programmet
sys.exit()

3.x Stränghantering i Python

Att kunna hantera strängar är en grundläggande färdighet inom programmering. Strängar används för att representera text, och i många program behöver vi bearbeta och analysera textdata. I detta avsnitt kommer vi att utforska varför stränghantering är viktigt, lära oss några viktiga funktioner i Python för att manipulera strängar, och avsluta med en uppgift där du får tillämpa dessa kunskaper.

3.x.1 Varför är stränghantering viktigt?

• Interaktion med användaren: Många program tar emot inmatning från användaren i form av text. För att förstå och reagera på denna inmatning behöver vi kunna bearbeta strängar.

• Datahantering: Mycket data lagras och överförs som text. För att extrahera information från denna data behöver vi kunna söka, dela upp och modifiera strängar.

• Felhantering: Användare kan mata in oväntade eller felaktiga data. Genom att hantera strängar effektivt kan vi validera och sanera inmatningar för att förhindra fel i programmet.

3.x.2 Viktiga strängfunktioner i Python

Här är några grundläggande strängfunktioner och metoder i Python som är användbara att känna till:

1. Längd på en sträng med len(): Returnerar antalet tecken i strängen.

   text = "Hej världen"
   print(len(text))  # Output: 11

2. Åtkomst till tecken med index:

   En sträng kan ses som en sekvens av tecken där varje tecken har en position, kallad index. Indexeringen börjar från 0 för det första tecknet, 1 för det andra, och så vidare. Man kan också använda negativa index för att räkna baklänges från slutet av strängen (-1 för sista tecknet, -2 för näst sista, osv).

   text = "Python"
   print(text[0])    # Output: P (första tecknet)
   print(text[1])    # Output: y (andra tecknet)
   print(text[-1])   # Output: n (sista tecknet)
   print(text[-2])   # Output: o (näst sista tecknet)
   

3. Konkatenering (sammanfogning) av strängar:

   text1 = "Hej"
   text2 = "världen"
   sammanfogad = text1 + " " + text2
   print(sammanfogad)  # Output: Hej världen

4. Ändra mellan versaler och gemener med str.lower(), str.upper(), str.capitalize(), str.title():

   • str.lower(): Konverterar alla bokstäver till små bokstäver.
   • str.upper(): Konverterar alla bokstäver till stora bokstäver.
   • str.capitalize(): Gör första bokstaven stor och resten små.
   • str.title(): Gör första bokstaven i varje ord stor och resten små.

   text = "heJ vÄrLdEn"
   print(text.lower())      # Output: hej världen
   print(text.upper())      # Output: HEJ VÄRLDEN
   print(text.capitalize()) # Output: Hej världen
   print(text.title())      # Output: Hej Världen
   

5. str.strip(): Tar bort inledande och avslutande blanksteg.

   text = "  hej "
   print(text.strip())  # Output: hej
   

6. str.replace(old, new): Ersätter en del av strängen med något annat.

   text = "Jag älskar programmering"
   print(text.replace("älskar", "gillar"))  # Output: Jag gillar programmering
   

7. str.find(substring): Söker efter en delsträng och returnerar dess startposition (index), eller -1 om den inte hittas.

   text = "Hej världen"
   position = text.find("världen")
   print(position)  # Output: 4
   

3.x.3 Exempel: Bearbeta en mening

Låt oss använda några av dessa funktioner i ett sammanhang. Antag att vi har följande sträng:

mening = "  Hej och välkommen till Programmering 01!  "

Vi vill bearbeta denna sträng på flera sätt:

1. Ta bort extra blanksteg:

   mening = mening.strip()
   print(mening)  # Output: Hej och välkommen till Programmering 01!
   

2. Konvertera till versaler:

   versaler = mening.upper()
   print(versaler)  # Output: HEJ OCH VÄLKOMMEN TILL PROGRAMMERING 01!
   

3. Ersätta ord:

   ny_mening = mening.replace("Programmering 01", "Python-kursen")
   print(ny_mening)  # Output: Hej och välkommen till Python-kursen!
   

4. Åtkomst till enskilda tecken:

   första_tecken = mening[0]
   sista_tecken = mening[-1]
   print(f"Första tecknet: '{första_tecken}', Sista tecknet: '{sista_tecken}'")
   # Output: Första tecknet: 'H', Sista tecknet: '!'
   

Ange en mening:   jag lär mig att programmera i python!  
Antal tecken i meningen: 37
Meningen med stor bokstav i varje ord:
Jag Lär Mig Att Programmera I Python!

Ange en mening: Jag älskar att programmera. Att programmera är kul!
  Ange ordet du vill ersätta: programmera
  Ange det nya ordet: koda

  Den nya meningen är:
  Jag älskar att koda. Att koda är kul!
  

3.x.5 Sammanfattning

Stränghantering är en viktig del av programmering som låter oss bearbeta och analysera textdata. Genom att behärska grundläggande strängfunktioner kan vi skapa mer interaktiva och robusta program. Uppgiften ovan ger dig möjlighet att öva på dessa färdigheter i praktiken.

3.7 Slutuppgift på momentet

Två stycken diagnoser, teoretisk och praktisk, avrundar momentet.

Vill du förbereda dig inför slutuppgifterna så jobba med uppgifterna i detta moment, kolla på vad du fick som feedback på tidigare inlämningsuppgifter och kika i extramaterialet om du vill träna mer.