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

Villkor låter oss styra vad programmet gör. En if-sats kör kod om uttrycket efter if är sant. I Python avgör kolon (:) och indentering (inryck) vilken kod som hör till villkoret.

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. Koden som tillhör if-satsen är indenterad (vanligtvis fyra mellanslag). Var konsekvent i hela filen. 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.

3.1.1 Ett snarlikt exempel – med/utan indentering

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

Små förändringar i indentering ändrar programflödet — var noggrann.

3.1.2 Tid i program – localtime

Vi kan läsa av datorns (lokala) tid. Funktionen localtime() ger ett paket med tidsfält (en struct_time, ungefär som en namngiven tupel). Med strftime() kan vi formatera tiden till en snygg sträng.

from time import localtime, strftime

t = localtime()                 # t är en struct_time med fält som tm_hour, tm_min, ...
print(t)                        # visar alla fält (debug)

# Plocka ut delar
print("Timme:", t.tm_hour)      # 0..23
print("Minut:", t.tm_min)
print("Sekund:", t.tm_sec)

# Formatera hela datum/tid som text
tidtext = strftime("%Y-%m-%d %H:%M:%S", t)
print("Nu är klockan:", tidtext)

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

time.struct_time(tm_year=2026, tm_mon=05, tm_mday=11, tm_hour=04,
tm_min=32, tm_sec=51, tm_wday=1, tm_yday=130, tm_isdst=1)

Timme: 04
Minut: 32
Sekund: 51
Nu är klockan: 2026-05-11 04:32:51

from time import localtime, strftime

t = localtime()

# Uppgift 1
timme = t.tm_hour       # 0..23
print(f"Timmen är: {timme}")

# Uppgift 2
if timme >= 12:
    print("Eftermiddag")   # körs kl 12–23

# Uppgift 3
datumtext = strftime("%Y-%m-%d", t)
print(f"Idag är det {datumtext}")

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             # localtime() ger en time.struct_time
from datetime import datetime, date             # datetime/date är muterbara objekt

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=2026, tm_mon=05, tm_mday=11, tm_hour=04,
tm_min=32, tm_sec=51, tm_wday=1, tm_yday=130, tm_isdst=1)
<class 'time.struct_time'>

d: datetime
2026-05-11 04:32:51.293
<class 'datetime.datetime'>

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

3.2 else

När vi har ett villkor men vill fånga alla andra fall också använder vi else. Tänk: Om (villkor) – annars …. En else-gren har inget eget uttryck; den körs när villkoret i if är falskt.

# Fråga efter ett heltal
tal = int(input("Ange ett heltal: "))

if tal > 0:
    print("Talet är positivt")
else:
    print("Talet är noll eller negativt")

print("Klart!")  # körs alltid

tal = int(input("Ange ett heltal: "))

# Uppgift 1
if tal % 2 == 0:                 # rest 0 => jämnt
    print("jämnt")
else:
    print("udda")

# Uppgift 2
# Utskrift: "jämnt"
# Förklaring: 0 % 2 == 0 (resten när 0 delas med 2 är 0),
# därför uppfylls villkoret för "jämnt".

# Uppgift 3
# if tal > 0:
#    print("Talet är positivt")
# else:
#    print("Talet är noll eller negativt")
#    print("Klart!")      # nu skrivs "Klart!" ENDAST när else grenen körs

3.2.1 Jämföra två tal – tvåvägsbeslut

a = float(input("Ange tal a: "))
b = float(input("Ange tal b: "))

if a >= b:
    print(f"a ({a}) är störst eller lika stort som b ({b})")
else:
    print(f"b ({b}) är större än a ({a})")

3.2.2 Feljakt

Här finns en kort kodsnutt med flera vanliga misstag kring if/else. Kopiera, kör och rätta tills programmet beter sig som texten säger.

# Programmet ska fråga efter ålder och skriva
# "Myndig" om åldern är 18 eller mer, annars "Minderårig".

age = input("Ange din ålder: ")    # ska vara ett heltal
if age = 18:                        # jämförelse, inte tilldelning
    print("Myndig")
  else
    print("Minderårig")
print("Klar")

age = int(input("Ange din ålder: "))
if age >= 18:
    print("Myndig")
else:
    print("Minderårig")
print("Klar")

namn = input("Ange ditt namn: ").strip()
age = int(input("Ange din ålder: "))

print(f"Hej {namn}!")
print(f"Första bokstaven i ditt namn är: {namn[0]}")

