4. Moment04 - Iterationer och listor

4.1 Iteration – upprepning i kod

Iteration är ett annat ord för upprepning. Inom matematiken och i programmering handlar iteration om att en funktion eller process upprepar beräkningar eller andra operationer tills ett önskat resultat uppnåtts. I Python kommer du framför allt att använda två typer av loopar:

• for-loop – när du vet hur många gånger något ska upprepas (antal varv)
• while-loop – när du vill upprepa något så länge ett villkor är uppfyllt

Vi börjar med for-loopen, som är den mest styrda loopen.

4.1.1 Första for-loopen

Ett första exempel på en for-loop som körs fem varv:

for i in range(5):
    print(i)

När du kör koden ovan blir utskriften:

0
1
2
3
4

Funktionen range(5) skapar en talföljd som börjar på 0 och slutar precis innan 5. Loopen körs alltså fem varv: för i = 0, 1, 2, 3, 4.

Vi kan skriva samma loop mer tydligt genom att ange både start- och stoppvärde:

for i in range(0, 5):
    print(i)

Detta ger exakt samma utskrift som det första exemplet.

• Första talet i range() är startvärde (inkluderas).
• Andra talet är stoppvärde. stoppvärdet är aldrig med i talföljden.

for år in range(1, 6):
    print("År:", år)

4.1.2 Start, stopp och steg

Ibland vill vi inte räkna alla tal ett och ett, utan hoppa i större steg. Vi kan också ge range() ett tredje argument: stegstorleken.

# Räkna från 1 till 9, i steg om 2
for tal in range(1, 10, 2):
    print(tal)

Utskrift:

1
3
5
7
9

Här börjar vi på 1, går upp till men inte med 10, och hoppar i steg om 2. Talserien blir alltså 1, 3, 5, 7, 9.

Värdena i range(start, stopp, steg) betyder:

• start – första talet i serien (tas med)
• stopp – sista gränsen (tas inte med)
• steg – hur mycket talet ökar (eller minskar) för varje varv

for tal in range(10, 0, -1):
    print(tal)

summa = 0

for tal in range(1, 21):
    print(tal)
    summa += tal

print(f"Summan av alla talen är {summa}")

# 1
for i in range(5):
    print(i)

# 2
for i in range(3, 9):
    print(i)

# 3
for i in range(2, 12, 3):
    print(i)

# 4
for i in range(10, 0, -1):
    print(i)

Nu har du testat for-loopar med range(). Dags att använda dem i lite större uppgifter.

4.1.3 Nästlade iterationer

Ibland behöver vi göra en loop inuti en annan loop. Detta kallas för en nästlad iteration (eller "loop i loop"). Det används när något behöver upprepas i två led – till exempel rader och kolumner, eller kombinationer av två olika värden.

Ett enkelt sätt att tänka på nästlade loopar är:

• Yttre loopen – bestämmer hur många “rader” som ska göras
• Inre loopen – fyller varje rad med värden

# 6:ans och 7:ans multiplikationstabeller

for i in range(6, 8):          # Yttre loop: tabell 6 och tabell 7
    for j in range(1, 11):     # Inre loop: talen 1–10
        print(f"{i} * {j} = {i * j}")
    print()                    # Tom rad mellan tabellerna

Förklaring:

• När i = 6 körs innerloopen 10 gånger (1–10)
• När i = 7 körs innerloopen igen (1–10)
• Den inre loopen kör alltså klart varje gång innan den yttre går vidare

6 * 1 = 6
6 * 2 = 12
...
6 * 10 = 60

7 * 1 = 7
7 * 2 = 14
...
7 * 10 = 70

for t1 in range(1, 7):
    for t2 in range(1, 7):
        print(t1, "+", t2)

Multiplikationstabell

  1  2  3  4  5
  2  4  6  8 10
  3  6  9 12 15
  4  8 12 16 20
  5 10 15 20 25

4.1.4 Iteration som testmetod

En loop används inte bara för att räkna tal eller skriva ut serier. Den kan också vara ett kraftfullt sätt att testa hur ett uttryck fungerar för många olika värden.

I stället för att mata in värden manuellt kan vi låta en loop prova alla tänkbara fall åt oss. Det här är väldigt användbart när vi vill kontrollera om vår logik fungerar som vi tänkt.

for timme in range(0, 24):              # Testa alla timmar 0–23
    print(f"Klockan är {timme}, ", end="")

    if timme < 8:
        print("skoldagen har inte börjat.")
    elif timme > 16:
        print("skoldagen är slut.")
    else:
        print("skoldagen pågår.")

Fördelen här är att vi kan se exakt vid vilka tider gränserna slår om – utan att skriva in något själva.

for tal in range(1, 31):
    if tal % 3 == 0:
        print(f"{tal} är delbart med 3")

Detta är ett vanligt sätt att testa eller felsöka villkor.

for tal in range(1, 41):

    if tal % 5 == 0:
        print(f"{tal} är delbart med 5")

    if tal % 2 == 0 and tal % 3 == 0:
        print(f"{tal} är delbart med både 2 och 3")

Ange vilken multiplikationstabell: 3

Multiplikationstabell upp till 1x1
1

Multiplikationstabell upp till 2x2
1 2
2 4

Multiplikationstabell upp till 3x3
1 2 3
2 4 6
3 6 9

4.2 while-loop

En while-loop används när vi vill upprepa kod så länge ett villkor är sant. Till skillnad från for-loopen är det alltså inte bestämt i förväg hur många varv loopen körs. Strukturen ser ut så här:

while villkor:
    kod som upprepas

Ett första exempel på en while-loop som körs fem varv:

tal = 1

while tal <= 5:
    print(tal)
    tal += 1                 # viktiga raden!

Förklaring:

• Loopen körs så länge tal <= 5 är sant.
• Efter varje varv ökar vi tal med 1.
• När tal blir 6 avslutas loopen.

Viktigt!

tal = 1

while tal <= 5:
    print(tal)     # tal ändras aldrig → loopen kör för alltid!

tal = 1

while tal <= 15:
    print(tal)
    tal += 1

tal = 20

while tal >= 0:
    print(tal)
    tal -= 1

print("Klart!")

4.2.1 break – avbryta en loop

Ibland vill vi kunna avbryta en loop i förtid, även om villkoret fortfarande är sant (för while) eller om det finns fler varv kvar (för for-loopar). Då använder vi nyckelordet break.

När Python kör ett break inuti en loop:

• hoppar programmet ut ur loopen direkt
• fortsätter på första raden efter loopen

while True:
    text = input("Skriv något (eller 'stop' för att avsluta): ")

    if text == "stop":
        print("Avslutar loopen.")
        break              # hoppar ut ur loopen

    print("Du skrev:", text)

print("Utanför loopen.")

Förklaring:

• while True betyder att loopen i teorin kan köra för alltid.
• När användaren skriver stop körs break och loopen avslutas direkt.
• Programmet fortsätter sedan på raden print("Utanför loopen.").

break fungerar på samma sätt i en for-loop. Här stoppar vi loopen så fort vi hittar det första talet som är delbart med 9.

for tal in range(1, 50):
    print(f"Kollar talet: {tal}")

    if tal % 9 == 0:         # första talet som är delbart med 9
        print(f"Hittade ett tal delbart med 9: {tal}")
        break                # avbryt loopen direkt

print("Klar med sökningen!")

Förklaring:

• Loopen testar talen 1–49.
• När den når 9 är villkoret tal % 9 == 0 sant.
• break stoppar loopen direkt – talen efter 9 testas inte.

while True:
    tal = int(input("Ange ett heltal (0 för att avsluta): "))

    if tal == 0:
        print("Du valde att avsluta.")
        break

    print("Du skrev talet:", tal)

print("Programmet är klart.")

for tal in range(1, 101):
    if tal > 50 and tal % 7 == 0:
        print("Första talet som är > 50 och delbart med 7 är:", tal)
        break

print("Sökningen är klar.")

4.2.2 continue – hoppa över ett varv

Ibland vill vi hoppa över delar av koden i en loop, men ändå låta loopen fortsätta med nästa varv. Då använder vi nyckelordet continue.

När Python kör continue:

• hoppar programmet över resten av koden i loopen
• går vidare direkt till nästa varv i loopen

for tal in range(1, 11):
    if tal % 2 != 0:     # om talet är udda
        continue         # hoppa över utskriften
    print(tal)

2
4
6
8
10

Förklaring: När loopen träffar ett udda tal körs continue, och loopen hoppar till nästa tal. Därför skrivs bara jämna tal ut.

text = "programmering"

for bokstav in text:
    # kontrollera om bokstaven finns i strängen med alla vokaler
    if bokstav in "aeiouyåäö":
        continue      # hoppa över vokalerna
    print(bokstav, end="")

prgrmmrng

I tidigare exempel har vi loopat igenom en talserie med range(), men en for-loop kan också gå igenom en sträng ett tecken i taget. I exemplet ovan får variabeln bokstav alltså värdet av nästa tecken varje varv.

Villkoret if bokstav in "aeiouyåäö": kontrollerar om tecknet är en vokal. Uttrycket in används här för att se om ett värde finns i en samling (i detta fall en sträng).

Detta är ett vanligt sätt att filtrera bort vissa värden i en loop, och du kommer använda in ofta när du senare arbetar med olika typer av listor.

tal = 0

while tal < 10:
    if tal % 2 == 0:
        continue      # tal ökar aldrig → oändlig loop!
    tal += 1

tal = 0

while tal < 10:
    tal += 1
    if tal % 2 == 0:
        continue
    print(tal)

for tal in range(1, 31):
    if tal % 3 == 0:
        continue
    print(tal)

text = input("Skriv en mening: ")

for bokstav in text:
    if bokstav == " ":
        continue
    print(bokstav)

4.2.3 Pseudokod för loopar

I Moment03 tränade du på att skriva pseudokod för sekvenser och val (if-satser). Nu ska vi titta på hur pseudokod kan användas för att beskriva iteration, alltså upprepning av kod.

Pseudokod är inte riktig kod – den är ett sätt att beskriva vad programmet ska göra, utan att bry sig om exakt syntax. Den ska vara kort, tydlig och lätt att översätta till Python.

Hur skriver man pseudokod för en loop? En vanlig struktur är:

• Så länge villkor gäller
• gör något
• uppdatera variabler

Eller för ett bestämt antal varv:

• Upprepa antal gånger
• gör något i varje varv

Du behöver inte använda Python-ord som while eller for. Pseudokoden ska beskriva idén, inte syntaxen.

tal = 1

while tal <= 5:
    print(tal)
    tal += 1

Pseudokoden förklarar principen. Python-versionen följer samma logik, men använder riktig kod och korrekta indrag.

for i in range(10):
    print("Varv:", i)

# 1
tal = 0
while tal < 20:
    print(tal)
    tal += 2

# 2
for tal in range(1, 11):
    print(tal, tal * tal)

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

for i in range(1, n + 1):
    if i % 3 == 0:
        print(i, "är delbart med 3")

4.2.4 Vanliga fel i loopar och hur du undviker dem

Loopar är ett av de vanligaste områdena där elever stöter på buggar. I det här avsnittet går vi igenom vanliga misstag och hur du kan felsöka loopar på ett smart sätt.

Vi tittar på körtidsfel (loopen beter sig fel vid körning) och logiska fel (loopen gör något annat än det du tänkt).

4.2.4.1. Oändlig loop (while-loop som aldrig avslutas)

tal = 1

while tal < 10:
    print(tal)
    # tal ökas aldrig!

Vad händer?

Villkoret tal < 10 är alltid sant eftersom tal aldrig uppdateras. Programmet fastnar i loopen för alltid.

tal = 1

while tal < 10:
    print(tal)
    tal += 1

4.2.4.2. continue som låser loopen

tal = 0

while tal < 5:
    if tal % 2 == 0:
        continue      # tal ökas aldrig → oändlig loop
    tal += 1

