5. Moment05 - Funktioner och datalagring

I de tidigare momenten har vi arbetat med variabler, villkor, loopar och datastrukturer. Nu tar vi nästa steg: vi ska bygga program som är uppdelade i funktioner och som kan spara och läsa data från filer.

Hittills har våra program “glömt” all information när de avslutas. I detta moment ska vi lära oss hur data kan lagras i en fil och läsas in igen nästa gång programmet körs.

Momentet fokuserar på teknik och struktur:

• hur program delas upp i funktioner
• hur data lagras i textfiler
• hur strukturerad data läses in och skrivs tillbaka
• hur listor används som grundstruktur

Målet är att du ska kunna bygga program som både är strukturerade och kan hantera data över tid.

5.1 Funktioner – struktur i program

I tidigare moment har vi skrivit program där all kod ligger “på rad”. Det fungerar, men när programmen växer blir de svårare att läsa, svårare att förstå och svårare att förändra.

En funktion är en namngiven koddel som samlar instruktioner som hör ihop. Istället för att skriva allt i ett enda långt block delar vi upp programmet i mindre delar med tydliga namn.

Funktioner hjälper oss att:

• undvika att skriva samma kod flera gånger
• göra programmet lättare att läsa
• dela upp ett stort problem i mindre delar
• kunna återanvända kod på flera ställen

Tänk på ett program som en maskin. Om alla delar ligger huller om buller blir den svår att förstå. Om varje del har ett namn och ett tydligt ansvar blir programmet mer strukturerat.

I detta avsnitt ska vi lära oss hur man skapar och använder funktioner för att bygga mer strukturerade program.

5.1.1 Skapa och anropa en funktion

En funktion skapas med def. Koden i funktionen körs först när funktionen anropas.

Det är viktigt att själva funktionen är definierad innan du försöker anropa den. Python läser koden uppifrån och ner. Om du anropar en funktion innan Python hunnit läsa dess definition får du ett fel.

def hälsa():
    print("Hej!")

hälsa()

Hej!

hälsa()

def hälsa():
    print("Hej!")

NameError: name 'hälsa' is not defined

Om du får detta fel betyder det oftast att du anropar en funktion som Python inte känner till ännu. Kontrollera då att:

• funktionen ligger ovanför anropet (i samma fil)
• eller att du importerar rätt fil om funktionen ligger i en modul

def hälsa():
    print("Hej!")

hälsa()
hälsa()

Hej!
Hej!

def skriv_titel():
    print("===== MIN APP =====")

skriv_titel()
skriv_titel()
skriv_titel()

5.1.2 Parametrar – skicka in värden

Parametrar gör funktionen flexibel: samma funktion kan användas med olika värden. När du anropar funktionen skickar du in värden som kallas argument.

def hälsa_namn(namn):
    print("Hej " + namn + "!")

hälsa_namn("Anna")
hälsa_namn("Erik")

Hej Anna!
Hej Erik!

5.1.2.1 Defaultvärden

En parameter kan ha ett defaultvärde. Det betyder att parametern får ett värde automatiskt om du inte skickar in något värde vid anropet.

def summera(a, b=10):
    print(a + b)

summera(5, 2)   # b blir 2
summera(5)      # b blir 10 (default)

7
15

def multiplicera(a, b):
    print(a * b)

multiplicera(3, 4)
multiplicera(10, 2)
multiplicera(7, 5)

5.1.2.2 Namngivna argument (keyword arguments)

När du anropar en funktion brukar du skicka in argument i rätt ordning. Då kopplas argumenten till parametrarna positionellt (först till första parametern, sedan till nästa, osv.).

def summera(a, b, c=1, d=0):
    print(a + b + c + d)

summera(3, 7, 2, 4)       # Utskrift: 16

Du kan också koppla argument till parametrar genom att skriva parameterns namn vid anropet. Detta kallas namngivna argument (på engelska keyword arguments).

def summera(a, b, c=1, d=0):
    print(a + b + c + d)

summera(a=3, b=7, d=4)     # Utskrift: 15

I exemplet ovan får c sitt defaultvärde (1) eftersom vi inte skickade in något värde för c.

Viktig regel: Om du blandar positionella och namngivna argument måste de positionella komma först.

# Rätt:
summera(3, 7, d=4)