if age >= 18:
    print("Myndig")
else:
    print("Minderårig")

3.3 elif

När ett beslut har fler än två vägar använder vi elif (else + if). Du kan ha hur många elif-grenar som helst, men fortfarande bara en if och högst en else i samma kedja.

# Läs in ett heltal
poäng = int(input("Ange poäng (0–100): "))

if poäng >= 90:
    print("Betyg: A")
elif poäng >= 80:
    print("Betyg: B")
elif poäng >= 70:
    print("Betyg: C")
elif poäng >= 60:
    print("Betyg: D")
elif poäng >= 50:
    print("Betyg: E")
else:
    print("Betyg: F")

# Uppgift 1
# För poäng = 95 blir utskriften "E".
# Varför? Kedjan testas uppifrån och ned. Villkoret (poäng >= 50) är sant
# för 95, så programmet stannar där och senare villkor (>= 90, >= 80 …)
# hinner aldrig testas. Ordningsregeln är alltså viktig.

# Uppgift 2
# Ja, rätt svar på varje test.
# Förväntat (A..F): 49:F  50:E  59:E  60:D  69:D  70:C  79:C  80:B  89:B  90:A

3.3.1 Vanlig fälla: överlapp & “döda grenar”

ålder = int(input("Ange ålder: "))

if ålder >= 18:
    print("Vuxen")
elif ålder >= 65:   # Denna gren är "död" – träffas aldrig
    print("Senior")
else:
    print("Minderårig")

Varför? Alla värden >= 65 matchar redan första villkoret. Lösning: byt ordning eller gör det första villkoret snävare.

if ålder >= 65:
    print("Senior")
elif ålder >= 18:
    print("Vuxen")
else:
    print("Minderårig")

3.3.2 Feljakt

Kopiera, kör och rätta programmet så att det kategoriserar temperatur korrekt:

# Regler:
#  temp < 0   → "Iskallt"
#  0–9        → "Kallt"
#  10–19      → "Svalt"
#  20–24      → "Lagom"
#  25–30      → "Varmt"
#  > 30       → "Hett"

t = input("Ange temperatur i °C: ")

if t > 30:
    print("Hett")
elif t >= 25:
    print("Varmt")
elif t >= 20
    print("Lagom")
elif t >= 0:
    print("Kallt")
elif t >= 10:
    print("Svalt")
else:
    print("Iskallt")

t = float(input("Ange temperatur i °C: "))

if t > 30:
    print("Hett")
elif t >= 25:
    print("Varmt")
elif t >= 20:
    print("Lagom")
elif t >= 10:
    print("Svalt")
elif t >= 0:
    print("Kallt")
else:
    print("Iskallt")

# mata in koden
kod = input("Ange statuskod: ").strip().upper()[0]

if kod == "P":
    print("Plockas")
elif kod == "S":
    print("Skickad")
elif kod == "L":
    print("Levererad")
else:
    print("Okänd status")

3.4 Operatorer

I våra selektioner har vi skrivit uttryck som avgör vad programmet ska göra. Alla sådana uttryck måste ge ett svar som är sant (True) eller falskt (False). För att kunna bygga dessa uttryck behöver vi kunna använda olika operatorer.

3.4.1 Jämförelseoperatorer

Jämförelseoperatorer används när vi vill jämföra värden. De fungerar ungefär som i matematiken och returnerar alltid ett booleskt värde (True eller False).

x = 14

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

Det går även att jämföra strängar alfabetiskt (lexikografiskt):

print("apa" == "apa")   # True
print("Apa" == "apa")   # False (stor/liten bokstav skiljer)
print("apa" < "banan")  # True (a kommer före b i alfabetet)

x = 10
y = 15
print(x > y)
print(x + 5 == y)
print("hej" != "Hej")
print("abc" < "abd")

# x > y          -> False
# x + 5 == y     -> True
# "hej" != "Hej" -> True (stor/liten bokstav skiljer)
# "abc" < "abd"  -> True (alfabetiskt jämförs tecken för tecken)

3.4.2 Logiska operatorer

Logiska operatorer används för att kombinera flera uttryck i samma villkor. De fungerar så här:

ålder = 17
har_tillstånd = True

print(ålder > 18 and har_tillstånd)  # False
print(ålder > 18 or har_tillstånd)   # True
print(not har_tillstånd)             # False

ålder = int(input("Ange ålder: "))
längd = int(input("Ange längd i cm: "))