Förklaring: continue hoppar över tal += 1. Loopen kan inte gå vidare.

tal = 0

while tal < 5:
    tal += 1
    if tal % 2 == 0:
        continue
    print(tal)

4.2.4.3. Loopen körs aldrig (fel villkor)

tal = 10

while tal < 5:
    print(tal)
    tal -= 1

Varför körs den inte?

tal < 5 är redan falskt från början, så loopen hoppar över allt.

4.2.4.4. Felaktig range i en for-loop

Här händer inga “oändliga loopar”, men felaktig range() gör att loopen kör fel antal varv.

for i in range(10, 1):
    print(i)

Detta skriver inte ut något alls, eftersom Python räknar uppåt som standard (steg = 1) och aldrig når stopvärdet.

for i in range(10, 1, -1):
    print(i)

tal = 5
while tal > 0:
    if tal == 3:
        continue
    print(tal)
    tal -= 1

x = 1
while x < 10:
    print(x)

for i in range(5, 0):
    print(i)

# 1 – continue stoppar loopen vid 3
tal = 5
while tal > 0:
    if tal == 3:
        tal -= 1
        continue
    print(tal)
    tal -= 1

# 2 – glömt uppdatera variabeln
x = 1
while x < 10:
    print(x)
    x += 1

# 3 – range med negativt steg
for i in range(5, 0, -1):
    print(i)

i = 10
while i != 0:
    print(i)

for i in range(1, 5, -1):
    print(i)

tal = 3
while tal < 10:
    print(tal)
    if tal == 5:
        break

i = 10
while i != 0:
    print(i)

for i in range(1, 5, -1):
    print(i)

tal = 3
while tal < 10:
    print(tal)
    if tal == 5:
        break

4.2.5 Felhantering i loopar – try/except

När vi använder try/except för att kontrollera inmatning är det vanligast att lägga konstruktionen inuti en yttre loop. Det gör att programmet kan be användaren försöka igen utan att krascha eller avslutas. Samma kod kan köras utan loop, men då finns ingen möjlighet att göra en ny inmatning automatiskt vid fel.

Tidigare har vi sett att våra program kraschar om användaren matar in något som inte går att omvandla till rätt datatyp, t.ex. om vi gör int(input()) och användaren skriver hej. Detta är ett körtidsfel och det kan stoppas med try/except.

try testar att köra en kodrad. Om allt fungerar fortsätter programmet som vanligt. Om ett fel inträffar hoppar Python direkt till except, där vi kan skriva ut ett meddelande och be användaren försöka igen.

while True:
    try:
        tal = int(input("Ange ett heltal: "))
        break   # bara om inmatningen lyckas
    except:
        print("Fel: du måste mata in ett heltal.")
        
print("Du matade in talet", tal)

Förklaring:

• try testar att omvandla inmatningen till ett heltal.
• Om det misslyckas fångas felet av except och loopen fortsätter.
• När användaren till slut skriver ett giltigt tal avbryts loopen med break.

while True:
    try:
        tal = int(input("Ange ett tal mellan 1 och 50: "))
        
        if 1 <= tal <= 50:
            break     # giltigt värde
        else:
            print("Talet måste vara mellan 1 och 50.")
    
    except:
        print("Fel: du måste mata in ett heltal.")

print(f"Du matade in: {tal}")

I detta avsnitt har du lärt dig använda iteration i olika former: for-loopar, while-loopar, nästlade loopar, break, continue och robust inmatning med try/except. Du har tränat både på att skriva kod och på att felsöka loopar. Nu är du redo att arbeta med listor — där iteration är ett av de viktigaste verktygen.

4.3 Listor (list)

Hittills har du mest arbetat med enstaka värden – ett tal, en sträng, en boolesk variabel. Ofta vill man kunna spara många värden som hör ihop, till exempel:

• alla poäng på ett prov
• namnen på eleverna i en klass
• veckans temperaturer

I Python använder vi listor (typen list) för att spara flera värden i samma variabel.

4.3.1 Skapa och läsa listor

En lista skapas med hakparenteser [] och värden separerade med kommatecken.

tom_lista = []
tal = [3, 7, 10, 4]
namn = ["Anna", "Bo", "Celine"]
blandat = [10, "hej", True]

En lista kan innehålla olika datatyper, men i den här kursen kommer vi oftast att ha samma typ av data i en lista (t.ex. bara heltal, eller bara strängar).

4.3.1.1 Index – komma åt ett visst element

Varje värde i en lista har ett index – ett positionsnummer. Python börjar räkna från 0:

• första elementet har index 0
• andra elementet har index 1
• osv…

namn = ["Anna", "Bo", "Celine"]

print(namn[0])   # första namnet
print(namn[1])   # andra namnet
print(namn[2])   # tredje namnet

Anna
Bo
Celine

Du kan också använda negativa index för att räkna baklänges från slutet:

namn = ["Anna", "Bo", "Celine"]

print(namn[-1])   # sista elementet ("Celine")
print(namn[-2])   # näst sista ("Bo")

Celine
Bo

Med funktionen len() får du veta hur många element listan innehåller.

namn = ["Anna", "Bo", "Celine"]
antal = len(namn)

print(f"Listan innehåller {antal} namn")

Listan innehåller 3 namn

namn = ["Anna", "Bo", "Celine", "David"]

print(namn[0])
print(namn[1])
print(namn[-2])

filmer = ["Inception", "Shrek", "Spider-Man"]

print(f"Första filmen: {filmer[0]}")
print(f"Sista filmen: {filmer[-1]}")
print(f"Antal filmer: {len(filmer)}")

namn = ["Anna", "Bo", "Celine", "David", "Elias"]

print(namn[1:3])    # ['Bo', 'Celine']
print(namn[:2])     # ['Anna', 'Bo']
print(namn[3:])     # ['David', 'Elias']
print(namn[-2:])    # ['David', 'Elias']

4.3.2 Ändra listor – append, insert, remove, pop

Till skillnad från strängar är listor förändringsbara (eng. mutable). Du kan lägga till, ta bort och ändra element efter att listan skapats.

4.3.2.1 Byta ut ett element

namn = ["Anna", "Bo", "Celine"]
namn[1] = "Bertil"    # Byt ut värdet i index 1 (andra elementet)

print(namn)

['Anna', 'Bertil', 'Celine']

4.3.2.2 Lägga till element

• append(x) – lägger till x sist i listan
• insert(index, x) – lägger till x på ett visst ställe (och flyttar alla andra element ett steg åt höger)

namn = ["Anna", "Bo"]

namn.append("Celine")       # lägg till sist
namn.insert(1, "David")     # lägg in på plats 1
print(namn)

['Anna', 'David', 'Bo', 'Celine']

4.3.2.3 Ta bort element

• remove(x) – tar bort första förekomsten av värdet x
• pop() – tar bort och returnerar sista elementet
• pop(index) – tar bort och returnerar elementet på en viss plats

namn = ["Anna", "Bo", "Celine", "Bo", "David"]

namn.remove("Bo")      # tar bort första "Bo"
sist = namn.pop()      # tar bort sista elementet
element2 = namn.pop(1) # tar bort andra elementet (index 1) 

print(f"Listan nu: {namn}")
print(f"Tog bort sist: {sist}")
print(f"Tog bort andra: {element2}")

Listan nu: ['Anna', 'Bo', 'Celine']
Tog bort sist: David
Tog bort andra: Bo
  

klass = ["Adam", "Bea", "Carl"]

klass.append("Dina")
klass.insert(1, "Elias")
klass.remove("Carl")

print("Aktuell klasslista:", klass)

tal = [5, 1, 8, 3]

tal.sort()
print("Sorterad lista:", tal)   
# Utskrift: [1, 3, 5, 8]

# sorted() ger en ny lista istället
tal2 = [5, 1, 8, 3]
ny_lista = sorted(tal2)

print("Original:", tal2)
print("Ny sorterad lista:", ny_lista)

tal = [5, 1, 8, 3]

ny_lista = sorted(tal, reverse=True)
tal.sort(reverse=True)

print(tal)       # [8, 5, 3, 1]
print(ny_lista)  # [8, 5, 3, 1]

4.3.3 Loopar + listor

Listor blir som mest användbara när du kombinerar dem med for-loopar. I stället för att räkna med range() kan du loopa direkt över listans innehåll.

namn = ["Anna", "Bo", "Celine"]

for person in namn:
    print("Hej", person)

Här får variabeln person värdet av nästa element i listan varje varv, på samma sätt som du tidigare gått igenom en sträng bokstav för bokstav.

Ibland vill man också ha indexet. Då kan man kombinera range() och len():

poäng = [12, 18, 15]

for i in range(len(poäng)):        # 0, 1, 2
    print(f"Elev {i} fick {poäng[i]} poäng på provet.")

Elev 0 fick 12 poäng
Elev 1 fick 18 poäng
Elev 2 fick 15 poäng
  

Indexet kan sedan användas för att hämta information i en annan lista, kanske skall vi matcha namn och resultat från provet.

elever = ["Anna", "Bo", "Celine"]
poäng = [12, 18, 15]

for i in range(len(elever)):        # 0, 1, 2
    print(f"Elev {elever[i]} fick {poäng[i]} poäng på provet.")

Elev 0: Anna fick 12 poäng
Elev 1: Bo fick 18 poäng
Elev 2: Celine fick 15 poäng

4.3.3.1 Ett smartare sätt: enumerate()

I många situationer vill man både ha index och värde när man loopar över en lista. Det går att göra med range(len(lista)), men Python har ett tydligare och säkrare sätt: enumerate().

Den ger både index och värde automatiskt:

poäng = [12, 18, 15]

for i, värde in enumerate(poäng):
    print(f"Elev {i} fick {värde} poäng")

Elev 0 fick 12 poäng
Elev 1 fick 18 poäng
Elev 2 fick 15 poäng
  

elever = ["Anna", "Bo", "Celine"]
poäng = [12, 18, 15]

for i, namn in enumerate(elever):
    print(f"Elev {i}: {namn} fick {poäng[i]} poäng")

Elev 0: Anna fick 12 poäng
Elev 1: Bo fick 18 poäng
Elev 2: Celine fick 15 poäng

Fördelar med enumerate():

• Koden blir lättare att läsa.
• Du slipper skriva lista[i].
• Mindre risk för indexfel.

Du kommer använda enumerate() i flera kommande uppgifter.

frukter = ["äpple", "banan", "kiwi"]

for i, frukt in enumerate(frukter):
    print(i, frukt)

4.3.3.2 Summera med en loop

I exemplet nedan beräknas först summan och sedan medelvärdet. Både summan och medelvärdet skrivs ut.

poäng = [12, 18, 15, 20]

summa = 0
for p in poäng:
    summa += p

medel = summa / len(poäng)
print(f"Medelpoäng: {medel}")
print(f"Summa: {summa}")

Medelpoäng: 16.25
Summa: 65
  

tal = [3, 5, 8, 2]

# Summa
summa = 0
for x in tal:
    summa += x

# Produkt
produkt = 1
for x in tal:
    produkt *= x

print("Summa:", summa)
print("Produkt:", produkt)

4.3.3.3 Inbyggda funktioner för listor: sum(), min(), max()

Python har färdiga funktioner som kan användas på listor med tal:

• sum(lista) – räknar ut summan
• min(lista) – ger minsta värdet
• max(lista) – ger största värdet

Dessa fungerar när du vill beräkna något på alla värden i listan. Men ibland räcker de inte – till exempel om du bara vill summera de positiva talen, eller de tal som är större än 10. Då behöver du en egen loop.

poäng = [12, 18, 15, 20]

print(sum(poäng))
print(min(poäng))
print(max(poäng))

65
12
20
  

temperaturer = [-2, 0, 3, 5, 1, -1, 4]

temperaturer = [-2, 0, 3, 5, 1, -1, 4]

summa = 0
minsta = temperaturer[0]
största = temperaturer[0]