# Fel (ger SyntaxError):
# summera(a=3, 7, d=4)

def rabatt(pris, procent=10):
    return pris - (pris * procent / 100)

# Defaultvärde (10%)
pris1 = rabatt(200)
print(pris1)

# Namngivet argument (25%)
pris2 = rabatt(200, procent=25)
print(pris2)

5.1.2.3 Vad kan skickas in som argument?

När vi anropar en funktion behöver argumenten inte vara hårdkodade värden som 5 eller "Anna". Vi kan också skicka in värden från variabler, uttryck och listor.

def skriv_summa(a, b):
    print(a + b)

x = 7
tal_lista = [10, 20, 30]

skriv_summa(3, 4)              # hårdkodade värden
skriv_summa(x, 5)              # variabel
skriv_summa(2 + 3, 4 * 2)      # uttryck
skriv_summa(tal_lista[0], 5)   # värde hämtat från lista

Det viktiga är att det som skickas in blir ett värde som passar funktionen.

5.1.3 Return – skillnad på print och return

Hittills har vi använt print() för att visa resultat. Men ibland behöver vi använda resultatet vidare i programmet. Då räcker inte print() – då behöver vi return.

• print() – visar något på skärmen
• return – skickar tillbaka ett värde till den som anropade funktionen

Anta att vi vill räkna ut den totala arean av tre rektanglar. Då behöver vi kunna använda varje area vidare i programmet.

def area_rektangel(bredd, hojd):
    return bredd * hojd

area1 = area_rektangel(3, 5)
area2 = area_rektangel(4, 2)
area3 = area_rektangel(6, 3)

total_area = area1 + area2 + area3

print(f"Totala arean är {total_area}")

Om funktionen istället hade använt print() hade vi inte kunnat spara värdena i variabler och summera dem.

5.1.3.1 Vanligt misstag: Varför skrivs "None" ut?

När man är ny på funktioner händer det ofta att man blandar ihop print och return. Titta på detta exempel:

def a():
    print("a")

def b():
    return "b"

a()
print(a())

b()
print(b())

a
a
None
b

Vad händer rad för rad?

• Rad 7: a() - Funktionen körs och skriver ut "a". Den returnerar inget värde, alltså returneras automatiskt None.
• Rad 8: print(a()) - Först körs a() igen → den skriver ut "a". Sedan returnerar funktionen None. print() skriver då ut detta värde → därför ser vi None.
• Rad 10: b() - Funktionen returnerar strängen "b". Men eftersom vi inte skriver ut värdet händer inget synligt på skärmen.
• Rad 11: print(b()) - Funktionen körs och returnerar "b". Detta värde skickas in i print(), som då skriver ut "b".

Viktig princip:

• En funktion utan return returnerar automatiskt None.
• Att anropa en funktion är inte samma sak som att skriva ut dess returvärde.

Kom ihåg:
Om du vill använda resultatet vidare → använd return.
Om du bara vill visa något → använd print().

def addera(a, b):
    return a + b

svar = addera(10, 7)
print(svar)

5.1.4 Funktioner i separat fil (moduler)

När program växer blir det rörigt att ha all kod i samma fil. Därför kan vi dela upp programmet i flera filer.

En vanlig struktur är:

• main.py – styr programmet
• funktioner.py – innehåller funktioner

Detta gör programmet mer strukturerat och lättare att underhålla.

def skriv_meny():
    print("1. Säg hej")
    print("2. Avsluta")

def hamta_val():
    return input("Välj: ")

def hantera_val(val):
    if val == "1":
        print("Hej!")
    elif val == "2":
        print("Avslutar...")
    else:
        print("Ogiltigt val")

import funktioner

funktioner.skriv_meny()
val = funktioner.hamta_val()
funktioner.hantera_val(val)

Observera att:

• Filerna måste ligga i samma mapp.
• Vi skriver import funktioner (utan .py).
• Vi anropar funktionerna via filnamnet.

import funktioner

funktioner.skriv_meny()

from funktioner import *

skriv_meny()

# funktioner.py
def skriv_meny():
    print("1. Dubbel tal")
    print("2. Avsluta")

def dubbla(tal):
    return tal * 2


# övning51e.py
import funktioner

funktioner.skriv_meny()
val = input("Välj: ")

if val == "1":
    tal = int(input("Ange tal: "))
    resultat = funktioner.dubbla(tal)
    print(resultat)
