4. Moment04 - Iterationer och listor

Det finns flera olika strukturer när vi skapar iterationer inom programmeringen, de är bra på olika saker så för att få den mest effektiva koden behöver du kunna använda flera olika typer. När det gäller Python så finns det två olika typer av iterationer som vi behöver kunna.

4.1 for-loopen

For-loopen är den mest styrda loopen, här ligger fokus på att en operation genomförs x antal gånger. Vi börjar med ett exempel.

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

for-kommandot innebär att det är en for-loop vi vill köra. i får värdet som iteratorn (räknaren) har i varje varv. Och in range (5) innebär att vi skall räkna från början, vilket är 0 eftersom det lägsta talet inom programmering är 0, och köra vår loop 5 gånger. För bättre tydlighet skulle vi kunna skriva koden på följande sätt;

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

Alltså: Kör en loop, börja med att i får värdet 0 och kör loopen 5 gånger (egentligen kör mot 5 men stannar innan 5 körs). Utskrifterna skulle i bägge fallen bli.

0
1
2
3
4

Att kunna utföra en viss operation flera gånger är något som ofta används inom programmeringen. Just nu kör vi en loop ganska få gånger men vid statistiska beräkningar så kan loopen bestå av enormt stora datamängder. Vi skall senare kika lite på hur vi kan loopa igenom en lista istället för att följa en talserie.

Men om vi nu vill följa en dataserie men inte använda alla tal i vår beräkning så kan vi på ett enkelt sätt ta större steg än 1 i vår loop.

for i in range (0, 15, 3):
    print(i)

Utskriften blir då.

0
3
6
9
12

När vi kör vår for-loop så finns det ett kommando som körs när loopen har kört färdigt och innan skriptet fortsätter utanför loopen och det är kommandot else. OBS: Blanda nu inte ihop det med else som används vid selektioner.

summa = 0
for i in range (0, 15, 3):
    print(i)
    summa += i
else:
    print("Summan av alla talen är", summa)

Utskriften blir då.

0
3
6
9
12
Summan av alla talen är 30

I detta fallet så hade vi fått samma resultat och utskrift om vi hade skrivit koden på följande sätt;

summa = 0
for i in range (0, 15, 3):
    print(i)
    summa += i

print("Summan av alla talen är", summa)

Återigen ett exempel på hur vi kan skriva kod på olika sätt för att få fram samma resultat. Lägg här märke till rad 6 där koden inte har någon indentering och därför inte tillhör loopen. Det finns tillfällen då else är extra intressant och det kikar vi på senare.

Vi har sett att det finns tre olika parametrar till vår for-loop och hittills har vi bara räknat uppåt. Det går naturligtvis också att räkna nedåt, det viktigaste då är att vi ser till att vi har ett korrekt startvärde och slutvärde så att det går att loopa mellan dessa tal. Går det inte att loopa så kommer inte loopen att köras.

summa = 0
for i in range (10, 3, -3):
    print(i)
    summa += i

print("Summan av alla talen är", summa)

Vi kör vår loop från talet 10 till talet 3 där varje steg minskas med 3. Utskriften blir då.

10
7
4
Summan av alla talen är 21

Testa vad som händer om du byter plats på parameter 1 och 2 eller gör parameter 3 till positiv.

4.1.1 Nästlade iterationer

Vi har tidigare kikat på hur vi kan nästla selektioner vilket innebär en, eller flera, selektioner i en annan selektion. På samma sätt kan vi göra med kontrollstrukturen iterationer. Vi kan dessutom blanda hur vi vill nästla selektioner och iterationer, allt beror på uppgiften vi skall lösa.

Här kommer ett exempel på hur man kan nästla iterationer.

# 6:an & 7:ans multiplikationstabeller
# Den yttre loopen tar hand om första talet, 6:ans tabell, 7:ans tabell
for i in range(6, 8):
    # Den inre loopen tar hand om alla tal mellan 0 och 10
    for j in range(0, 11):
        print(f"{i} * {j} = {i*j}")

    print()     # Skapar tomrad mellan de olika "tabellerna"

Det som behöver fokuseras främst på är kommenterat i koden ovan. Utskriften av programmet kommer här.

6 * 0 = 0
6 * 1 = 6
6 * 2 = 12
6 * 3 = 18

//
// bortklippta rader
//

7 * 8 = 56
7 * 9 = 63
7 * 10 = 70

På samma sätt som vi kan ha en iteration inne i en annan iteration så kan vi naturligtvis ocksp ha en selektion inne i en iteration.

Här kommer ett exempel på en selektion i en iteration där vi loopar från 10 till 20 men istället för att ta tre steg så väljer vi att skriva ut vart tredje tal med summan som alla tal skapar. Om vi kör tre steg i loopen så missar vi ju att summera de tal som inte stegas igenom vilket gör att resultatet blir felaktigt.