for t in temperaturer:
    summa += t
    if t < minsta:
        minsta = t
    if t > största:
        största = t

medel = summa / len(temperaturer)

print(f"Summan: {summa}")
print(f"Minsta: {minsta}")
print(f"Största: {största}")
print(f"Medeltemperatur: {medel:.2f}")

Summan: 10
Minsta: -2
Största: 5
Medeltemperatur: 1.43
  

minsta = tal_lista[0]
största = tal_lista[0]

4.3.4 Söka i listor – in och for/else

Ofta vill man veta om ett visst värde finns i en lista, till exempel om ett namn finns i en klasslista. Python har en enkel operator för detta: in.

klass = ["Anna", "Bo", "Celine"]

namn = input("Ange ett namn: ")

if namn in klass:
    print(f"{namn} finns i listan.")
else:
    print(f"{namn} hittades inte.")

Du kan också söka “manuellt” med en loop. I Python finns ett praktiskt mönster där man använder for-loop tillsammans med else för att skilja på hittat och inte hittat.

4.3.3.2 for/else – vad betyder else efter en loop?

I Python kan en for-loop (och även while) ha ett eget else-block. Det fungerar inte som else i en if-sats, utan har en egen betydelse:

else-blocket körs endast om loopen inte avbrutits med break.

• Om loopen hittar det du söker och använder break → else körs inte.
• Om loopen går klart utan att hitta något → else körs.

Detta gör for/else mycket användbart vid sökningar, eftersom du kan skilja på “hittat” och “inte hittat” utan extra variabler.

klass = ["Anna", "Bo", "Celine"]
namn = input("Ange ett namn: ")

for elev in klass:
    if elev == namn:
        print("Hittade", namn)
        break
else:
    # else körs bara om loopen INTE bröts med break
    print(namn, "fanns inte i listan.")

klass = ["Anna", "Bo", "Celine", "David", "Elias"]

namn = input("Ange ett namn att söka efter: ")

if namn in klass:
    print(f"{namn} finns i listan.")
else:
    print(f"{namn} hittades inte.")
  

klass = ["Anna", "Bo", "Celine", "David", "Elias"]

namn = input("Ange ett namn att söka efter: ")

for elev in klass:
    if elev == namn:
        print(f"{namn} finns i listan.")
        break
else:
    print(f"{namn} hittades inte.")
  

4.3.5 Slump och listor

Listor används ofta tillsammans med slumptal, till exempel vid simuleringar, spel, statistik eller sannolikhetsproblem. Python har en inbyggd modul, random, som gör det enkelt att skapa slumptal.

from random import randint

# Skriv ut ett slumpat tal mellan 1 och 100
print(f"Slumpat tal mellan 1 och 100: {randint(1, 100)}")

Vi kan använda randint() för att skapa listor med slumpade tal – till exempel provresultat, tärningskast eller simuleringar.

from random import randint

slumpade_tal = []

for _ in range(10):
    slumpade_tal.append(randint(1, 6))

print(slumpade_tal)

I koden ovan använder vi _ som loopvariabel när värdet inte behövs.

from random import randint

antal = int(input("Hur många slumptal vill du skapa? "))

tal_lista = []
for _ in range(antal):
    tal_lista.append(randint(1, 20))

print(f"Listan: {tal_lista}")

större_än_tio = 0
for tal in tal_lista:
    if tal > 10:
        större_än_tio += 1

print(f"Antal tal större än 10: {större_än_tio}")

Listan: [3, 17, 12, 5, 19]
Antal tal större än 10: 3
  

from random import randint

slumptal = []
for _ in range(20):
    slumptal.append(randint(1, 5))

print("Listan:", slumptal)

räkning = [0, 0, 0, 0, 0]   # index 0 svarar för talet 1 osv

for tal in slumptal:
    räkning[tal - 1] += 1

for i, antal in enumerate(räkning, start=1):
    print(f"Antal {i}: {antal}")

Listan: [2, 5, 1, 3, 3, 1, 4, 2, 5, 5, 1, 4, 2, 5, 3, 3, 1, 2, 4, 5]
Antal 1: 4
Antal 2: 4
Antal 3: 4
Antal 4: 4
Antal 5: 4

4.3.3.4 Ett enklare sätt att räkna förekomster: list.count(x)

I förra övningen räknade du själv hur många gånger varje värde förekom i listan. Det är bra träning, men Python har också en färdig funktion som kan räkna åt dig:

lista.count(x) – returnerar hur många gånger värdet x förekommer i listan.

tal = [1, 2, 3, 2, 2, 4]

print(tal.count(2))   # hur många tvåor finns det?
print(tal.count(5))   # hur många femmor?
  

3
0
  

Detta är ett mycket enkelt och effektivt sätt att kontrollera ett värdes förekomst i en lista. I större projekt kommer du ofta använda count() för snabba kontroller, men det är viktigt att du förstår hur du själv kan räkna med loopar, vilket du tränade i 4.3i.

for i in range(1, 6):
    print("Egen räkning:", räkning[i-1])
    print("Med count():", slumptal.count(i))
      

Nu har du två olika verktyg: ett manuellt (loopar) och ett automatiskt (count()). Båda är viktiga — i olika situationer.

from random import randint

# Slumpa ett tärningskast
kast = randint(1, 6)
print("Du slog:", kast)

4.3.6 Listor i listor (listor av rader och kolumner)

En lista kan också innehålla andra listor. Det är ett vanligt sätt att representera tabeller, spelplaner eller matriser.

tabell = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print(tabell[0][0])   # första raden, första kolumnen → 1
print(tabell[1][2])   # andra raden, tredje kolumnen → 6

För att skriva ut hela tabellen kan du använda en nästlad loop, precis som i avsnittet om nästlade iterationer.

tabell = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

for rad in tabell:
    for värde in rad:
        print(värde, end=" ")
    print()      # radbrytning efter varje rad

elever = [
    ["Anna", 15, 18],
    ["Bo", 12, 14],
    ["Celine", 20, 19]
]

for elev in elever:
    namn = elev[0]
    total = elev[1] + elev[2]
    print(f"{namn} fick totalt {total} poäng")

4.4 Set (set)

Ibland vill vi samla värden utan att få dubbletter. Till exempel:

• vilka elever som har lämnat in (unika namn)
• vilka ord som förekommer i en text (unika ord)
• vilka tärningsvärden som kom upp (1–6 utan dubbletter)

Då passar datatypen set.

4.4.1 Skapa set

Du kan skapa set på två vanliga sätt:

• med { } när du redan har värden
• med set(lista) när du vill ta bort dubbletter från en lista

# 1) Skapa set direkt
frukter = {"äpple", "banan", "kiwi"}
print(frukter)                      # {'kiwi', 'äpple', 'banan'}

# 2) Skapa set från en lista (tar bort dubbletter)
tal = [1, 2, 3, 3, 4, 3, 2]
unika_tal = set(tal)

print("Original lista:", tal)       # Original lista: [1, 2, 3, 3, 4, 3, 2]
print("Unika tal:", unika_tal)      # Unika tal: {1, 2, 3, 4}

4.4.2 Lägga till och ta bort

Tre vanliga metoder är:

• add(x) – lägger till ett värde
• remove(x) – tar bort ett värde och ger fel om värdet saknas. Används när programmet förväntar sig att värdet ska finnas.
• discard(x) - ger inget fel om värdet saknas och används när det är okej att värdet kanske inte finns.

namn = {"Anna", "Bo"}

namn.add("Celine")
print(namn)           # {'Bo', 'Anna', 'Celine'}

namn.remove("Bo")
print(namn)           # {'Anna', 'Celine'}

namn.discard("Bo")    # Tar bort Bo om det finns, inga error.
print(namn)           # {'Anna', 'Celine'}

4.4.3 Loopar + set

Du kan loopa igenom ett set precis som en lista, men kom ihåg att ordningen inte är garanterad.

unika = {3, 7, 2, 7, 3}

for tal in unika:
    print(tal)

När du kör koden ovan blir utskriften:

2
3
7

Nu har vi kikat på flera olika exempel och vi har sagt att set inte sorteras. Men känslan är att ett set som innehåller tal ofta är sorterade. Att ett set av tal ser sorterat ut är bara en bieffekt av hur Python råkar lagra talen i minnet, vi kan dock inte garantera att de alltid är sorterade.

namn = {"Anna", "Celine", "Bosse", "Anna", "David"}
print(namn)

for n in sorted(namn):
    print(n)

När du kör koden ovan blir utskriften:

{'Anna', 'David', 'Bosse', 'Celine'}
Anna
Bosse
Celine
David

tal = [1, 2, 2, 3, 3, 3, 4]
unika = set(tal)

print("Unika tal:", unika)
print("Antal unika:", len(unika))

unika_namn = set()

while True:
    namn = input("Skriv ett namn (stop för att avsluta): ")

    if namn == "stop":
        break

    unika_namn.add(namn)

print("Unika namn:", unika_namn)
print("Antal unika namn:", len(unika_namn))

4.5 Tuple (tuple)

En tuple liknar en lista, men med en avgörande skillnad: innehållet kan inte ändras efter att den skapats.

Tuple används när flera värden hör ihop och ska behandlas som ett fast paket, till exempel:

• koordinater (x, y)
• fasta inställningar
• poster som representerar en rad data

4.5.1 Skapa tuples

En tuple skapas med parenteser () eller genom att skriva värden separerade med kommatecken.

# Med parenteser
punkt = (3, 7)

# Utan parenteser
färg = "röd", "grön", "blå"

print(punkt)              # (3, 7)
print(färg)               # ('röd', 'grön', 'blå')

4.5.1.1 Tuple med ett värde (komma)

När du skapar en tuple med ett enda värde finns det en vanlig fälla som är viktig att känna till.

Det är kommat, inte parenteserna, som gör att Python tolkar värdet som en tuple.

t1 = (5)
t2 = (5,)

print(type(t1))  # <class 'int'>
print(type(t2))  # <class 'tuple'>

I exemplet ovan är t1 inte en tuple, utan bara talet 5. För att skapa en tuple med ett enda värde måste du skriva ett komma.

en_tuppel = ("hej",)
en_till = (True,)

print(en_tuppel)
print(en_till)

Detta är extra viktigt när du:

• skapar tuple-värden dynamiskt
• arbetar med unpacking (kommer i 4.5.4)
• skickar tuple-värden vidare i programmet

a = (10)
b = (10,)

print(type(a))
print(type(b))

4.5.2 Läsa värden ur tuple

Precis som listor använder tuple index.

punkt = (3, 7)

print(punkt[0])   # 3 (x-koordinat)
print(punkt[1])   # 7 (y-koordinat)

Men du kan inte ändra värden:

punkt = (3, 7)

# Detta ger fel:
# punkt[0] = 10
# Felkoden blir: TypeError: 'tuple' object does not support item assignment

4.5.3 Tuple – användbara funktioner

En tuple fungerar ungefär som en lista, men den är oföränderlig. Det betyder att du inte kan lägga till, ta bort eller ändra värden i en tuple.

Tuple har färre funktioner än list, eftersom den är tänkt att vara ett fast paket, men det finns två som är särskilt användbara:

• count(x) – räknar hur många gånger ett värde förekommer
• index(x) – ger index (position) för första förekomsten

weekdays = ("måndag", "tisdag", "onsdag", "torsdag", "fredag", "lördag", "söndag")

# count(): hur många gånger finns ett värde?
print(weekdays.count("tisdag"))  # 1

# index(): vilket index har värdet (första förekomsten)?
print(weekdays.index("torsdag"))  # 3

weekdays = ("måndag", "tisdag", "onsdag")

# Detta ger ett fel om värdet inte finns:
# print(weekdays.index("fredag"))  # ValueError

Om du vill undvika att programmet kraschar kan du först kontrollera om värdet finns i tuplen med in:

weekdays = ("måndag", "tisdag", "onsdag")

sok = input("Vilken dag söker du? ")

if sok in weekdays:
    print("Index:", weekdays.index(sok))
else:
    print("Dagen finns inte i tuplen.")

farger = ("röd", "blå", "grön", "blå", "gul", "blå")

print("Antal blå:", farger.count("blå"))
print("Första blå har index:", farger.index("blå"))

# Testa detta (ger fel):
# print(farger.index("svart"))

4.5.4 Tuple unpacking

Ett vanligt och mycket praktiskt sätt att använda tuple är unpacking.

punkt = (3, 7)

x, y = punkt

print("x =", x)     # x = 3
print("y =", y)     # y = 7

Detta används ofta tillsammans med funktioner (kommer i senare moment) som returnerar flera värden.

punkt = (5, 9)

x, y = punkt

print("x =", x)
print("y =", y)

4.5.5 Loopar + tuple

Du kan loopa över en tuple på samma sätt som en lista.

färger = ("röd", "grön", "blå")

for färg in färger:
    print(färg)

temperaturer = (18, 21, 19)

for t in temperaturer:
    print(t)

4.6 Dictionaries (dict)

Hittills har du oftast sparat data som en lista. I en lista hittar du värden med index (platsnummer). Men ibland vill du istället kunna slå upp ett värde med ett namn eller en nyckel.

Ett dictionary (typen dict) fungerar som en uppslagstabell:

• nyckel → värde
• Nycklar är unika (du kan inte ha samma nyckel två gånger).
• Du hittar värden genom att skriva dict[nyckel] (istället för lista[index]).

Tänk på ett dictionary som en telefonbok eller ett elevregister: du letar inte på “plats 3”, du letar på ett namn.

# Lista: värden hör ihop genom sin position
farger = ["röd", "grön", "blå"]
koder = ["#ff0000","#00ff00", "#0000ff"]

print(farger[0], koder[0])  # röd #ff0000
print(farger[2], koder[2])  # blå #0000ff


# Dictionary: värden hör ihop genom en nyckel
fargkoder = {
  "röd": "#ff0000",
  "grön": "#00ff00",
  "blå": "#0000ff"
}

print(fargkoder["röd"])   # #ff0000
print(fargkoder["blå"])  # #0000ff

I exemplet ovan är nycklarna färgens namn och värdena är färgkoden som bl.a. används vid webbutveckling. Det gör att vi kan slå upp en färgkod direkt, utan att veta vilket index färgen har.

tom_dict = {}      # detta är en tom dict

# Ett tomt set skapas med set()
tomt_set = set()

dict_one = {"Anna":12}      # Ett index och värde i
set_one = {"Anna"}          # Ett värde i set

prislista = {
    "mjölk": 18,
    "bröd": 25,
    "banan": 4
}

print("Bröd kostar:", prislista["bröd"], "kr")

poang = {
    "Anna": 15,
    "Bo": 18,
    "Celine": 20
}

print("Bo fick:", poang["Bo"], "poäng")

# Om du försöker med en nyckel som inte finns:
# print(poang["David"])  # ger fel (KeyError)

4.6.1 Skapa, läsa och ändra värden

Ett dictionary kan både skapas, läsas och ändras efteråt. Du kan alltså lägga till nya nycklar, uppdatera värden och ta reda på om en nyckel finns.

• dict[nyckel] – läs ett värde (om nyckeln finns)
• dict[nyckel] = värde – lägg till ny nyckel eller ändra befintlig
• nyckel in dict – kontrollera om nyckeln finns

huvudstäder = {
  "Sverige": "Stockholm",
  "Norge": "Oslo"
}

# Läs ett värde
print("Sveriges huvudstad är:", huvudstäder["Sverige"])

# Ändra ett värde
huvudstäder["Norge"] = "Bergen"
print("Norges huvudstad är nu:", huvudstäder["Norge"])

# Lägg till en ny nyckel
huvudstäder["Danmark"] = "Köpenhamn"

print(huvudstäder)    # {'Sverige': 'Stockholm', 'Norge': 'Bergen', 'Danmark': 'Köpenhamn'}

När du skriver huvudstäder["Norge"] = "Bergen" så spelar det ingen roll om nyckeln redan finns:

• Om nyckeln finns → värdet uppdateras.
• Om nyckeln inte finns → en ny post läggs till.

huvudstäder = {
  "Sverige": "Stockholm",
  "Norge": "Oslo",
  "Danmark": "Köpenhamn"
}

land = input("Ange ett land: ")

if land in huvudstäder:
    print(f"{land}s huvudstad är {huvudstäder[land]}")
else:
    print("Landet finns inte i listan.")

I koden ovan använder vi in för att undvika att programmet kraschar. Om du försöker läsa en nyckel som inte finns får du annars felet KeyError.

kurser = {
    "Matematik": 100,
    "Svenska": 100,
    "Engelska": 100
}

# Del A: uppdatera eller lägga till
kurs = input("Ange kurs: ")
poang = int(input("Ange poäng: "))

kurser[kurs] = poang

print("\nAlla kurser:")
print(kurser)       # {'Matematik': 100, 'Svenska': 100, 'Engelska': 100, 'Programmering': 100}

# Del B: slå upp kurs
sok = input("\nVilken kurs vill du slå upp? ")

if sok in kurser:
    print(f"{sok} har {kurser[sok]} poäng")
else:
    print("Kursen finns inte i listan.")

4.6.2 Loopar + dictionary

Ett dictionary används väldigt ofta tillsammans med loopar. Till skillnad från listor finns det inga index, men istället kan du loopa över:

• nycklar
• värden
• nyckel + värde samtidigt

Vilket du väljer beror på vad du behöver göra i loopen.

kontakter = {
    "Anna": "anna@gmail.com",
    "Bo": "bo@hotmail.com",
    "Celine": "celine@skola.se"
}

for namn in kontakter:
    print(namn)

Anna
Bo
Celine

När du loopar direkt över ett dictionary får loopvariabeln nycklarna.

for email in kontakter.values():
    print(email)

anna@gmail.com
bo@hotmail.com
celine@skola.se