elif val == "2":
    print("Avslutar...")

import rektangel
import cirkel

5.1.5 Dokumentation av funktioner

När program blir större är det viktigt att andra (och du själv i framtiden) förstår vad en funktion gör.

Därför behöver funktioner dokumenteras. Det kan göras på olika nivåer – från enkla kommentarer till så kallade docstrings.

5.1.5.1 Enkla kommentarer

Den enklaste formen av dokumentation är en kommentar med #. Kommentaren beskriver vad funktionen gör.

def area_rektangel(bredd, hojd):
    # Beräknar arean av en rektangel
    return bredd * hojd

Kommentarer är bra, men de är mest till för människor som läser koden.

5.1.5.2 Docstrings

En docstring är en dokumentationssträng som skrivs direkt under funktionshuvudet med tre citationstecken (""").

Den beskriver:

• vad funktionen gör
• vilka parametrar den tar emot
• vad den returnerar

def area_rektangel(bredd, hojd):
    """
    Beräknar arean av en rektangel.

    Parametrar:
        bredd (int eller float): Rektangelns bredd
        hojd (int eller float): Rektangelns höjd

    Returnerar:
        int eller float: Rektangelns area
    """
    return bredd * hojd

Docstrings är standard i Python och gör det lättare att förstå och använda funktioner.

5.1.5.3 PyCharm och automatisk dokumentation

I PyCharm kan du automatiskt skapa en docstring.

• Skriv """ direkt under funktionshuvudet.
• Tryck Enter.
• PyCharm skapar då en mall med parametrar och returvärde.

Du kan sedan fylla i beskrivningarna själv.

def addera(a, b):
    """
    Returnerar summan av två tal.

    Parametrar:
        a (int eller float): Första talet
        b (int eller float): Andra talet

    Returnerar:
        int eller float: Summan av talen
    """
    return a + b

Att dokumentera sina funktioner är en viktig del av att skriva tydlig och professionell kod.

5.2 Filhantering

I tidigare moment har våra program bara arbetat med data medan programmet körs. När programmet avslutas försvinner all information.

I många program behöver data sparas så att den kan användas igen nästa gång programmet startas. Exempel kan vara:

• sparade inställningar
• listor med namn eller resultat
• loggar eller mätvärden

Ett enkelt sätt att lagra data är att använda filer. En fil kan innehålla text som programmet läser in och arbetar vidare med.

I detta avsnitt ska vi arbeta med tre saker:

• läsa data från en fil
• skriva data till en fil
• lagra strukturerad data i filer

Vi börjar med det enklaste fallet: en fil där varje rad innehåller ett värde.

5.2.1 Läsa från fil

För att läsa från en fil använder vi funktionen open(). Det vanligaste sättet är att använda konstruktionen with open().

Fördelen med with open() är att filen automatiskt stängs när blocket är färdigt. Du behöver alltså inte själv skriva någon extra kod för att stänga filen.

Anna
Erik
Sara

with open("namn.txt") as fil:
    for rad in fil:
        print(rad)

Anna
 
Erik
 
Sara

I exemplet ovan läses filen rad för rad i en loop.

Varje rad i filen är en sträng och innehåller redan ett radbyte (\n) i slutet.

När vi använder print() läggs ytterligare ett radbyte till. Därför visas en tom rad mellan varje namn i utskriften.

Ofta vill man ta bort radbrytningen i slutet av raden innan man använder datan. Det görs med funktionen strip().

with open("namn.txt") as fil:
    for rad in fil:
        namn = rad.strip()
        print(namn)

FileNotFoundError

Anna
Erik
Sara

with open("namn.txt") as fil:
    for rad in fil:
        namn = rad.strip()
        print(namn)

I många fall vill vi inte bara skriva ut det vi läser in. Ofta vill vi istället lagra datan i en lista så att programmet kan arbeta vidare med den.

57
33
24

tal_lista = []

with open("provpoäng.txt") as fil:
    for rad in fil:
        tal = int(rad.strip())
        tal_lista.append(tal)

print(tal_lista)

for rad in fil:
    rad = rad.strip()

    if rad == "":
        continue

    tal = int(rad)

18
21
16
23

temperaturer = []

with open("temperaturer.txt") as fil:
    for rad in fil:
        tal = int(rad.strip())
        temperaturer.append(tal)

print(temperaturer)

12
7
19
3
15

import statistics

tal = [12, 7, 19, 3, 15]

print(statistics.median(tal))

import statistics

print(statistics.__file__)

print(type(sum))

<class 'builtin_function_or_method'>

help(sum)
help(statistics.median)

5.2.2 Skriva till fil

I avsnitt 5.2.1 läste vi data från en fil och lagrade den i en lista. Nu gör vi tvärtom: vi ska skriva data från programmet till en fil.

När vi skriver till en fil använder vi också open(), men nu anger vi dessutom vilket läge filen ska öppnas i.

För att skriva till en fil använder vi oftast läget "w".

with open("hej.txt", "w") as fil:
    fil.write("Hej!")

Om filen inte finns skapas den. Om filen redan finns skrivs innehållet över.

Hej!

När vi skriver flera rader till en fil måste vi själva lägga till radbrytningen \n.

with open("namn.txt", "w") as fil:
    fil.write("Anna\n")
    fil.write("Erik\n")
    fil.write("Sara\n")

Anna
Erik
Sara

with open("tal.txt") as fil:
    ...

with open("tal.txt", "r") as fil:
    ...

Detta fungerar, men om vi redan har datan i en lista är det oftast bättre att loopa igenom listan.

namn_lista = ["Anna", "Erik", "Sara"]

with open("namn.txt", "w") as fil:
    for namn in namn_lista:
        fil.write(namn + "\n")

Här används samma idé som när vi läste från fil:

• i 5.2.1: fil → lista
• nu i 5.2.2: lista → fil

with open("tal.txt", "w") as fil:
    fil.write(12)

with open("tal.txt", "w") as fil:
    fil.write(str(12))

with open("logg.txt", "a") as fil:
    fil.write("Ny rad\n")

Om filen redan innehåller data läggs den nya raden till längst ner i filen.

Start
Första körningen
Ny rad

klasslista = ["Alva", "Noah", "Maja"]

with open("klasslista.txt", "w") as fil:
    for namn in klasslista:
        fil.write(namn + "\n")

temperaturer = [18, 21, 16, 23]

with open("temperaturer.txt", "w") as fil:
    for tal in temperaturer:
        fil.write(str(tal) + "\n")

Loggmeddelande: Programmet startade
Loggmeddelande: Testkörning
Loggmeddelande: Allt fungerar
Loggmeddelande:

Programmet startade
Testkörning
Allt fungerar

while True:
    meddelande = input("Loggmeddelande: ")

    if meddelande == "":
        break

    with open("logg.txt", "a") as fil:
        fil.write(meddelande + "\n")

Rapporten genererad!

RAPPORT
=======

Tal: [12, 7, 19, 3, 15]
Antal tal: 5
Summa: 56
Största tal: 19
Minsta tal: 3
Medelvärde: 11.2
Medianvärde: 12
Antal tal större än 10: 3
Sorterad lista: [3, 7, 12, 15, 19]

5.2.3 Strukturerad data i filer

I tidigare avsnitt har vi arbetat med filer där en rad innehåller ett värde.

12
8
15
9

Men många filer innehåller flera värden på samma rad.

Anna;12;14;16
Erik;8;10;9
Sara;15;13;17

Här representerar varje rad:

• ett namn
• tre delresultat

För att arbeta med denna typ av data behöver vi dela upp raden i flera delar.

Det görs med metoden:

split()

Den delar upp en sträng baserat på ett visst tecken, i detta fall ;.

5.2.3.1 Dela upp en rad med split()

Vi börjar med att läsa en rad från filen och dela upp den.

with open("resultat.txt") as fil:
    for rad in fil:
        delar = rad.strip().split(";")
        print(delar)

['Anna', '12', '14', '16']
['Erik', '8', '10', '9']
['Sara', '15', '13', '17']

Resultatet blir en lista där varje del av raden är ett element.

12

"12"

int("12")

5.2.3.2 Lagra strukturerad data

Nu ska vi lagra informationen i en struktur som är lätt att arbeta vidare med.

Vi kan till exempel i en lista lagra varje elev så här:

["Anna", [12, 14, 16]]

Det innebär:

• första värdet = namn
• andra värdet = lista med resultat

Hela filen kan då representeras så här:

[
    ["Anna", [12, 14, 16]],
    ["Erik", [8, 10, 9]],
    ["Sara", [15, 13, 17]]
]

Följande program läser filen och bygger denna struktur.

elever = []

with open("resultat.txt") as fil:
    for rad in fil:
        delar = rad.strip().split(";")
        namn = delar[0]
        poang = []
        for varde in delar[1:]:       # [1:] - starta loopen på listans index 1
            poang.append(int(varde))
        elever.append([namn, poang])

print(elever)

5.2.3.3 Skriva tillbaka strukturerad data

När vi skriver tillbaka datan måste vi skapa en rad som ser ut som i filen:

Anna;12;14;16

Det gör vi genom att bygga en textsträng för varje elev.

with open("resultat_ny.txt", "w") as fil:
    for elev in elever:
        namn = elev[0]
        poang = elev[1]
        text_poang = []
        for p in poang:
            text_poang.append(str(p))
        rad = namn + ";" + ";".join(text_poang)
        fil.write(rad + "\n")

Här används "w" eftersom vi skriver om hela filen.

5.2.3.4 Strukturerad data med dict

Vi kan också lagra samma data med en dict istället för en nästlad lista.

Då kan varje namn fungera som nyckel och listan med resultat som värde.

En möjlig struktur blir då:

{
    "Anna": [12, 14, 16],
    "Erik": [8, 10, 9],
    "Sara": [15, 13, 17]
}

Detta kan vara praktiskt om vi snabbt vill slå upp en viss elev med hjälp av namnet.

Följande program läser in filen resultat.txt och lagrar datan i en dictionary:

elever = {}

with open("resultat.txt") as fil:
    for rad in fil:
        delar = rad.strip().split(";")
        namn = delar[0]

        poang = []
        for varde in delar[1:]:
            poang.append(int(varde))

        elever[namn] = poang

print(elever)       # Utskrift: {'Anna': [12, 14, 16], 'Erik': [8, 10, 9], 'Sara': [15, 13, 17]}

Om vi vill skriva tillbaka datan till en ny fil behöver vi loopa över både nycklar och värden.

with open("resultat_ny.txt", "w") as fil:
    for namn, poang in elever.items():

        text_poang = []
        for p in poang:
            text_poang.append(str(p))

        rad = namn + ";" + ";".join(text_poang)
        fil.write(rad + "\n")

Resultatet i resultat_ny.txt blir samma typ av fil som tidigare:

Anna;12;14;16
Erik;8;10;9
Sara;15;13;17

Alingsås;12;14;11;9;4
Göteborg;15;16;14
Stockholm;10;8;6;5

Alingsås har 5 mätpunkter
Göteborg har 3 mätpunkter
Stockholm har 4 mätpunkter

with open("temperaturer.txt") as fil:

    for rad in fil:

        delar = rad.strip().split(";")

        stad = delar[0]

        antal = len(delar) - 1

        print(f"{stad} har {antal} mätpunkter")

Alingsås;12;14;11;9;4
Göteborg;15;16;14
Stockholm;10;8;6;5

Alingsås: 10
Göteborg: 15
Stockholm: 7

with open("temperaturer.txt") as fil:
    for rad in fil:
        delar = rad.strip().split(";")

        stad = delar[0]
        temperaturer = []

        for varde in delar[1:]:
            temperaturer.append(int(varde))

        medel = sum(temperaturer) / len(temperaturer)

        print(f"{stad}: {medel:.2f}")

Alingsås;12;14;11;9;4
Göteborg;15;16;14
Stockholm;10;8;6;5

Alingsås - medel: 10, median: 11
Göteborg - medel: 15, median: 15
Stockholm - medel: 7, median: 7

Rapport skapad!

5.3 JSON – strukturerad data på riktigt

Hittills i momentet har vi arbetat med textfiler där vi själva bestämt hur datan ska se ut. Vi har till exempel använt filer med ett värde per rad och filer där flera värden skiljs åt med semikolon.

Det fungerar bra, men det kräver också att vi själva delar upp texten med split(), konverterar värden och bygger upp strukturen i programmet.

JSON är ett vanligt format för att lagra strukturerad data. Det används i många riktiga program och på webben när system skickar information till varandra.

Fördelen med JSON är att vi kan lagra data i en struktur som redan liknar Pythons listor och dictionaries.

5.3.1 Vad är JSON?

JSON står för JavaScript Object Notation. Trots namnet används formatet i många olika programmeringsspråk, även i Python.

En JSON-fil kan till exempel se ut så här:

{
    "stad": "Alingsås",
    "temperaturer": [12, 14, 11, 9, 4]
}

I Python motsvaras detta av en dictionary:

data = {
    "stad": "Alingsås",
    "temperaturer": [12, 14, 11, 9, 4]
}

Det betyder att JSON passar bra när vi vill lagra data som har:

• nycklar, till exempel "stad"
• värden, till exempel "Alingsås"
• listor, till exempel flera temperaturer

5.3.2 Läsa JSON från fil

För att läsa JSON använder vi modulen json.

När vi läser in en JSON-fil med json.load() omvandlas datan till vanliga Python-strukturer, oftast listor och dictionaries.

import json

with open("temperaturer.json", encoding="utf-8") as fil:
    data = json.load(fil)

print(data)         # Utskrift: {'stad': 'Alingsås', 'temperaturer': [12, 14, 11, 9, 4]}

Om filen innehåller JSON-exemplet från tidigare avsnitt blir data en dictionary.

print(data["stad"])
print(data["temperaturer"])

Alingsås
[12, 14, 11, 9, 4]

Vi kan sedan arbeta vidare med datan precis som med vanliga dictionaries och listor.

for temperatur in data["temperaturer"]:
    print(temperatur)

5.3.3 Skriva JSON till fil

För att spara en dictionary eller lista som JSON använder vi json.dump().

import json

data = {
    "stad": "Alingsås",
    "temperaturer": [12, 14, 11, 9, 4]
}

with open("temperaturer.json", "w", encoding="utf-8") as fil:
    json.dump(data, fil, indent=4, ensure_ascii=False)

{
    "stad": "Alingsås",
    "temperaturer": [
        12,
        14,
        11,
        9,
        4
    ]
}

with open("temperaturer.json", "w", encoding="utf-8") as fil:
    json.dump(data, fil, indent=4, ensure_ascii=False)

5.3.4 Flera objekt i samma JSON-fil

Ofta vill vi lagra mer än en sak i samma fil. Då kan vi använda en lista av dictionaries.

[
    {
        "stad": "Alingsås",
        "temperaturer": [12, 14, 11, 9, 4]
    },
    {
        "stad": "Göteborg",
        "temperaturer": [15, 16, 14]
    },
    {
        "stad": "Stockholm",
        "temperaturer": [10, 8, 6, 5]
    }
]

När vi läser in denna fil får vi en lista där varje element är en dictionary.

import json

with open("temperaturer_flera.json", encoding="utf-8") as fil:
    data = json.load(fil)

print(type(data))
print(data[0])
print(data[0]["stad"])

<class 'list'>
{'stad': 'Alingsås', 'temperaturer': [12, 14, 11, 9, 4]}
Alingsås

Vi kan nu loopa över hela listan:

for post in data:
    print(post["stad"])

{
    "stad": "Alingsås",
    "temperaturer": [12, 14, 11, 9, 4]
}

import json

with open("temperaturer.json", encoding="utf-8") as fil:
    data = json.load(fil)

print(data["stad"])
print(len(data["temperaturer"]))

[
    {
        "stad": "Alingsås",
        "temperaturer": [12, 14, 11, 9, 4]
    },
    {
        "stad": "Göteborg",
        "temperaturer": [15, 16, 14]
    },
    {
        "stad": "Stockholm",
        "temperaturer": [10, 8, 6, 5]
    }
]

Alingsås: 10
Göteborg: 15
Stockholm: 7

import json

with open("temperaturer_flera.json", encoding="utf-8") as fil:
    data = json.load(fil)

for post in data:
    stad = post["stad"]
    temperaturer = post["temperaturer"]
    medel = sum(temperaturer) / len(temperaturer)
    print(f"{stad}: {medel:.2f}")

[
    {
        "stad": "Alingsås",
        "medel": 10,
        "median": 11
    },
    {
        "stad": "Göteborg",
        "medel": 15,
        "median": 15
    },
    {
        "stad": "Stockholm",
        "medel": 7,
        "median": 7
    }
]

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

5.4.1 Checklista inför diagnosen

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