# Deklarerar variabler
summa = 0
start = 10
stopp = 20
print(f"\nVi loopar från {start} till {stopp}.")
# Loopar från start till stopp
for i in range (start, stopp+1):
    summa += i
    # Om i är jämnt delbart med 3 skriver vi ut en delberäkning
    if i % 3 == 0:
        print(f"När i är {i} så är totalsumman {summa}")
# else som tillhör loopen och körs när loopen har körts färdigt
else:
    print(f"När vi loopat färdigt så är summan {summa}")

Det som behöver fokuseras främst på är kommenterat i koden ovan. Utskriften av programmet kommer här.

Vi loopar från 10 till 20.
När i är 12 så är totalsumman 33
När i är 15 så är totalsumman 75
När i är 18 så är totalsumman 126
När vi loopat färdigt så är summan 165

Multiplikationstabell
   1   2   3   4   5   6   7   8   9  10
   2   4   6   8  10  12  14  16  18  20
   3   6   9  12  15  18  21  24  27  30
   4   8  12  16  20  24  28  32  36  40
   5  10  15  20  25  30  35  40  45  50
   6  12  18  24  30  36  42  48  54  60
   7  14  21  28  35  42  49  56  63  70
   8  16  24  32  40  48  56  64  72  80
   9  18  27  36  45  54  63  72  81  90
  10  20  30  40  50  60  70  80  90 100

4.1.2 Iteration som testmetod

En iteration kan ofta kan vara ett bra sätt att använda när vi kör tester på våra program. Vi skall kika på hur vi kan testa en uppgift som vi jobbade med i moment03. Uppgiften M03U04 handlade om att vi skulle hämta ett klockslag från datorn och sedan jämföra värdet på timmen för att se om det är före skoldag, efter skoldag eller om skoldagen pågår. Genom att skapa en iteration från 0 till 23 så är det lätt att se om vårt program fungerar som det är tänkt.

# Loopar från klockan 0 till 23
for timme in range(0, 24):
    # Skriver ut vad klockan är men utan radbrytning
    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.")

Utskriften blir då.

Klockan är 0, skoldagen har inte börjat.
Klockan är 1, skoldagen har inte börjat.
// bortklippt //
Klockan är 7, skoldagen har inte börjat.
Klockan är 8, skoldagen pågår
// bortklippt //
Klockan är 16, skoldagen pågår
Klockan är 17, skoldagen är slut.
// bortklippt //
Klockan är 22, skoldagen är slut.
Klockan är 23, skoldagen är slut.

Den största fördelen här är att det nu är möjligt att testa hela applikationen utan att göra en manuell inmatning 24 ggr. Dessutom är det enkelt att testa de gränser som är intressanta för oss. I exemplet ovan så är det ju timvärden 7, 8, 16, 17 som vi är mest intresserade av att testa.

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-loopen

Den andra typen av loop som vi skall gå igenom är while-loopen. Här är det villkoret som är det styrande för hur länge loopen skall köras.

tal = 1

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

I exemplet så ser vi att uttrycket är tal < 5 och så länge detta gäller så kommer loopen att köras ett varv till. När vi jobbar med while-loopen så måste vi se till att det värde som finns i uttrycket måste förändras, vilket sker på rad 5, annars kommer loopen att bli oändlig. Utskriften i vårt exempel blir då.

1
2
3
4

Svårare än så är inte while-loopen och det viktigaste är att hålla koll på uttrycket eftersom det avgör om loopen skall köras en gång till. På samma sätt kan vi använda else för att göra något när villkoret inte längre ger värdet True och loopen avbryts.

tal = 1

while tal < 5:
    print(tal)
    tal += 1
else:
    print(f"När vi har loopat klart så har tal värdet {tal}")

1
2
3
4
När vi har loopat klart så har tal värdet 5

Använd else när det behövs.

4.2.1 Continue

Ibland kan det vara så att vi vill använda en loop men av någon anledning inte genomföra en viss process ifall något uttryck gäller. Då kan vi använda kommandot continue som kommer hoppa över allt som kommer efter det kommandot i loopen och börja om loopen igen. Ett exempel;

tal = 0
while tal < 10:                 # kör så länge tal är mindre än 10
    tal += 1                    # öka tal med 1
    if tal % 2 == 0:            # om tal är jämnt delbart med 2 ..
      continue                  # .. starta om loopen
    print("Talet är", tal)     # skriv ut talet

print("Utanför loopen")

Talet är 1
Talet är 3
Talet är 5
Talet är 7
Talet är 9
Utanför loopen

Continue kan användas i både for-loopar och while-loopar.

Det finns ingen specifik uppgift för continue utan det kommer en efter avsnitt 4.2.2.

4.2.2 Break

Kommandot break används på liknande sätt som continue fast istället för att börja om på nästa varv i loopen så avbryts loopen och programmet fortsätter efter loopen. Samma exempel som för continue fast med break.

tal = 0
while tal < 10:                 # kör så länge tal är mindre än 10
    tal += 1                    # öka tal med 1
    if tal % 2 == 0:            # om tal är jämnt delbart med 2 ..
      break                     # .. avbryt loopen
    print("Talet är", tal)     # skriv ut talet

print("Utanför loopen")

Talet är 1
Utanför loopen

4.2.3 Pseduokod för loopar

I förra momentet lärde vi oss att skriva pseudokod i sekvens och selektion. Nu har det blivit dags att lägga till iterationer (loopar). Egentligen är det uttrycket vi är intresserade av och sedan visar vi att det är en loop med hjälp av pilar. Jag visar med ett exempel och det är kodexempel: continue ovan som jag kommer använda som exempel.

Om vi skall skriva pseudokod för samma uppgift så kan den se ut så här.

• Ge tal värdet 0
• Om tal är mindre än 10
• Öka talet med 1
• Om tal inte är jämnt delbart med 2
• Skriv ut talet
• Annars kör ett varv till
• Annars skriv ut att vi är utanför loopen

Den pseudokoden är väldigt lik kodexemplet, vilket den lätt blir om vi kodar först och skall skapa pseduokod efteråt. Om vi istället fokuserar på uppgiften och lösningen istället för koden så kanske pseduokoden ser ut så här.

• Loopa igenom alla tal från 1 till 10
• Om talet inte är jämnt delbart med 2
• Skriv ut talet
• Skriv ut att vi är utanför loopen

Här ser du två exempel på att vi kan skriva pseduokoden på lite olika sätt men ändå lösa samma uppgift. Det viktigaste är att du hittar ett sätt att lösa uppgiften.

4.2.4 Felhantering, körtidsfel

Tidigare har vi pratat om att syntaxfel är de fel som vi skriver i koden som gör att våra skript inte går att köra utan ger ett, eller flera, fel när vi försöker köra applikationen.

Nästa feltyp vi behöver lära oss ta hand om är körtidsfel och de är fel som kraschar en applikation medan den körs. Vi har stött på detta när vi matar in någonting annat än vad vår applikation förväntar sig. Ofta blir det fel när vi skall mata in ett heltal och matar in någonting som inte kan konverteras till ett heltal.

Det som löser detta problem för oss är en kontrollstruktur som egentligen är en variant av selektion och som passar väldigt bra ihop med iterationer. Strukturen är en try-except (try-catch i många andra programmeringsspråk) och den provar att göra någonting, om det fungerar så är allt frid och fröjd och applikationen kan fortsätta, fungerar det inte så har vi möjlighet att skriva kod som talar om vad vi vill skall hända då. En felaktig inmatning, eller en felaktig inläsning från en fil, gör ju att vår applikation kraschar lite senare och det vill vi ju inte, då är det bättre att ta kontroll på inmatningen så att den går rätt till. Vi kör ett exempel.

# loopen kommer "alltid" köras eftersom uttrycket är True
while True:
    try:        # detta block är det som testas, blir det fel här...
        tal = int(input("Ange ett heltal: "))
        break   # avbryter loopen
    except:     # ... hamnar vi här istället
        print("Det blev fel, försök igen")
# Utanför loopen sker utskriften
print(f"Det korrekt inmatade talet är {tal}")

Ange ett heltal: tre
Det blev fel, försök igen
Ange ett heltal: 3.2
Det blev fel, försök igen
Ange ett heltal: 3,2
Det blev fel, försök igen
Ange ett heltal: 3
Det korrekt inmatade talet är 3

Koden och kommentarerna borde räcka för att förklara vad som händer. Detta är ett smidigt sätt att undvika krascher i våra applikationer.

4.3 Listtyper

Olika typer av listor är vanliga i de flesta programmeringsspråk. Orsaken till detta är att vi ofta behöver bearbeta en stor mängd data och då är det inte praktiskt att skapa variabler för all denna data. Tänk att en klass har genomfört ett prov och du nu skall göra ett antal beräkningar av denna data. Då är det inte vettigt att skapa en variabel för varje resultat; res1 = 14, res2 = 19 osv. För detta ändamål används någon form av lista. I python har vi fyra olika listtyper; list, tuple, set och dictionary. Det är främst de två första som vi kommer kika på och det är list som vi kommer lägga mest tid på att använda.

4.3.1 List

En lista kan du se som en variabel med flera fack (element), i varje element kan det lagras ett värde. Om vi går tillbaka till exemplet om att samla provresultat så kommer varje resultat hamna i var sitt element i den listan som du har skapat. I de flesta listtyper kommer varje element ha ett id som gör att vi kan hålla ordning på i vilket element ett visst värde finns.

4.3.1.1 Skapa

Att skapa en lista är enkelt, du skapar en variabel men anger värden med hjälp av klammer och separerar värden med kommatecken.

resultat = [12, 19, 22, 4, 0]

4.3.1.2 Skriv ut hela

Om vi vill skriva ut vår lista så går det att skriva ut variabelns värde vilket kommer se ut på precis samma sätt som vi skrev in den.

resultat = [12, 19, 22, 4, 0]
print(resultat)

[12, 19, 22, 4, 0]

Det går också att skriva ut varje element för sig genom att loopa igenom listan.

resultat = [12, 19, 22, 4, 0]

# Loopar igenom resultat med en for-loop
for r in resultat:    # Låt r lagra nästa element i listan resultat
    print(r)

12
19
22
4
0

Det är också möjligt att lagra olika datatyper i en list.

data = [21, "Programmering01", [2, 3, 4, 5], False, 3.14]
print("Skriv ut innehållet:", data)
print("\nSkriv ut datatyperna i listan")
for d in data:
    print(d, "är av typen", type(d))

Skriv ut innehållet: [21, 'Programmering01', [2, 3, 4, 5], False, 3.14]

Skriv ut datatyperna i listan
21 är av typen <class 'int'>
Programmering01 är av typen <class 'str'>
[2, 3, 4, 5] är av typen <class 'list'>
False är av typen <class 'bool'>
3.14 är av typen <class 'float'>

4.3.1.3 Enskilt element

För att kunna anropa ett enskilt element i en lista så behöver dessa identifieras på något sätt. I en list så identifieras de med ett index och det kan vi använda om vi vill skriva ut ett särskilt värde. Indexen i en list börjar numreras från 0.

cities = ["Göteborg", "Alingsås", "Borås"]
print("Pelle bor i", cities[1])
cities[1] = "Vårgårda"
print(cities)

Pelle bor i Alingsås
['Göteborg', 'Vårgårda', 'Borås']

Ibland kan det vara bra att kunna skriva ut både index och värdet. En sådan enkelt utskrift som nedan är inget vi vill ha i en färdig applikation men det kan vara skönt att göra utskriften under utveckling.

cities = ["Göteborg", "Alingsås", "Borås"]
for index, value in enumerate(cities):
    print(index, value)

0 Göteborg
1 Alingsås
2 Borås

Ofta vill vi göra något mer än att bara hämta index och värden från en lista. Då är det viktigt att förstå hur vi ändrar värdet som vi hämtat och hur vi ändrar värdet som finns lagrat i listan.

cities = ["Göteborg", "Alingsås", "Borås"]
for index, value in enumerate(cities):
    if value == "Borås":
        cities[index] = "Borås i listan"
        value = "Borås i loopen"
    print(index, value)

print(cities)

0 Göteborg
1 Alingsås
2 Borås i loopen
['Göteborg', 'Alingsås', 'Borås i listan']

4.3.1.4 Skriv ut del av list

Ibland kanske vi inte vill skriva ut hela listan utan bara en del.

resultat = [12, 19, 22, 4, 0]

print(resultat[0:3])    # Skriv ut de tre första elementens värden, starta på index 0, gå mot index 3.
print(resultat[-1])     # Skriv ut det sista värdet i listan
print(resultat[::-1])   # Vänd listan

[12, 19, 22]
0
[0, 4, 22, 19, 12]

4.3.1.5 Lägg till och ta bort

Hittills har vi bara kikat på listor som får alla sina värden när listan skapas. Det går bra att lägga till, eller ta bort, element efter att listan är skapad. Här kommer ett exempel på både hur man lägger till och tar bort ett element.

cities = ["Göteborg", "Alingsås", "Borås"]
print(cities)

# append lägger till ett element sist i vår list
cities.append("Vårgårda")
print(cities)

# insert lägger till ett element på den plats vi vill i listan.
# Angivet index är där vi petar in vårt element
cities.insert(1, "Mölnlycke")
print(cities)

# Vi kan fråga efter index om vi känner till värdet
index_borås = cities.index("Borås")
cities.pop(index_borås)     # pop tar bort det index som anges
print(cities)

['Göteborg', 'Alingsås', 'Borås']
['Göteborg', 'Alingsås', 'Borås', 'Vårgårda']
['Göteborg', 'Mölnlycke', 'Alingsås', 'Borås', 'Vårgårda']
['Göteborg', 'Mölnlycke', 'Alingsås', 'Vårgårda']

Om vi skall kunna lägga till element från inmatning eller på något annat sätt så behöver vi kunna deklarera en variabel som list även om den är tom.

cities = []
print(cities)

cities.append("Alingsås")
print(cities)

[]
['Alingsås']

4.3.1.6 Funktioner

Python är synnerligen välbyggt för att jobba med datahantering och listor, därför finns det en hel mängd inbyggda funktioner.

resultat = [12, 19, 22, 4, 19, 13, 21, 18]

# Maxvärdet i list
print(max(resultat))

# Minvärdet i list
print(min(resultat))

# Summan av alla värden
print(sum(resultat))

# Antal element i vår list
print(len(resultat))

# Sortera vår list
resultat.sort()
print(resultat)

# Sorterar listan omvänt
resultat.sort(reverse=True)
print(resultat)

# Antal element med ett visst värde
print(resultat.count(19))

# Tömmer list
resultat.clear()
print(resultat)

22
4
128
8
[4, 12, 13, 18, 19, 19, 21, 22]
[22, 21, 19, 19, 18, 13, 12, 4]
2
[]

# Importera randint som gör att vi slumpa heltal
from random import randint
# Skriv ut ett slumpat tal mellan 1 och 100
print(randint(1, 100))

Slumpat tal mellan 1 och 100: 12

4.3.2 Tuple

Tuple är nästa typ av lista som vi skall kika på. Det som är speciellt med en Tuple är att den får sina värden när den skapas och sedan kan den inte ändras på något sätt. Försöker vi ge ett element ett nytt värde så kommer du få error av typen;

4.3.2.1 Skapa en tuple

Skillnaden på att skapa en tuple istället för en lista är att när vi skapar en tuple så skall den skapas med parentes istället för klammer.

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

4.3.2.2 Skriva ut hela eller delar

Att skriva ut en tuple sker på samma sätt som med en list.

weekdays = ("måndag", "tisdag", "onsdag", "torsdag", "fredag", "lördag", "söndag")
print(weekdays)        # Hela tupeln
print(weekdays[0])     # Tupeln med index 0 (position 1)
print("\nEn dag på varje rad")
for w in weekdays:
    print(w)

('måndag', 'tisdag', 'onsdag', 'torsdag', 'fredag', 'lördag', 'söndag')
måndag

En dag på varje rad
måndag
tisdag
onsdag
torsdag
fredag
lördag
söndag

4.3.2.3 Funktioner

Några funktioner som kan användas när vi jobbar med en tuple.

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

# Hur många element det finns med ett visst värde
print(weekdays.count("tisdag"))

# Vilket index ett visst värde har
print(weekdays.index("tisdag"))

# storleken på en tuple
print(len(weekdays))

# ta bort en tuple
del weekdays

# Det går nu inte att skriva ut innehållet i vår tuple,
# den är helt borttagen och inte tömd som en list
# Istället får vi ett error "NameError: name 'weekdays' is not defined"
# print(weekdays)

1
1
7

4.3.3 Set

Set är den tredje listtypen som vi pratar om. Det som är speciellt med den är att det inte får finnas dubbletter och att listan är osorterad (det är dock en sanning med modifikation, matar du in tal så sorteras den, men inte med strängar). Eftersom det inte finns några unika index i denna lista så kan vi inte skriva ut ett specifikt element ur vårt set. Kika på exemplet för att förstå hur det fungerar.

orter = {"Vårgårda", "Alingsås", "Göteborg", "Lerum"}
print(orter)           # slumpvis utskrift, eftersom sets är osorterad
print(len(orter))      # Hur många orter finns i set

# Kolla om ett värde finns i vårt set
if("Alingsås" in orter):
    print("Ja, Alingsås finns i vårt set")

tomt_set = set()        # Skapar ett tomt set
tal = {4, 3, 1}         # Skapar ett set
print(tal)

tal.add(2)              # Lägger till värdet 2
print(tal)

# Lägger till värdet 2 igen, denna lagras inte eftersom talet 2 redan finns
tal.add(2)

for t in tal:           # Utskrift mha for-loopen
    print(t)

tal.remove(2)           # Ta bort talet 2, ger error om 2 inte finns
tal.discard(2)          # Tar också bort talet 2, ger inget error om det ej finns
print(tal)

tal.clear()             # Tar bort allt innehåll i vårt set
print(tal)

del tal                 # Tar bort set

# Kan inte skriva ut ett borttaget set (NameError: name 'tal' is not defined)
# print(tal)

{'Göteborg', 'Lerum', 'Vårgårda', 'Alingsås'}
4
Ja, Alingsås finns i vårt set
{1, 3, 4}
{1, 2, 3, 4}
1
2
3
4
{1, 3, 4}
set()

Så funkar ett set, fokus här är att inte få dubbletter och att det inte är viktigt i vilken ordning saker skapas. Skulle kunna användas för att kolla mailadresser, användarnamn eller andra saker som behöver vara unika.

# En lista med ett antal värden
l1 = [1, 6, 2, 3, 2, 5, 2, 1, 3, 1, 4, 5, 1, 4, 5, 6]
print(f"Antal tal: {len(l1)}, lista: {l1}")

# Gör om till ett set
s1 = set(l1)
print(f"Antal tal: {len(s1)}, set: {s1}")

# Gör om till lista
l2 = list(s1)
print(f"Antal tal: {len(l2)}, lista: {l2}")