if ålder >= 15 and längd >= 160:
    print("Du får åka!")
else:
    print("Tyvärr, inte idag.")

3.4.3 Sammansatta uttryck, parenteser & operatorprioritet

Python prioriterar and före or. Med parenteser kan vi styra ordningen. Samma variabler kan ge olika resultat beroende på hur vi grupperar uttrycken.

# Regler (tänkta):
#   - Man kommer in om man har biljett OCH dörren är öppen
#   - ... ELLER om man står på gästlistan

har_biljett   = False
dörr_öppen    = True
på_gästlista  = True

# A) Utan parenteser → AND prioriteras före OR
#    Tolkning: (har_biljett AND dörr_öppen) OR på_gästlista
resA = har_biljett and dörr_öppen or på_gästlista
print("A:", resA)  # True

# B) Parenteser runt AND-delen (samma som A enligt prioritet)
resB = (har_biljett and dörr_öppen) or på_gästlista
print("B:", resB)  # True

# C) Parenteser på ett annat ställe
#    Tolkning: har_biljett AND (dörr_öppen OR på_gästlista)
resC = har_biljett and (dörr_öppen or på_gästlista)
print("C:", resC)  # False

A: True
B: True
C: False

# Negation (resD är True bara när varken "biljett & dörr" eller gästlista gäller)
har_biljett=False
dörr_öppen=False
på_gästlista=False
resD = not (har_biljett and dörr_öppen or på_gästlista)     # not(False or False) -> True
print("Negation:", resD)  # True

3.4.4 Miniquiz – Sant eller falskt?

Testa om du har koll på logiska operatorer, parenteser och kedjade jämförelser. Försök gissa resultaten innan du öppnar facit!

# Fråga 1
print(5 > 3 and 2 < 4)

# Fråga 2
print(5 > 3 or 2 > 8 and 4 < 1)

# Fråga 3
print(not (7 <= 10 and 3 > 5))

# Fråga 4
ålder = 17
print(8 <= ålder < 18)

# Fråga 5
biljett = False
gästlista = False
print(not (biljett or gästlista))

# Fråga 1
# 5 > 3 (True) och 2 < 4 (True) → True and True → True

# Fråga 2
# and prioriteras före or:
# 2 > 8 and 4 < 1 → False and False → False
# 5 > 3 or False → True → True

# Fråga 3
# (7 <= 10 and 3 > 5) → True and False → False
# not False → True

# Fråga 4
# 8 <= 17 < 18 → True and True → True
# (kedjad jämförelse kontrollerar båda delarna)

# Fråga 5
# (biljett or gästlista) → False
# not False → True
# alltså: "Får inte komma in" → True betyder att uttrycket 'inte har biljett eller gästlista' stämmer

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. Det hjälper oss att förstå problemet bättre och undvika misstag senare. Ett vanligt verktyg för detta är pseudokod – ett sätt att beskriva hur programmet ska fungera med vanligt språk, utan att behöva följa programmeringsspråkets regler.

Pseudokod fokuserar på vad programmet ska göra – inte hur det ska göras i kod.

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.

# Fråga användaren efter hens ålder
ålder = int(input("Ange din ålder: "))

# Om åldern är mindre än 18
if ålder < 18:
    print("Du är minderårig")
# Annars om åldern är större än 64
elif ålder > 64:
    print("Du är troligtvis pensionär")
# Annars
else:
    print("Du är troligtvis vuxen och jobbar")

Som du ser liknar koden nästan punktlistan rad för rad. Om du skriver tydlig pseudokod först, blir själva kodningen ofta enkel.

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.

x = int(input("Ange ett tal: "))
if x % 2 == 0:
    print("Jämnt")
else:
    print("Udda")

# 1. Fråga användaren efter ett tal
# 2. Fråga efter ett till
# 3. Multiplicera talen
# 4. Om de är lika → skriv att det är en kvadrat
# 5. Annars → skriv att det är en rektangel

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å gymnasiet 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.7 Avrundning av momentet

Detta moment avslutas med två diagnoser som säkerställer att du har förstått grunderna:

• En teoretisk diagnos i form av en quiz med 10 frågor på de viktigaste begreppen.
• En praktisk diagnos där du får skriva kod och lösa en eller flera uppgifter med fokus på det du lärt dig i momentet.

Syftet är att både kontrollera dina kunskaper och ge dig en chans att öva på provliknande situationer.

3.7.1 Checklista inför diagnosen

För att vara förberedd bör du kunna: