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

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("\nVi loopar från {} till {}.".format(start, 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("När i är {} så är totalsumman {}".format(i, summa))
# else som tillhör loopen och körs när loopen har körts färdigt
else:
    print("När vi loopat färdigt så är summan {}".format(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

# Deklarerar variabler
summa = 0
start = 10
stopp = 20
print("\nVi loopar från {} till {}.".format(start, 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("När i är {} så är totalsumman {}".format(i, summa))
# else som tillhör loopen och körs när loopen har körts färdigt
else:
    print("När vi loopat färdigt så är summan {}".format(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

Jag har tidigare nämnt att iteration 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("Klockan är {}, ".format(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("När vi har loopat klart så har tal värdet {}".format(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.3.

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 Aktivitetsdiagram och pseduokod för loopar

I förra momentet lärde vi oss att skriva pseudokod och aktivitetsdiagram 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

Som du ser är den lik aktivitetsdiagrammet, men man skulle också kunna skriva den på ett mer generellt sätt så att varje utvecklare själv kan välja vilken typ av loop som skall/kan användas. Då kan det se 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 finns inget rätt eller fel även om du i det första exemplet troligtvis styrs till att använda while-loopen och i det andra själv får välja vilken iteration du vill använda för att lösa uppgiften.

Avancerade algoritmer med flera eller djupa iterationer känns ofta lättare att följa med ett aktivitetsdiagram än med pseudokod.

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("Det korrekt inmatade talet är {}".format(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: 91

Uppgift: m04e04

Här kommer en extrauppgift som du har möjlighet att bygga på hur långt du vill. Yatzy är ett klassiskt spel med fem tärningar, klassisk tärning 1-6, där det gäller att samla poäng genom att samla på olika serier av tärningsslag.

Börja med att att skapa fem slumpade tärningar i en lista. Skriv sedan ut din hand på valfritt sätt.

Första uppgiften är att kolla om det finns minst ett par bland dina fem tärningar. Använd gärna aktivitetsdiagram och/eller pseudokod för att planera hur du skall lösa detta.

• Kan du visa vilket värde som blivit yatzy (1:or, 2:or osv..).
• Kan du se om det är flera par?
• Kan du se om det blivit någon triss?

Alla som har spelat yatzy vet att det är en hel del olika typer av slag som kan ge olika antal poäng. Att bygga upp hela detta spelet tar en stund och är väl omfattande för denna kursen. Hur hittar vi då en förenklad version av yatzy? Vi går naturligtvis till barnspelen och kikar på hur barn- och bamse-yatzy fungerar. Utifrån dessa regler så är det enklare att bygga fullt fungerande varianter av yatzy.

Barnyatzy [klicka för regler]

Bamseyatzy [klicka för regler]

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)

{'Lerum', 'Alingsås', 'Vårgårda', 'Göteborg'}
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]

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("Du har angivit betyget {} som räknas om till poängen {}".format(grade, 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("Betyget {} ger {:3.1f} poäng".format(key, value))

# 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'}]

4.3.5 En cheat sheet på listor

I inlägget Användning av listor finns det lite fler exempel på hur man kan använda olika typer av listor för att analysera data.

4.4 Inlämningsuppgift

Denna uppgift byggs på i flera delar. Du löser så många delar du kan och lämnar in den sista fungerande lösningen. I denna övning kommer jag testa dig på tekniker från detta och tidigare moment men framförallt testas du på problemlösning. Ta hand om en del i taget, klura ut vad jag vill att du gör, dela upp uppgiften i mindre delar och när du är helt klar med den delen så går du vidare till nästa. Du kommer inte vinna på att kika på flera delar åt gången. I de tidigare delarna så får du lite extra hjälp att komma igång medan de senare delarna kräver en del egen problemlösning för att få det att fungera. I varje del så får du se hur min utskrift ser ut när jag har löst programmet, du måste inte härma mig men det kan vara en vägledning för att du skall förstå uppgiften.

I uppgift a ligger fokus på iteration och selektion, i uppgift b ligger fokus på fler iterationer och även listor. Jag vill att du klarar av dessa två innan inlämning för att visa på kunskaper inom de delar som ingår i momentet.

# Anders Andersson, 18TEx
# Moment04, uppgift d
# Det var en utmanade uppgift och jag klarade inte av sista tillägget.
# Det som var mest utmanande var hur jag skulle konvertera det som matades in...
# ....

# Be användaren mata in rektangelns två sidor
# Beräkna och skriv ut arean på rektangeln
# Om bägge sidorna är lika långa...
  # ... tala om att det är en kvadrat
# Loopa höjden från 1 till 10
  # Beräkna volymen och skriv ut den

Denna applikation gör ett antal beräkningar på en rektangel/rätblock.
Ange rektangelns ena sida: 5
Ange rektangelns andra sida: 5

Rektangeln har sidorna 5 och 5 vilket gör att arean är 25
Eftersom bägge sidorna är lika långa så är denna rektangel en kvadrat.

Höjden | Volymen
-----------------
     1 |      25
     2 |      50
     3 |      75
     4 |     100
     5 |     125
     6 |     150
     7 |     175
     8 |     200
     9 |     225
    10 |     250

# Skapa en loop som bryter när användaren inte vill göra fler beräkningar
  # Be användaren mata in rektangelns två sidor
  # Beräkna och skriv ut arean på rektangeln samt lagra i listan
  # Om bägge sidorna är lika långa...
    # ... tala om att det är en kvadrat och skriv detta i listan
  # Loopa höjden från 1 till 10
    # Beräkna volymen och skriv ut den
  # Fråga användaren om hen vill göra fler beräkningar
    # Om inte avryt loopen
# Skriv ut alla beräkningar

Denna applikation gör ett antal beräkningar på en rektangel/rätblock.
Ange rektangelns ena sida: 5
Ange rektangelns andra sida: 5

Rektangeln har sidorna 5 och 5 vilket gör att arean är 25
Eftersom bägge sidorna är lika långa så är denna rektangel en kvadrat.

Höjden | Volymen
-----------------
     1 |      25
###### bortklippt ######
    10 |     250
Vill du göra en beräkning till (J/N)? J

Ange rektangelns ena sida: 6
Ange rektangelns andra sida: 4

Rektangeln har sidorna 6 och 4 vilket gör att arean är 24

Höjden | Volymen
-----------------
     1 |      24
###### bortklippt ######
    10 |     240
Vill du göra en beräkning till (J/N)? N

Rektangeln har sidorna 5 och 5 vilket gör att arean är 25, rektangeln är en kvadrat.
Rektangeln har sidorna 6 och 4 vilket gör att arean är 24

Denna applikation gör ett antal beräkningar på en rektangel/rätblock.
Ange rektangelns ena sida: 5
Ange rektangelns andra sida: 5
Ange rätblockets höjd: tre
Du har gjort en felaktig inmatning, ange ett heltal
Ange rätblockets höjd: -3

Rektangeln har sidorna 5 och 5 vilket gör att arean är 25
Eftersom bägge sidorna är lika långa så är denna rektangel en kvadrat.

Höjden | Volymen
-----------------
     1 |      25
Vill du göra en beräkning till (J/N)? N
Rektangeln har sidorna 5 och 5 vilket gör att arean är 25, rektangeln är en kvadrat.

# funktion omkrets
# inparameter: sida1 & sida2
# returvärde inget
def omkrets(s1, s2):
    print("Omkretsen av en rektangel med sidorna {} och {} är {}"
           .format(s1, s2, 2*(s1+s2)))

# funktion omkrets_retur
# inparameter: sida1 & sida2
# returvärde: omkretsen
def omkrets_retur(s1, s2):
    return 2*(s1+s2)

sida1 = 5
sida2 = 5

# ta emot det returnerade värdet
o = omkrets_retur(sida1, sida2)

# Anropar funktionen omkrets för utskrift
omkrets(sida1, sida2)

# Anropar funktionen omkrets_retur i utskriften
print("Omkretsen av en rektangel med sidorna {} och {} är {}"
       .format(sida1, sida2, omkrets_retur(sida1, sida2)))