Antal tal: 16, lista: [1, 6, 2, 3, 2, 5, 2, 1, 3, 1, 4, 5, 1, 4, 5, 6]
Antal tal: 6, set: {1, 2, 3, 4, 5, 6}
Antal tal: 6, lista: [1, 2, 3, 4, 5, 6]

Mata in sporter (tryck Enter för att avsluta):
> Fotboll
> Handboll
> Fotboll
"Den sporten finns redan med!"
> Ishockey
> Handboll
"Den sporten finns redan med!"
>
 
Unika sporter i bokstavsordning:
Fotboll
Handboll
Ishockey
Totalt antal inmatningar: 5
Antal unika sporter: 3

4.3.4 Dictionary

Dictionary har en stark koppling mellan index, som du själv sätter, och det värde som är kopplat till index. Detta är en lämplig konstruktion för olika typer av uppslag.

points = {'A':20, 'B':17.5, 'C':15, 'D':12.5, 'E':10}
grade = input("Vilket betyg har du fått på kursen? ")
print(f"Du har angivit betyget {grade} som räknas om till poängen {points[grade]}")

# Nu kan vi lägga till F
points['F'] = 0

# Skriv ut hela dictionary, med både index och värde
print("\nOmvandlingslista")
for key, value in points.items():
    print(f"Betyget {key} ger {value:3.1f} poäng")

# Skriv ut endast värde
print("\nAlla värden")
for value in points.values():
  print(value)

# Skriv ut endast index
print("\nAlla index")
for key in points.keys():
  print(key)

# Ta bort ett element
points.pop('A')
# del points['A']   # Funkar på samma sätt

points.clear()      # Tömmer dictionary
print(points)       # Skriver ut tomt

del points          # Tar bort hela dictionary
# print(points)     # Ger error eftersom dictionary är borttaget

Vilket betyg har du fått på kursen? A
Du har angivit betyget A som räknas om till poängen 20
 
Omvandlingslista
Betyget A ger 20.0 poäng
Betyget B ger 17.5 poäng
Betyget C ger 15.0 poäng
Betyget D ger 12.5 poäng
Betyget E ger 10.0 poäng
Betyget F ger 0.0 poäng
 
Alla värden
20
17.5
15
12.5
10
0
 
Alla index
A
B
C
D
E
F
 
{}

l_users = []                            # Listan där alla dict skall lagras

while True:
    print("\nNu skall du mata in en ny användare, avbryt inmatning genom att mata in tom sträng.")
    user = input("Mata in användarnamn: ")
    if len(user) < 1:                   # Om tom inmatning...
        break                           # ... avbryt inmatning
    pwd = input("Mata in lösenord: ")
    if len(pwd) < 1:
        break
    d = {'user': user, 'password': pwd}
    l_users.append(d)                   # Lägg till dict i listan

print("\nDu har avbrutit inmatningen.")
print(f"Här är listan med alla användare: {l_users}")

Nu skall du mata in en ny användare, avbryt inmatning genom att mata in tom sträng.
Mata in användarnamn: Anna
Mata in lösenord: qwerty
 
Nu skall du mata in en ny användare, avbryt inmatning genom att mata in tom sträng.
Mata in användarnamn: Bosse
Mata in lösenord: abc123
 
Nu skall du mata in en ny användare, avbryt inmatning genom att mata in tom sträng.
Mata in användarnamn: Cilla
Mata in lösenord: 12345678
 
Nu skall du mata in en ny användare, avbryt inmatning genom att mata in tom sträng.
Mata in användarnamn: 
 
Du har avbrutit inmatningen.
Här är listan med alla användare: [{'user': 'Anna', 'password': 'qwerty'}, {'user': 'Bosse', 'password': 'abc123'}, {'user': 'Cilla', 'password': '12345678'}]

Mata in namn (tryck Enter för att avsluta):
> Anna
Ange telefonnummer för Anna:
> 0701234567
> Kalle
Ange telefonnummer för Kalle:
> 0729876543
> Lisa
Ange telefonnummer för Lisa:
> 0731122334
>
 
Telefonbok (i bokstavsordning):
Anna: 0701234567
Kalle: 0729876543
Lisa: 0731122334
 
Skriv in ett namn för att få fram telefonnummer:
> Kalle
Telefonnummer: 0729876543

4.3.5 En cheat sheet på listor

4.3.6 Praktisk användning av listor

I tidigare avsnitt har vi gått igenom grunderna för listor och iterationer i Python. Nu ska vi titta på hur vi kan använda dessa koncept i praktiska tillämpningar. Genom att simulera tärningskast kommer vi att utforska hur listor och dictionaries kan användas för att lagra och analysera data på ett effektivt sätt.

4.3.6.1 Tärningsslag med listor

Vi börjar med att skapa ett program som simulerar ett antal tärningskast och använder listor för att lagra resultaten. Målet är att räkna hur många gånger varje tärningsvärde förekommer och presentera detta för användaren.