Här används values() för att bara få fram värdena.

for namn, email in kontakter.items():
    print(namn, "har e-postadressen", email)

Anna har e-postadressen anna@gmail.com
Bo har e-postadressen bo@hotmail.com
Celine har e-postadressen celine@skola.se

Metoden items() ger både nyckel och värde samtidigt. Det är det vanligaste sättet att skriva ut innehållet i ett dictionary.

poang = { "Anna": 15, "Bo": 18, "Celine": 20 } 
print("Namn:")

for namn in poang:
    print(namn) 

print("\nPoäng:") 
for p in poang.values(): 
    print(p) 
    
print("\nNamn och poäng:") 
for namn, p in poang.items():
    print(namn, ":", p)

Namn (Enter för att avsluta): Anna
Resultat: 15
Namn (Enter för att avsluta): Bo
Resultat: 18
Namn (Enter för att avsluta): Celine
Resultat: 20
Namn (Enter för att avsluta):
 
Summa: 53
Medel: 17.67
 
Över medel:
Bo - 18
Celine - 20
 
Antal över medel: 2

4.6.3 Räkna förekomster med dictionary

Ett mycket vanligt användningsområde för dictionary är att räkna hur ofta något förekommer. Det kan till exempel vara:

• betyg
• ord
• svarsalternativ

Mönstret är alltid detsamma:

• om nyckeln redan finns → öka värdet
• om nyckeln inte finns → skapa den med startvärde 1

betyg = ["A", "C", "B", "A", "C", "A"]

antal = {}

for b in betyg:
    if b in antal:
        antal[b] += 1
    else:
        antal[b] = 1

print(antal)

{'A': 3, 'C': 2, 'B': 1}

I exemplet ovan är:

• nyckeln = betyget
• värdet = hur många gånger betyget förekommer

svar = ["ja", "nej", "ja", "vet ej", "ja"]

antal = {}

for s in svar:
    if s in antal:
        antal[s] += 1
    else:
        antal[s] = 1

print(antal)

4.6.4 Dictionary som register

Ett annat vanligt användningsområde för dictionary är att använda det som ett register: du slår upp en nyckel och får tillbaka ett värde.

• nyckel → t.ex. ett användarnamn
• värde → t.ex. ett namn, ett telefonnummer eller en klass

telefonbok = {
    "Anna": "070-111 22 33",
    "Bo": "070-444 55 66",
    "Celine": "070-777 88 99"
}

print(telefonbok["Anna"])      # slår upp värdet via nyckeln

070-111 22 33

Om du försöker slå upp en nyckel som inte finns får du ett fel (KeyError). Därför är det vanligt att först kontrollera om nyckeln finns.

namn = "David"

if namn in telefonbok:
    print(telefonbok[namn])
else:
    print("Finns inte i telefonboken.")

I ett register kan du också lägga till, ändra och ta bort.

telefonbok = {}

# lägga till
telefonbok["Anna"] = "070-111 22 33"

# ändra (samma syntax!)
telefonbok["Anna"] = "070-000 00 00"

# ta bort
del telefonbok["Anna"]

print(telefonbok)

elev = {
    "Alva": "TE23",
    "Nils": "NA22",
    "Sara": "SA21"
}

# 1) uppslag
print(elev["Alva"])

# 2) fråga användaren
namn = input("Ange elevens namn: ")

if namn in elev:
    print(f"{namn} går i {elev[namn]}")
else:
    print("Eleven finns inte i registret.")

# 3) lägga till
nytt_namn = input("Ny elev: ")
ny_klass = input("Klass: ")
elev[nytt_namn] = ny_klass

print(elev)

Namn (Enter för att avsluta): Anna
Klass: 25NAa
Namn (Enter för att avsluta): Bo
Klass: 25NAb
Namn (Enter för att avsluta): Cilla
Klass: 25NAa
Namn (Enter för att avsluta): 
 
Klassregister:
Anna - 25NAa
Bo - 25NAb
Cilla - 25NAa
 
Sök efter elev: Bo
Bo går i 25NAb
 
Tog bort Anna ur registret.
 
Antal elever per klass:
25NAb: 1
25NAa: 1

4.6.5 List of dicts

Ibland räcker det inte med ett enda dictionary. Ofta vill du lagra flera poster, där varje post innehåller flera värden.

En vanlig lösning är då att använda en lista med dictionaries (på engelska: list of dicts).

Varje dictionary i listan representerar en post, till exempel en elev, en användare eller en film.

elever = [
    {"namn": "Anna", "klass": "TE23", "poang": 18},
    {"namn": "Bo", "klass": "NA22", "poang": 15},
    {"namn": "Celine", "klass": "TE23", "poang": 20}
]

För att arbeta med datan loopar du över listan. Varje varv i loopen är då ett dictionary.

for elev in elever:
    print(elev["namn"], "-", elev["klass"], "-", elev["poang"])

Anna - TE23 - 18
Bo - NA22 - 15
Celine - TE23 - 20

Du kan också använda villkor för att filtrera poster.

for elev in elever:
    if elev["poang"] >= 18:
        print(elev["namn"], "har", elev["poang"], "poäng")

Anna - TE23 - 18
Celine - TE23 - 20

varor = [
    {"namn": "Banan", "pris": 6, "antal": 12},
    {"namn": "Choklad", "pris": 20, "antal": 0},
    {"namn": "Läsk", "pris": 18, "antal": 7},
    {"namn": "Tuggummi", "pris": 10, "antal": 0}
]

print("Alla varor:")
for vara in varor:
    print(f'{vara["namn"]} - {vara["pris"]} kr ({vara["antal"]} st)')

totalvarde = 0
for vara in varor:
    totalvarde += vara["pris"] * vara["antal"]

print("\nTotalt lagervärde:", totalvarde, "kr")

print("\nSlut i lager:")
for vara in varor:
    if vara["antal"] == 0:
        print("-", vara["namn"])

4.6.6 En cheat sheet på datastrukturer

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

4.7.1 Checklista inför diagnosen

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