from random import randint    # Importerar funktionalitet för slumpmässiga tal

antal_slag = 100              # Antal tärningskast som ska utföras
slag = []                     # Lista för att lagra alla tärningsslag
frekvens = [0]*6              # Lista för att räkna frekvensen av varje tärningsvärde (index 0-5)

for i in range(antal_slag):   # Loopar antal_slag gånger
    värde = randint(1, 6)     # Slår ett tärningsslag (värde mellan 1 och 6)
    slag.append(värde)        # Lägger till tärningsslaget i listan slag
    frekvens[värde - 1] += 1  # Ökar räknaren för det aktuella tärningsvärdet

# Skriver ut frekvensen av varje tärningsvärde
print("Frekvens av varje tärningsvärde:")
for i in range(6):
    print(f"Värde {i+1}: {frekvens[i]} gånger")

# Skriver ut alla tärningsslag
print("\nAlla tärningsslag:")
print(slag)

4.3.6.2.1 Förklaring av koden

• Vi importerar randint från modulen random för att kunna generera slumpmässiga tal mellan 1 och 6.
• Variabler
• antal_slag: Antalet tärningskast som ska simuleras.
• slag: En lista som lagrar resultatet av varje tärningskast.
• frekvens: En lista med sex nollor som används för att räkna hur många gånger varje tärningsvärde förekommer.
• Huvudloopen
• Vi loopar antal_slag gånger och simulerar ett tärningskast varje gång.
• Resultatet av tärningskastet lagras i värde.
• Vi lägger till värde i listan slag.
• Vi ökar räknaren för det aktuella tärningsvärdet i listan frekvens. Eftersom listan är nollindexerad, subtraherar vi 1 från värde för att få rätt index.
• Utskrift
• Vi loopar genom listan frekvens och skriver ut hur många gånger varje tärningsvärde förekom.
• Vi skriver också ut alla tärningsslag som lagrats i listan slag.

4.3.6.2 Tärningsslag med dictionaries

Nu ska vi förbättra vårt program genom att använda en dictionary istället för listor för att räkna frekvensen av varje tärningsvärde. Dictionaries är särskilt användbara när vi vill koppla nycklar (tärningsvärden) till värden (antal gånger de förekommer).

from random import randint    # Importerar funktionalitet för slumpmässiga tal

antal_slag = 100              # Antal tärningskast som ska utföras
slag = []                     # Lista för att lagra alla tärningsslag
frekvens = {}                 # Dictionary för att lagra frekvensen av varje tärningsvärde

for i in range(antal_slag):
    värde = randint(1, 6)     # Slår ett tärningskast (värde mellan 1 och 6)
    # Använder try / except för att uppdatera frekvensen i dictionaryn
    try:
        frekvens[värde] += 1  # Ökar räknaren för det aktuella tärningsvärdet
    except KeyError:
        frekvens[värde] = 1   # Skapar ny nyckel i dictionaryn om den inte finns

# Skriver ut hela dictionaryn
print("\nFrekvens av varje tärningsvärde:")
print(frekvens)

# Skriver ut varje tärningsvärde och dess frekvens
print("\nUtskrift av tärningsvärden och deras frekvenser:")
for nyckel in frekvens:
    print(f"Tärningsvärde {nyckel}: {frekvens[nyckel]} gånger")

# Sorterar och skriver ut tärningsvärdena i ordning
print("\nTärningsvärden sorterade efter värde:")
for nyckel, värde in sorted(frekvens.items()):
    print(f"Tärningsvärde {nyckel}: {värde} gånger")

# Sorterar och skriver ut tärningsvärdena i omvänd ordning
print("\nTärningsvärden sorterade i omvänd ordning:")
for nyckel, värde in sorted(frekvens.items(), reverse=True):
    print(f"Tärningsvärde {nyckel}: {värde} gånger")

# Sorterar baserat på frekvens och skriver ut i fallande ordning
print("\nTärningsvärden sorterade efter frekvens (högst först):")
for nyckel, värde in sorted(frekvens.items(), key=lambda x: x[1], reverse=True):
    print(f"Tärningsvärde {nyckel}: {värde} gånger")
    
# Ett alternativt sätt ifall man vill sortera först på antal och sedan värde
# -x[1] innebär fallande, x[0] innebär stigande
print("\nTärningsvärden sorterade först på frekvens och sedan på värde:")
for nyckel, värde in sorted(frekvens.items(), key=lambda x: (-x[1], x[0])):
    print(f"Tärningsvärde {nyckel}: {värde} gånger")

# Skriver ut alla tärningsslag
print("\nAlla tärningsslag:")
print(slag)

4.3.6.2.1 Förklaring av koden

• Vi importerar randint från modulen random för att kunna generera slumpmässiga tal mellan 1 och 6.
• Variabler
• antal_slag: Antalet tärningskast som ska simuleras.
• slag: En lista som lagrar resultatet av varje tärningskast.
• frekvens: En tom dictionary som kommer att lagra frekvensen av varje tärningsvärde.
• Huvudloopen
• Vi loopar antal_slag gånger och simulerar ett tärningskast varje gång.
• slag: En lista som lagrar resultatet av varje tärningskast.
• Vi använder try / except för att hantera uppdateringen av frekvens:
• Om tärningsvärdet redan finns som en nyckel i frekvens, ökar vi dess värde med 1.
• Om tärningsvärdet inte finns, fångar vi KeyError och lägger till nyckeln med startvärdet 1. Ett KeyError är en mer specifik typ av Exception istället för att fånga ett allmänt error. Se avsnitt 4.3.6.2.3 för alternativa lösningar.
• Utskrift
• Vi skriver ut hela dictionaryn för att se frekvensen av varje tärningsvärde.
• Vi loopar genom frekvens och skriver ut varje nyckel och dess värde.
• Vi visar hur man kan sortera dictionaryn på olika sätt:
• Sortera efter tärningsvärde.
• Sortera i omvänd ordning efter tärningsvärde.
• Sortera efter frekvens med hjälp av en lambda-funktion.
• Vi skriver också ut alla tärningsslag som lagrats i listan slag, vilket kan vara bra att jämföra övriga resultat med.

4.3.6.2.2 Förklaring av lambda

Lambda-anropet behöver nog en särskild förklaring.

print("\nTärningsvärden sorterade efter frekvens (högst först):")
for nyckel, värde in sorted(frekvens.items(), key=lambda x: x[1], reverse=True):
    print(f"Tärningsvärde {nyckel}: {värde} gånger")

• frekvens.items(): Returnerar en lista med dictionaryns nyckel-värde-par som tupler.
• sorted(): En inbyggd funktion som sorterar en iterable (datastruktur som går att loopa igenom, som listorna i detta avsnitt men också datatypen String).
• key=: Ett argument till sorted() där vi kan ange en funktion som bestämmer sorteringsordningen.
• lambda x: x[1]: En anonym funktion som tar ett argument x (i detta fall en tuple) och returnerar det andra elementet i tuplen (x[1]), alltså frekvensen.
• reverse=True: Anger att sorteringen ska ske i omvänd ordning (från högsta till lägsta frekvens).

print("\nTärningsvärden sorterade först på frekvens och sedan på värde:")
for nyckel, värde in sorted(frekvens.items(), key=lambda x: (-x[1], x[0])):
    print(f"Tärningsvärde {nyckel}: {värde} gånger")

Skillnaden i detta exempel är att vi väljer att sortera frekvensen i fallande ordning -x[1] och sedan värdena i stigande ordning x[0]. -x[1] innebär fallande, x[0] innebär stigande.

Varför är det lämpligt att använda lambda i denna situation?

• Enkelhet: Lambda-funktionen gör det möjligt att snabbt definiera en enkel sorteringsnyckel utan att behöva skriva en separat funktion.
• Effektivitet: Koden blir mer kompakt och lättläst.

Vi går inte dljuare i lambdafunktioner just nu men det är användbart när data skall behandlas. Kanske återkommer vi till det senare i kursen men nu har du sett det en gång iaf om du skulle stöta på det vid någon sökning på nätet.

4.3.6.2.3 Jämförelse mellan try / except,if-sats och dict.get()

Vi använde try / except för att hantera uppdateringen av frekvens i lösningen ovan. Det finns alternativa lösningar för just det vi ville göra och här går jag igenom dem.

try:
    frekvens[värde] += 1
except KeyError:
    frekvens[värde] = 1

if värde in frekvens:
    frekvens[värde] += 1
else:
    frekvens[värde] = 1

frekvens[värde] = frekvens.get(värde, 0) + 1

Flera olika varianter för att lösa samma uppgift, det är python i ett nötskal. Använd den lösning som du gillar mest och som du kan använda i skarpt läge.

resultat = [4, 3, 5, 2, 4, 3, 4, 5, 3, 2, 4, 5, 3, 4, 2, 4, 5, 3, 4, 2, 4, 5, 3, 4, 2]

provresultat = [
    [7, 8, 6],[5, 6, 5],[9, 8, 7],[6, 5, 6],[8, 9, 8],
    [6, 7, 5],[7, 8, 7],[5, 6, 4],[8, 7, 8],[6, 5, 6],
    [7, 8, 7],[5, 6, 5],[8, 9, 8],[6, 7, 6],[7, 8, 7],
    [5, 6, 5],[8, 9, 8],[6, 7, 6],[7, 8, 7],[5, 6, 5],
    [8, 9, 8],[6, 7, 6],[7, 8, 7],[5, 6, 5],[8, 9, 8]
]

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