Skip to main content

8  Lagring og utveksling av data

Alt et program arbeider med, forsvinner når programmet stopper, med mindre det er lagret. Dette kapittelet handler om hvordan data lagres og sendes mellom programmer: hvordan en datamaskin i bunn og grunn lagrer tall og tekst, hvordan du leser og skriver filer, hvordan du bruker en database, hvordan du henter data fra andre systemer over nettet, og hvordan du holder dataene trygge.

Du lærer å regne med bits og bytes, å forstå tegnkoding og Unicode (og hvorfor «å» av og til blir til «Ã¥»), å arbeide med tekstfiler, CSV og JSON, å lage og søke i en database med SQL, å hente data fra et API og håndtere at nettet svikter, og å sikre data med sikkerhetskopier, tilgangsstyring, hashing og kryptering. Alt dette er kompetansemålet om å gjøre rede for standarder for lagring, utveksling og sikring av ulike typer data. Kapittelet legger også grunnlaget for å innhente og analysere data fra reelle datasett (kapittel 9).

Mye av dette gjør du i VS Code, siden det handler om filer på maskinen din, databaser og nettverk. Notatboka i nettleseren virker for det meste, siden oppgavene bruker tekst i minnet og midlertidige filer og databaser i minnet.

Pass på på eksamen: På skriftlig eksamen har du ikke nettilgang. Data kommer som filer (CSV eller JSON), og API-oppgaver må kunne løses med en lagret JSON-fil. Øv derfor på å lese og bearbeide data fra filer, og se på API-kall som noe du kan gjøre hjemme.

Notatboka har flere oppgaver, som rettes med sjekk(). Den kan brukes i nettleseren eller i VS Code.

Læringsmål

Etter å ha arbeidet med kapittelet skal du kunne

  • regne mellom tallsystemer og forklare hvordan tall og tekst lagres som bits og bytes,
  • forklare ASCII, Unicode og UTF-8, og bruke riktig tegnkoding når du leser og skriver filer,
  • lese og skrive tekstfiler, CSV og JSON med Python, og velge riktig format,
  • lage en database, og bruke SQL til å legge inn, endre og hente data,
  • hente data fra et API og håndtere feil og manglende nett,
  • forklare og bruke sikkerhetskopier, tilgangsstyring, hashing og kryptering.

8.1 Digital representasjon og tegnkoding

Her ser du hva som skjer helt nederst: hvordan en datamaskin lagrer tall og tekst som bare nuller og enere.

8.1.1 Bits, bytes og tall

En datamaskin består av milliarder av små brytere som enten er på eller av. Alt den lagrer, fra bilder og musikk til dette kapittelet, er til slutt en lang rekke av disse på/av-verdiene, som vi skriver som \(1\) og \(0\). Å forstå hvordan tall kan skrives med bare to sifre, er første steg på veien til å forstå hvordan alt annet lagres.

Læringsmål

Etter dette delkapittelet skal du kunne

  • forklare hva en bit og en byte er, og regne ut hvor mange verdier \(n\) bits kan ha,
  • regne mellom titallsystemet, totallsystemet (binært) og sekstentallsystemet (hex),
  • bruke bin, hex, int og formatering i Python til å konvertere,
  • forklare forskjellen på kB og KiB, og regne ut størrelsen på data.

Bits og bytes

En bit er den minste enheten: ett tall som er enten \(0\) eller \(1\). En byte er \(8\) bits. Med \(n\) bits kan du lage \(2^n\) ulike kombinasjoner, siden hver ekstra bit dobler antallet:

Bits Antall verdier
\(1\) \(2\)
\(2\) \(4\)
\(8\) (en byte) \(256\)
\(16\) \(65\,536\)
\(32\) \(4\,294\,967\,296\)

En byte kan altså ha \(256\) ulike verdier (\(0\) til \(255\)). Trenger du å skille mellom \(300\) ulike ting, må du ha minst \(9\) bits, siden \(2^8 = 256\) er for lite og \(2^9 = 512\) er nok.

RegelAntall verdier

\(n\) bits gir \(2^n\) ulike verdier, fra \(0\) til \(2^n - 1\). For å finne hvor mange bits som trengs for å skille mellom \(N\) ting, finn minste \(n\) slik at \(2^n \geq N\).

Totallsystemet (binære tall)

I titallsystemet har hvert siffer en plass med verdi \(1, 10, 100, \ldots\) (potenser av \(10\)). I totallsystemet er plassverdiene potenser av \(2\): \(1, 2, 4, 8, 16, \ldots\) regnet fra høyre. Tallet \(1010\) i totallsystemet er

\[1\cdot 8 + 0\cdot 4 + 1\cdot 2 + 0\cdot 1 = 10\]

For å gå andre veien, fra titallsystemet til totallsystemet, finner du hvilke plassverdier som går opp i tallet, fra den største. For \(37\): \(32\) går opp (\(37 - 32 = 5\)), \(16\) gjør det ikke, \(8\) gjør det ikke, \(4\) går opp (\(5 - 4 = 1\)), \(2\) gjør det ikke, \(1\) går opp. Sifrene blir \(100101\).

I Python kan du la maskinen gjøre jobben:

print(bin(10))
print(int("1010", 2))
print(0b1010)
print(f"{37:b}")
print(f"{5:08b}")
0b1010
10
10
100101
00000101
  • bin(10) gir teksten '0b1010'. 0b betyr bare «binært tall».
  • int("1010", 2) gjør en tekst med binære sifre om til et vanlig tall. Det andre tallet sier hvilket tallsystem teksten er skrevet i.
  • 0b1010 skrevet rett i koden er det samme som tallet \(10\).
  • f"{37:b}" formaterer tallet binært uten prefiks, og {5:08b} fyller ut til åtte sifre med nuller foran. Det er slik en byte vanligvis skrives.

Skriv \(13\) binært, og \(11001\) som et vanlig tall.

Plassverdiene fra høyre er \(1, 2, 4, 8, 16, \ldots\)

\(13 = 8 + 4 + 1\), så sifrene er \(1101\). Og \(11001 = 16 + 8 + 1 = 25\). Kontroller i Python:

print(f"{13:b}", int("11001", 2))
1101 25

Sekstentallsystemet (hex)

Lange rekker av nuller og enere er vanskelige å lese. Derfor bruker vi ofte sekstentallsystemet (hexadesimal), med \(16\) sifre: \(0\)–\(9\) og så \(\mathrm{a}\)–\(\mathrm{f}\) for verdiene \(10\)–\(15\). Fordelen er at ett hex-siffer er nøyaktig \(4\) bits, så en byte (8 bits) skrives med to hex-sifre.

Binært Hex Tall
0000 0 \(0\)
1001 9 \(9\)
1010 a \(10\)
1111 f \(15\)
11111111 ff \(255\)
print(hex(255))
print(f"{255:x}")
print(int("ff", 16))
print(0xff)
print(f"{200:02x}")
0xff
ff
255
255
c8

Du ser hex i mange sammenhenger: farger på nettsider, feilkoder og adresser i minnet.

Farger som tall

Fargen til en piksel på skjermen lagres som tre bytes: hvor mye rødt, grønt og blått (RGB), hver fra \(0\) til \(255\). På nettsider skrives de som hex: #ff8000 betyr rødt ff (\(255\)), grønt 80 (\(128\)) og blått 00 (\(0\)), altså oransje.

farge = "#ff8000"
r = int(farge[1:3], 16)
g = int(farge[3:5], 16)
b = int(farge[5:7], 16)
print(r, g, b)
print(f"#{r:02x}{g:02x}{b:02x}")
255 128 0
#ff8000

Siden hver av de tre fargene har \(256\) verdier, kan en piksel ha \(256^3 = 16\,777\,216\) ulike farger.

Størrelser: kB, MB og KiB

Datamengder måles i byte med prefikser. Her er det to systemer, og de blandes ofte sammen:

Prefiks (SI, titallspotenser) Antall byte Prefiks (IEC, totallspotenser) Antall byte
kB (kilobyte) \(1\,000\) KiB (kibibyte) \(1\,024\)
MB (megabyte) \(1\,000\,000\) MiB (mebibyte) \(1\,048\,576\)
GB (gigabyte) \(10^9\) GiB (gibibyte) \(2^{30}\)

Bruker du små bokstaver i, er det totallspotenser (\(1\,024 = 2^{10}\)). Lagringsprodusenter bruker titallspotenser, mens enkelte operativsystemer regner med totallspotenser, og det er derfor en disk på «500 GB» ser ut til å være litt mindre på datamaskinen.

Hvor stort er et ukomprimert bilde på \(1920 \times 1080\) piksler med \(3\) bytes per piksel?

bytes_totalt = 1920 * 1080 * 3
print(bytes_totalt)
print(bytes_totalt / 1_000_000)
6220800
6.2208

Omtrent \(6{,}2\) MB. Derfor komprimerer vi bilder (som JPEG og PNG), slik at filene blir mindre.

Hvor mange bits trengs for å nummerere \(300\) elever hver for seg? Og hvor mange verdier har \(10\) bits?

Finn minste \(n\) slik at \(2^n \geq 300\). I Python gir (N - 1).bit_length() svaret.

\(2^8 = 256 < 300 \leq 512 = 2^9\), så du trenger \(9\) bits. \(10\) bits gir \(2^{10} = 1024\) verdier.

print((300 - 1).bit_length())
print(2 ** 10)
9
1024
AdvarselVanlige feil
  • Å lese binære tall fra feil ende. Den minste plassverdien (\(1\)) er helt til høyre.
  • Å blande kB og KiB, og dermed regne feil med \(1000\) i stedet for \(1024\).
  • Å tro at 0b1010 er en tekst. Det er et tall skrevet binært.
  • Å glemme at bin(10) gir en tekst som starter med 0b.
  • Å glemme at \(n\) bits gir verdiene \(0\) til \(2^n - 1\), ikke til \(2^n\).
  • Å regne ut hex-sifre feil: a er \(10\), ikke \(1\).

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Skriv som vanlige tall: a) \(101\), b) \(1111\), c) \(10000\), d) \(11111111\).

Plassverdiene fra høyre er \(1, 2, 4, 8, 16, \ldots\)

  1. \(4 + 1 = 5\). b) \(8 + 4 + 2 + 1 = 15\). c) \(16\). d) \(255\) (\(128 + 64 + 32 + 16 + 8 + 4 + 2 + 1\), eller \(2^8 - 1\)).

Skriv binært: a) \(6\), b) \(19\), c) \(64\), d) \(100\).

Finn de største plassverdiene som går opp i tallet.

  1. \(110\) (\(4 + 2\)). b) \(10011\) (\(16 + 2 + 1\)). c) \(1000000\) (bare \(64\)). d) \(1100100\) (\(64 + 32 + 4\)).

Hvor mange ulike verdier kan a) \(4\) bits, b) \(1\) byte og c) \(2\) bytes ha?

  1. \(2^4 = 16\). b) \(2^8 = 256\). c) \(2^{16} = 65\,536\).
Nivå 2

Skriv hex-tallet 3c binært, og \(10110111\) som hex.

Ett hex-siffer er fire bits.

3 er 0011 og c er $12 = $ 1100, så 3c er 00111100. Dele \(10110111\) i grupper på fire: 1011 er b og 0111 er 7, så hex er b7.

Hvor mange bits trengs for å lagre a) \(100\) ulike verdier, b) alle ukedager, c) alle norske kommuner (omtrent \(360\))?

  1. \(7\) bits (\(2^7 = 128 \geq 100\)). b) \(3\) bits (\(2^3 = 8 \geq 7\)). c) \(9\) bits (\(2^9 = 512 \geq 360\), mens \(2^8 = 256\) er for lite).

Lyd lagres med \(44\,100\) målinger i sekundet, hver på \(2\) bytes, og to kanaler (stereo). Hvor mange MB (SI) er ett minutt ukomprimert?

Antall byte er målinger per sekund · bytes per måling · kanaler · sekunder.

\(44\,100 \cdot 2 \cdot 2 \cdot 60 = 10\,584\,000\) byte, altså omtrent \(10{,}6\) MB. Derfor bruker vi komprimering som MP3.

Kodeoppgaver

Disse oppgavene rettes automatisk.

Skriv funksjonen til_binaer(n) som gir tallet binært som tekst uten prefikset 0b. Bruk ikke bin.

Del på \(2\) gjentatte ganger og samle restene (n % 2) bakfra. Husk tilfellet \(0\).

Skriv funksjonen fra_binaer(tekst) som gjør en tekst med binære sifre om til et tall. Bruk ikke int.

Gå gjennom sifrene fra venstre: dobbel tallet for hvert siffer, og legg til \(1\) hvis sifferet er "1".

Skriv funksjonen bits_trengs(antall) som gir minste antall bits som trengs for å skille mellom antall ulike verdier (minst \(1\) bit).

Dobl et tall til du når antall, og tell hvor mange ganger. Eller bruk (antall - 1).bit_length(), men husk minst \(1\).

Skriv funksjonen til_rgb(farge) som gjør en tekst som "#ff8000" om til tuppelen (255, 128, 0).

int(farge[1:3], 16) gir rødt. Gjør det samme for grønt og blått.

Skriv funksjonen til_hex(r, g, b) som gir fargen som tekst på formen "#ff8000" (små bokstaver, to sifre for hver).

f"{r:02x}" gir to hex-sifre med null foran.

Funksjonen skal gi antall kilobyte (SI, \(1000\) byte) i en fil, avrundet ned. Den bruker feil tall. Rett den.

SI-prefikset kilo betyr tusen.

Utfordringer

Skriv funksjonen hex_til_bin(tekst) som gjør en tekst med hex-sifre (som "3c") om til binære sifre, fire bits per hex-siffer ("00111100").

For hvert siffer: f"{int(siffer, 16):04b}".

En ny disk er oppgitt til \(500\) GB. Operativsystemet viser \(465\) GiB. Er det juks? Forklar med regning.

Regn om \(500\cdot 10^9\) byte til GiB (\(2^{30}\) byte).

Nei. Produsenten bruker SI: \(500\) GB \(= 500 \cdot 10^9\) byte. Operativsystemet deler på \(2^{30} = 1\,073\,741\,824\) og får \(500 \cdot 10^9 / 1\,073\,741\,824 \approx 465{,}7\) GiB. Det er samme mengde, bare ulike enheter (men ofte skrevet «GB» i operativsystemet).

Oppsummering

Antall verdier

\(n\) bits gir \(2^n\) verdier (\(0\) til \(2^n-1\)). En byte er \(8\) bits (\(0\)–\(255\)).

Tallsystemer i Python

bin(10)          # '0b1010'
int("1010", 2)   # 10
hex(255)         # '0xff'
int("ff", 16)    # 255
f"{5:08b}"       # '00000101'
f"{200:02x}"     # 'c8'

Størrelser

  • kB = \(1000\) byte, KiB = \(1024\) byte
  • MB = \(10^6\), MiB = \(2^{20}\)
  • Lavest plassverdi er helt til høyre.
  • Ett hex-siffer er fire bits, to hex-sifre er en byte.
  • Farger er tre bytes (RGB), vist som hex, for eksempel #ff8000.

8.1.2 Tegnkoding og Unicode

Har du noen gang sett «BlÃ¥bær» i stedet for «Blåbær» på en nettside? Da var det feil tegnkoding. Datamaskinen lagrer bare tall, så hver bokstav må få et tall. Kodingen er avtalen om hvilket tall som hører til hvilken bokstav. Hvis avsenderen og mottakeren bruker ulike avtaler, blir resultatet rot.

Læringsmål

Etter dette delkapittelet skal du kunne

  • forklare hva en tegnkoding er, og hva ASCII, Latin-1, Unicode og UTF-8 er,
  • bruke ord, chr, encode og decode i Python,
  • forklare hvorfor tekst kan se feil ut når den leses med feil koding,
  • velge riktig koding når du leser og skriver filer.

Fra ASCII til Unicode

ASCII er en av de eldste standardene. Den gir hvert av \(128\) tegn et tall fra \(0\) til \(127\): store og små bokstaver (uten æøå), sifre, tegnsetting og noen kontrolltegn. Bokstaven A er \(65\), a er \(97\) og 0 er \(48\).

print(ord("A"), ord("a"), ord("0"))
print(chr(65), chr(97))
print(ord("å"))
65 97 48
A a
229

ord gir tallet til et tegn, og chr gir tegnet til et tall. Legg merke til at å har tallet \(229\). Det er utenfor ASCII (\(0\)–\(127\)), så ASCII kan ikke lagre æøå.

Ulike land lagde derfor sine egne utvidelser. Latin-1 (ISO 8859-1) bruker en hel byte (\(256\) tegn) og har æ, ø og å, men ikke for eksempel gresk eller kinesisk. Det ga rot når tekst gikk mellom systemer. Løsningen er Unicode, en standard som gir alle tegn i alle skriftspråk, og emojier, et eget nummer, kalt kodepunkt. Kodepunktet skrives U+ og hex: å er U+00E5, € er U+20AC og 😀 er U+1F600.

print(hex(ord("å")))
print(hex(ord("€")))
print(hex(ord("😀")))
print(chr(0x1F600))
0xe5
0x20ac
0x1f600
😀

Unicode sier hvilket nummer hvert tegn har, men ikke hvordan nummeret lagres som bytes. Det bestemmes av en koding. Den vanligste er UTF-8.

UTF-8

UTF-8 lagrer hvert tegn med \(1\) til \(4\) bytes. Tegn i ASCII bruker bare én byte, og er helt like som i ASCII. Andre tegn trenger flere:

for tegn in ["A", "å", "€", "😀"]:
    b = tegn.encode("utf-8")
    print(tegn, b, len(b))
A b'A' 1
å b'\xc3\xa5' 2
€ b'\xe2\x82\xac' 3
😀 b'\xf0\x9f\x98\x80' 4

encode gjør tekst om til bytes (et bytes-objekt, skrevet b'...'), og decode gjør bytes om til tekst igjen. \xc3\xa5 betyr de to bytene c3 og a5 i hex. Så å tar to bytes i UTF-8, € tre og 😀 fire.

Det betyr at antall tegn og antall bytes ikke alltid er det samme:

ord_ = "Blåbær"
print(len(ord_))
print(len(ord_.encode("utf-8")))
6
8

Ordet har \(6\) tegn, men \(8\) bytes, siden å og æ hver trenger to. UTF-8 er i dag standard på nettet, i Python og i de fleste filer. Den er også kompatibel med ASCII: en ren engelsk tekst er lik i begge.

RegelTegnkoding
  • Unicode gir hvert tegn et kodepunkt (et tall).
  • UTF-8 er en måte å lagre kodepunktene som bytes: \(1\)–\(4\) bytes per tegn.
  • Bruk UTF-8 når du ikke har en grunn til å bruke noe annet.
  • tekst.encode("utf-8") gir bytes. bytes.decode("utf-8") gir tekst.

Når kodingen blir feil

Rotet oppstår når bytes leses med en annen koding enn de ble skrevet med. Her skriver vi «Blåbær» som UTF-8, men leser bytene som om de var Latin-1:

bytes_ = "Blåbær".encode("utf-8")
print(bytes_.decode("latin-1"))
print(bytes_.decode("utf-8"))
Blåbær
Blåbær

Hver UTF-8-byte for å og æ leses som et eget Latin-1-tegn, og vi får Ã¥ og æ. Det motsatte skjer også: en gammel fil som er lagret som Latin-1, kan gi en feilmelding når du leser den som UTF-8:

try:
    b"Bl\xe5b\xe6r".decode("utf-8")
except UnicodeDecodeError as feil:
    print("UnicodeDecodeError:", feil)
print(b"Bl\xe5b\xe6r".decode("latin-1"))
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xe5 in position 2: invalid continuation byte
Blåbær

Bytene e5 og e6 er å og æ i Latin-1, men ikke gyldig UTF-8, så Python klager. Når du leser en fil du ikke kjenner, og får UnicodeDecodeError eller rare tegn som Ã¥, er kodingen nesten alltid feil. Prøv encoding="latin-1" (eller "cp1252", som Windows ofte bruker) hvis UTF-8 feiler.

Teksten «Hei» lagres som UTF-8. Hvilke bytes er det? Og hvor mange bytes er «Øl»?

H, e og i er i ASCII. Ø er ikke det.

H er \(72\), e er \(101\) og i er \(105\), så «Hei» er tre bytes. Ø er utenfor ASCII og tar to bytes, mens l tar en, så «Øl» er tre bytes:

print(list("Hei".encode("utf-8")))
print(len("Øl".encode("utf-8")))
[72, 101, 105]
3

Koding i filer

Når du leser og skriver tekstfiler (se 8.2.1), må du si hvilken koding du bruker, med encoding="utf-8". Hvis du ikke gjør det, bruker Python standarden til operativsystemet, og den kan variere mellom maskiner (særlig på Windows). Da kan et program som virker hos deg, gi rot hos en annen.

with open("navn.txt", "w", encoding="utf-8") as fil:
    fil.write("Blåbær\n")

Skriv alltid encoding="utf-8". En fil fra Excel kan starte med en usynlig markør (BOM) først i fila. Da kan du lese den med encoding="utf-8-sig", som fjerner markøren.

NoteSortering og store bokstaver

Python sorterer tekst etter kodepunkt. sorted(["å", "a", "z", "ø", "æ"]) gir ['a', 'z', 'å', 'æ', 'ø'], siden å (\(229\)) har lavere kodepunkt enn æ (\(230\)) og ø (\(248\)), men det norske alfabetet har rekkefølgen æ, ø, å. For riktig norsk sortering må du bruke egne regler (locale-modulen) eller sortere med en nøkkel.

AdvarselVanlige feil
  • Å la være å oppgi encoding når du åpner en fil, og få ulik oppførsel på ulike maskiner.
  • Å tro at antall tegn er lik antall bytes.
  • Å lese en Latin-1-fil som UTF-8, eller omvendt.
  • Å blande str (tekst) og bytes. Du kan ikke legge dem sammen uten å decode eller encode.
  • Å tro at «Unicode» er en koding. Unicode er nummereringen, og UTF-8 er en koding av den.
  • Å fikse rotet med å bytte tegn for hånd, i stedet for å finne riktig koding.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hva gir disse uttrykkene? a) ord("B"), b) chr(100), c) ord("a") - ord("A"), d) chr(ord("a") + 1).

A er \(65\) og a er \(97\).

  1. \(66\). b) 'd' (\(97 + 3\)). c) \(32\) (avstanden mellom store og små bokstaver). d) 'b'.

Hvor mange bytes er disse tekstene i UTF-8? a) «hei», b) «å», c) «Bergen», d) «Tromsø».

Tegn i ASCII tar én byte. Æ, ø og å tar to.

  1. \(3\). b) \(2\). c) \(6\). d) \(7\) (seks tegn, men ø tar to bytes).

Forklar med egne ord hvorfor «å» kan bli til «Ã¥» når du åpner en fil.

Filen er lagret som UTF-8, der «å» er to bytes (c3 og a5). Programmet som åpner den, leser bytene som Latin-1 (eller en lignende koding), der hver byte er ett tegn: c3 blir «Ã» og a5 blir «¥». Kodingen som brukes ved lesing, må være den samme som ved skriving.

Nivå 2
tekst = "Øl"
b = tekst.encode("utf-8")
print(len(tekst), len(b))
print(b.decode("latin-1"))

Ø er to bytes i UTF-8. Latin-1 leser hver byte som ett tegn.

2 3 og Ã\x98l: «Øl» er to tegn, men tre bytes. Leses de tre bytene som Latin-1, blir det tre tegn, der de to første er à og et usynlig kontrolltegn (\x98), og så l. Det vises på skjermen som «Ã«l» eller liknende.

Du får en gammel fil som gir UnicodeDecodeError når du åpner den med UTF-8. Hva prøver du, og hvordan finner du ut om det virket?

Prøv encoding="latin-1" eller "cp1252", som gamle norske filer ofte bruker. Det virket hvis æ, ø og å ser riktige ut i teksten (og ikke som æ, ø, Ã¥). Når du så skriver fila på nytt, kan du lagre den som UTF-8.

sorted(["å", "æ", "ø"]) gir ['å', 'æ', 'ø'], men i alfabetet kommer å sist. Forklar, og foreslå en løsning.

Python sorterer etter kodepunkt: å er \(229\), æ er \(230\) og ø er \(248\). Norsk rekkefølge er æ, ø, å, som ikke følger kodepunktene. Løsningen er å sortere med en nøkkel som gir hvert tegn riktig plass (for eksempel "abcdefghijklmnopqrstuvwxyzæøå".index(tegn)), eller bruke locale.

Kodeoppgaver

Skriv funksjonen rot13(tekst) som flytter hver bokstav \(13\) plasser fram i alfabetet (a–z og A–Z, med omlegging fra z til a). Andre tegn endres ikke. Bruk ord og chr.

For en liten bokstav: chr((ord(b) - ord("a") + 13) % 26 + ord("a")). Gjør tilsvarende for store.

Skriv funksjonen antall_bytes(tekst) som gir antall bytes teksten tar i UTF-8.

len(tekst.encode("utf-8")).

Teksten rotete er UTF-8-bytes som feilaktig ble lest som Latin-1. Skriv funksjonen fiks(rotete) som gir den riktige teksten tilbake.

Gjør teksten om til bytes igjen med riktig koding (Latin-1), og så til tekst med riktig koding (UTF-8).

Skriv funksjonen sorter_norsk(ordene) som sorterer en liste med ord etter det norske alfabetet (a–z, så æ, ø, å). Anta at alle ord bare har små bokstaver fra dette alfabetet.

Bruk key= med en funksjon som gir hver bokstav sin plass i "abcdefghijklmnopqrstuvwxyzæøå".

Funksjonen skal gi antall tegn i en fil som er lest som bytes, men gir antall bytes. Rett den.

Gjør bytene om til tekst først.

Utfordringer

Skriv funksjonene krypter(tekst, nokkel) og dekrypter(tekst, nokkel) som flytter små og store bokstaver (a–z, A–Z) nokkel plasser fram (eller tilbake). Andre tegn endres ikke.

dekrypter er det samme som å kryptere med -nokkel. Bruk % slik at negative tall også virker.

Gi tre grunner til at UTF-8 har blitt standarden for tekst.

  1. Den dekker alle tegn i alle språk (hele Unicode), også emojier. 2. Den er kompatibel med ASCII: ren engelsk tekst er byte for byte lik, så eldre filer og programmer virker. 3. Den bruker bare så mange bytes som trengs (én for ASCII, opp til fire for sjeldne tegn), så filer med mest engelsk tekst blir små. I tillegg er den entydig, slik at et program kan finne ut hvor hvert tegn begynner.

Oppsummering

Tegn og tall

ord("A")      # 65
chr(65)       # 'A'
ord("å")      # 229

Tekst og bytes

b = "å".encode("utf-8")   # b'\xc3\xa5'
b.decode("utf-8")         # 'å'
len("å"), len(b)          # 1, 2

Standarder

  • ASCII: 128 tegn (uten æøå)
  • Latin-1: 256 tegn, én byte hver
  • Unicode: nummer til alle tegn
  • UTF-8: 1–4 bytes per tegn
  • Bruk encoding="utf-8" når du åpner filer.
  • Ã¥ i stedet for å betyr feil koding.
  • Antall tegn og antall bytes er ikke alltid det samme.

8.2 Filer: tekst, CSV og JSON

Nå skal programmene dine huske ting til neste gang. Du lærer å lese og skrive vanlige tekstfiler, og to formater som programmer bruker til å utveksle data: CSV (tabeller) og JSON (strukturerte data).

8.2.1 Tekstfiler og pathlib

Når programmet slutter, forsvinner alle variablene. Vil du ta vare på noe til neste gang, som en høyscore, en handleliste eller resultatene fra en måling, må du skrive det til en fil. Filer ligger på disken, og overlever at programmet og maskinen slås av. En tekstfil er den enkleste typen: bare tegn, som du kan åpne i hvilket som helst program.

Læringsmål

Etter dette delkapittelet skal du kunne

  • åpne, lese og skrive tekstfiler med open og with,
  • bruke modusene "r", "w" og "a", og oppgi encoding,
  • bruke pathlib.Path til å bygge filbaner og sjekke om filer finnes,
  • håndtere at en fil ikke finnes.

Skrive og lese en fil

I eksemplene under bruker vi en midlertidig mappe, så vi ikke legger igjen filer på maskinen din. Det er den første cellen under. I din egen kode jobber du bare i mappen du er i.

import os, tempfile
os.chdir(tempfile.mkdtemp())      # en tom, midlertidig mappe
print(os.listdir("."))
[]

Slik skriver du til en fil:

with open("handleliste.txt", "w", encoding="utf-8") as fil:
    fil.write("melk\n")
    fil.write("brød\n")
    fil.write("ost\n")

print(os.listdir("."))
['handleliste.txt']
  • open("handleliste.txt", "w", encoding="utf-8") åpner fila for skriving ("w" som write). Finnes den ikke, lages den. Finnes den, slettes innholdet først.
  • with ... as fil: sørger for at fila lukkes når blokken er ferdig, selv om det skjer en feil. Uten with kan data gå tapt hvis du glemmer å lukke fila.
  • fil.write(tekst) skriver tekst. Den legger ikke til linjeskift, så vi skriver \n selv.

Slik leser du den tilbake:

with open("handleliste.txt", "r", encoding="utf-8") as fil:
    innhold = fil.read()

print(innhold)
print(repr(innhold))
melk
brød
ost

'melk\nbrød\nost\n'

read() gir hele fila som én tekst, med linjeskift (\n) mellom linjene. repr viser de usynlige tegnene. Oftest vil du ha linje for linje. Da kan du løpe gjennom fil-objektet:

with open("handleliste.txt", encoding="utf-8") as fil:
    for linje in fil:
        print(linje.strip())
melk
brød
ost

Hver linje slutter med \n, og strip() fjerner det. Modusen "r" (lese) er standard, så du trenger ikke skrive den. Vil du ha alle linjene i en liste, bruker du fil.readlines() eller fil.read().splitlines():

with open("handleliste.txt", encoding="utf-8") as fil:
    varer = fil.read().splitlines()
print(varer)
['melk', 'brød', 'ost']
RegelModuser for open
Modus Betydning Hvis fila finnes
"r" lese (standard) leser den; feil hvis den ikke finnes
"w" skrive sletter innholdet
"a" legge til på slutten beholder innholdet
"x" lage ny feil hvis den finnes

Skriv alltid with open(...) as fil: og encoding="utf-8".

Vil du legge til noe uten å slette det som står der fra før, bruker du "a":

with open("handleliste.txt", "a", encoding="utf-8") as fil:
    fil.write("kaffe\n")

with open("handleliste.txt", encoding="utf-8") as fil:
    print(fil.read().splitlines())
['melk', 'brød', 'ost', 'kaffe']

Du kan også bruke print med file=, som legger til linjeskift selv:

with open("handleliste.txt", "a", encoding="utf-8") as fil:
    print("te", file=fil)

Skriv koden som teller hvor mange linjer handleliste.txt har nå, og hva som er den siste varen.

Les linjene til en liste med read().splitlines().

with open("handleliste.txt", encoding="utf-8") as fil:
    linjer = fil.read().splitlines()
print(len(linjer), linjer[-1])
5 te

Når fila ikke finnes

Prøver du å lese en fil som ikke finnes, får du FileNotFoundError. Det er en feil du bør vente, så den passer til try/except fra kapittel 4:

try:
    with open("finnes_ikke.txt", encoding="utf-8") as fil:
        data = fil.read()
except FileNotFoundError:
    data = ""
    print("Fant ikke fila, starter med tomt innhold")
Fant ikke fila, starter med tomt innhold

Dette er et vanlig mønster for en høyscore-fil: første gang finnes den ikke, og programmet starter med et tomt resultat.

Filbaner med pathlib

En filbane sier hvor fila ligger. En relativ bane ("data/tall.txt") regnes fra mappen programmet kjører i, mens en absolutt bane starter helt fra roten (C:\Users\... eller /home/...). Modulen pathlib gir deg Path-objekter, som er mer praktiske og virker likt på Windows, Mac og Linux, uten at du må bry deg om / eller \.

from pathlib import Path

mappe = Path("data")
fil = mappe / "tall.txt"
print(fil)
print(fil.name, fil.stem, fil.suffix)
print(fil.parent)
data/tall.txt
tall.txt tall .txt
data

Operatoren / setter sammen deler av banen. name er filnavnet, stem er navnet uten endelse, suffix er endelsen og parent er mappen over. Du kan også spørre om ting finnes, og lage og lese filer:

mappe.mkdir(exist_ok=True)
fil.write_text("1\n2\n3\n", encoding="utf-8")

print(mappe.exists(), fil.exists(), fil.is_file(), mappe.is_dir())
print(fil.read_text(encoding="utf-8").split())
True True True True
['1', '2', '3']

mkdir(exist_ok=True) lager mappen, uten feil hvis den finnes fra før (bruk parents=True for å lage flere nivåer samtidig). write_text og read_text skriver og leser en hel fil med én kommando. Du kan liste innholdet i en mappe:

for sti in sorted(Path(".").iterdir()):
    print(sti)
print([f.name for f in Path(".").glob("*.txt")])
data
handleliste.txt
['handleliste.txt']

iterdir() gir alt i mappen, og glob("*.txt") gir bare filene som passer mønsteret.

Skriv koden som gir navnene (uten mappe) på alle .txt-filene i data, sortert.

Path("data").glob("*.txt") gir Path-objekter, og .name gir navnet.

print(sorted(f.name for f in Path("data").glob("*.txt")))
['tall.txt']
NoteHvor er jeg?

Får du FileNotFoundError selv om fila finnes, er det nesten alltid fordi programmet kjører i en annen mappe enn du tror. Sjekk med Path.cwd() hvor du er. I VS Code bestemmes dette av mappen du har åpnet og hvordan du starter programmet. En trygg måte er å bygge banen ut fra filen programmet ligger i: Path(__file__).parent / "data" / "tall.txt".

AdvarselVanlige feil
  • Å åpne med "w" og slette innholdet ved et uhell. Bruk "a" hvis du vil legge til.
  • Å glemme \n når du skriver linjer med write.
  • Å glemme strip() og få \n med i teksten.
  • Å glemme encoding="utf-8".
  • Å lese fila to ganger med samme fil-objekt. Etter første gjennomlesing er du på slutten, og får ingenting.
  • Å glemme with, og la fila stå åpen.
  • Å skrive tall til fil uten å gjøre dem om til tekst (str(tall)), og lese dem tilbake uten å gjøre dem om til tall (int(...)).
  • Å bruke en relativ filbane når programmet kjører i en annen mappe.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1
with open("a.txt", "w", encoding="utf-8") as fil:
    fil.write("en\n")
with open("a.txt", "w", encoding="utf-8") as fil:
    fil.write("to\n")
with open("a.txt", "a", encoding="utf-8") as fil:
    fil.write("tre\n")

Hva står i fila til slutt?

Hva gjør "w" med en fil som finnes?

to og tre, på hver sin linje. Den andre åpningen ("w") slettet en, og den tredje ("a") la tre til på slutten.

Hvilken modus passer: "r", "w" eller "a"?

Lese en høyscore-fil.
"r". b) "w" (erstatter alt). c) "a" (beholder det som står).
Lagre en helt ny versjon av innstillingene.
Legge en ny linje i en loggfil.

Hva gir Path("data/2026/tall.csv") for a) .name, b) .stem, c) .suffix, d) .parent?

  1. tall.csv. b) tall. c) .csv. d) data/2026.
Nivå 2
with open("tall.txt", "w", encoding="utf-8") as fil:
    for i in range(3):
        fil.write(i)

Hva skjer, og hvordan rettes det?

Hva slags verdi tar write?

Det gir TypeError: write() argument must be str, not int. write vil ha tekst. Rett med fil.write(str(i) + "\n") (og husk linjeskift, ellers blir det 012 på én linje).

with open("x.txt", "w", encoding="utf-8") as fil:
    fil.write("a\nb\nc\n")

with open("x.txt", encoding="utf-8") as fil:
    forste = fil.readline()
    resten = fil.read()
print(repr(forste))
print(repr(resten))

'a\n' og 'b\nc\n'. readline() leser én linje (med \n), og read() leser resten derfra.

Gjør det på maskinen

Lag programmet dagbok.py i VS Code. Det spør brukeren om en setning, og legger den til på slutten av fila dagbok.txt, etterfulgt av dagens dato (from datetime import date, date.today()). Så skriver det ut hele dagboka. Kjør programmet tre ganger. Finn fila i filutforskeren i VS Code, og åpne den. Hva skjer hvis du bytter "a" med "w"?

from datetime import date

linje = input("Hva skjedde i dag? ")
with open("dagbok.txt", "a", encoding="utf-8") as fil:
    fil.write(f"{date.today()}: {linje}\n")

with open("dagbok.txt", encoding="utf-8") as fil:
    print(fil.read())

Med "w" blir dagboka slettet hver gang, så den bare har siste innlegg. Med "a" vokser den. Hvis du kjører programmet fra en annen mappe enn den fila ligger i, lages en ny dagbok.txt der. Sjekk med Path.cwd() hvor du er.

Skriv et program som skriver ut navnet og størrelsen i byte til alle filene i mappen programmet ligger i, sortert etter navn. Bruk Path(__file__).parent, iterdir(), is_file() og stat().st_size.

from pathlib import Path

mappe = Path(__file__).parent
for sti in sorted(mappe.iterdir()):
    if sti.is_file():
        print(sti.name, sti.stat().st_size)
Kodeoppgaver

Disse oppgavene rettes automatisk, og bruker midlertidige mapper.

Skriv funksjonen skriv_linjer(sti, linjer) som skriver hver tekst i lista på sin egen linje i fila (UTF-8).

with open(sti, "w", encoding="utf-8") as fil: og fil.write(linje + "\n") for hver linje.

Skriv funksjonen les_linjer(sti) som gir lista med linjene i fila uten linjeskift. Finnes ikke fila, gir den en tom liste.

Bruk try/except FileNotFoundError, og fil.read().splitlines().

Skriv funksjonen legg_til(sti, tekst) som legger teksten til på slutten av fila som en ny linje. Lager fila hvis den ikke finnes.

Modusen "a" lager fila hvis den ikke finnes, og beholder innholdet hvis den finnes.

Skriv funksjonen tell_ord(sti) som gir antall ord i fila (ord er skilt med mellomrom eller linjeskift).

len(fil.read().split()) deler på all hvitt rom.

Skriv funksjonen hoyeste(sti) som leser en fil med ett heltall per linje og gir det høyeste. Er fila tom eller mangler den, gir funksjonen \(0\).

Gjør hver linje om til int, og bruk max(..., default=0).

Skriv funksjonen filer_med(mappe, endelse) som gir sortert liste med navnene på filene i mappen som slutter med endelsen (for eksempel ".txt"). Undermapper telles ikke med.

Path(mappe).iterdir(), og sjekk sti.is_file() og sti.suffix == endelse.

Funksjonen skal legge en linje til i loggen, men sletter loggen hver gang. Rett den.

Hvilken modus beholder det som står i fila?

Utfordringer

Skriv funksjonen hyppigste_ord(sti) som gir det ordet som forekommer oftest i fila (små og store bokstaver er like, og tegn som .,!? ignoreres). Er det uavgjort, gir den det som kommer først alfabetisk. Tom fil gir None.

Gjør teksten til små bokstaver, fjern tegnsetting, del i ord og tell i en ordbok. Finn største antall, og velg det alfabetisk første med min.

Hva er fordelen med with open(...) as fil: i stedet for fil = open(...) og fil.close()?

with sørger for at fila lukkes automatisk når blokken er ferdig, også hvis det oppstår en feil midt i. Med close() for hånd kan en feil gjøre at linja aldri kjøres, og fila blir stående åpen. Da kan data som ligger i et mellomlager aldri bli skrevet til disken, og andre programmer kan bli hindret i å bruke fila.

Oppsummering

Skrive og lese

with open("a.txt", "w", encoding="utf-8") as f:
    f.write("tekst\n")

with open("a.txt", encoding="utf-8") as f:
    for linje in f:
        print(linje.strip())

Moduser

  • "r" lese · "w" skrive (sletter)
  • "a" legge til · "x" lage ny

pathlib

from pathlib import Path
sti = Path("data") / "tall.txt"
sti.exists(); sti.name; sti.suffix
sti.write_text("1\n", encoding="utf-8")
sti.read_text(encoding="utf-8")
list(Path(".").glob("*.txt"))
  • with lukker fila for deg. Oppgi alltid encoding="utf-8".
  • "w" sletter det som stod der. Bruk "a" for å legge til.
  • FileNotFoundError: sjekk Path.cwd().

8.2.2 CSV

Mange datasett er tabeller: rader med de samme kolonnene, som temperaturer per dag eller elever med karakterer. Det vanligste formatet for slike data er CSV (comma-separated values): en tekstfil der hver linje er en rad, og kolonnene er skilt med et tegn, vanligvis komma. Alle regneark og de fleste programmer kan lese og skrive CSV, og det er derfor det er så mye brukt til utveksling av data.

Læringsmål

Etter dette delkapittelet skal du kunne

  • forklare hvordan en CSV-fil er bygget opp,
  • lese og skrive CSV med csv.reader, csv.DictReader og csv.writer,
  • håndtere skilletegn, overskriftsrad og tall som tekst,
  • forklare hvorfor vi bruker modulen csv og ikke bare split(",").

Hvordan en CSV-fil ser ut

Her er en liten CSV-fil. Første linje er overskriftene, og de neste er dataene:

navn,klasse,poeng
Kari,2IT,45
Ola,2IT,38
Mia,3IT,51

Hvis du åpner den i Excel, ser du en tabell. Åpner du den i en teksteditor, ser du bare linjene over. Slik leser du den med Python. Vi lager først fila (i en midlertidig mappe), og så leser vi den:

import csv, os, tempfile
os.chdir(tempfile.mkdtemp())

with open("elever.csv", "w", encoding="utf-8") as fil:
    fil.write("navn,klasse,poeng\nKari,2IT,45\nOla,2IT,38\nMia,3IT,51\n")

with open("elever.csv", encoding="utf-8", newline="") as fil:
    leser = csv.reader(fil)
    for rad in leser:
        print(rad)
['navn', 'klasse', 'poeng']
['Kari', '2IT', '45']
['Ola', '2IT', '38']
['Mia', '3IT', '51']

csv.reader gir hver linje som en liste av tekster. Første rad er overskriftene. Merk at "45" er en tekst, ikke et tall: CSV lagrer ikke typer, så du må gjøre om til int eller float selv. Når du åpner fila for CSV, bruker du newline="", så Python ikke rører linjeskiftene (CSV-modulen tar seg av dem).

Ofte er det bedre å få hver rad som en ordbok, med overskriftene som nøkler. Da slipper du å huske hvilken kolonne som er hva:

with open("elever.csv", encoding="utf-8", newline="") as fil:
    elever = list(csv.DictReader(fil))

print(elever[0])
print(elever[0]["navn"])
total = sum(int(e["poeng"]) for e in elever)
print(total)
{'navn': 'Kari', 'klasse': '2IT', 'poeng': '45'}
Kari
134

DictReader bruker første rad som nøkler. Hver rad blir en ordbok der verdiene er tekster. Her summerer vi poengene ved å gjøre dem om til int.

RegelLese CSV
import csv
with open("fil.csv", encoding="utf-8", newline="") as fil:
    for rad in csv.DictReader(fil):
        print(rad["kolonne"])
  • csv.reader: hver rad er en liste.
  • csv.DictReader: hver rad er en ordbok med overskriftene som nøkler.
  • Alle verdier er tekst. Gjør om med int(...) og float(...).

Skrive CSV

Du skriver CSV med csv.writer eller csv.DictWriter:

ny = [
    {"navn": "Eva", "klasse": "3IT", "poeng": 60},
    {"navn": "Jon", "klasse": "2IT", "poeng": 29},
]

with open("nye.csv", "w", encoding="utf-8", newline="") as fil:
    skriver = csv.DictWriter(fil, fieldnames=["navn", "klasse", "poeng"])
    skriver.writeheader()
    skriver.writerows(ny)

print(open("nye.csv", encoding="utf-8").read())
navn,klasse,poeng
Eva,3IT,60
Jon,2IT,29

DictWriter trenger å vite rekkefølgen på kolonnene (fieldnames). writeheader() skriver overskriftsraden, og writerows skriver alle radene. Med csv.writer(fil) skriver du lister: skriver.writerow(["Eva", "3IT", 60]).

Hvorfor ikke bare split?

Du kan fristes til å bruke linje.split(","). Det går bra helt til en verdi selv inneholder et komma. I CSV settes slike verdier i anførselstegn:

navn,kommentar
Kari,"Bra, men kan bli bedre"
linje = 'Kari,"Bra, men kan bli bedre"'
print(linje.split(","))
print(next(csv.reader([linje])))
['Kari', '"Bra', ' men kan bli bedre"']
['Kari', 'Bra, men kan bli bedre']

split deler på alle komma og gir tre biter, mens csv.reader forstår anførselstegnene og gir to. Det finnes flere slike unntak (anførselstegn inni verdier, linjeskift inni verdier), og modulen kan dem alle. CSV har en offisiell standard (RFC 4180), og csv følger den.

Du har CSV-data som en tekst (ikke en fil). Les den og regn ut gjennomsnittet av poeng.

data = "navn,poeng\nKari,45\nOla,38\nMia,51\n"

io.StringIO(data) lager et «fil-objekt» av en tekst, som csv kan lese.

import io
data = "navn,poeng\nKari,45\nOla,38\nMia,51\n"
rader = list(csv.DictReader(io.StringIO(data)))
poeng = [int(r["poeng"]) for r in rader]
print(sum(poeng) / len(poeng))
44.666666666666664

Andre skilletegn og norske tall

I Norge bruker Excel ofte semikolon som skilletegn, fordi vi skriver desimaltall med komma (3,14). En «CSV» fra norsk Excel ser derfor ofte slik ut:

navn;temperatur
Oslo;3,5
Bergen;7,2

Du sier hvilket skilletegn du bruker med delimiter=";", og må selv bytte komma med punktum før du gjør om til float:

data = "navn;temperatur\nOslo;3,5\nBergen;7,2\n"
rader = list(csv.DictReader(io.StringIO(data), delimiter=";"))
temperaturer = [float(r["temperatur"].replace(",", ".")) for r in rader]
print(temperaturer)
[3.5, 7.2]

Når du får en fil fra Excel, kan den også starte med en usynlig markør (BOM). Åpne den da med encoding="utf-8-sig" (se 8.1.2). Møter du en ukjent CSV, så åpne den i en teksteditor først, og se hva som er skilletegn og kodingen.

NoteCSV og eksamen

På eksamen får du ofte data som en CSV-fil. Øv på å lese den med csv.DictReader, gjøre om kolonner til tall, og regne ut summer, gjennomsnitt og største verdi. For store datasett bruker vi pandas (kapittel 9), men csv er alltid tilgjengelig.

AdvarselVanlige feil
  • Å glemme at alle verdier er tekst, og få "45" + "38" som "4538".
  • Å bruke split(",") i stedet for csv, og få feil når en verdi inneholder komma.
  • Å glemme newline="" når du åpner CSV-filer.
  • Å glemme delimiter=";" for filer fra norsk Excel.
  • Å ikke bytte komma med punktum i desimaltall.
  • Å glemme overskriftsraden, så den leses som data.
  • Å glemme fieldnames eller writeheader() med DictWriter.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hva gir list(csv.reader(...)) for denne teksten?

a,b
1,2

[['a', 'b'], ['1', '2']]. Hver rad er en liste, og alle verdier er tekst, også tallene.

Hva er forskjellen, og når passer hver?

csv.reader gir hver rad som en liste, så du må huske hvilken plass hver kolonne har (rad[2]). DictReader gir en ordbok med overskriftene som nøkler (rad["poeng"]), og er mer lesbar og tåler at rekkefølgen på kolonnene endres. Bruk DictReader når fila har overskrifter, og reader når den ikke har det.

Nivå 2
rader = list(csv.DictReader(open("elever.csv", encoding="utf-8")))
snitt = sum(r["poeng"] for r in rader) / len(rader)

Hva slags verdier er r["poeng"]?

Alle verdier fra CSV er tekst, så sum prøver å legge sammen tekster og gir TypeError. Rett med int(r["poeng"]).

Du får en CSV-fil fra norsk Excel, og csv.reader gir én lang tekst per rad i stedet for kolonner. Hva er sannsynligvis galt, og hvordan retter du det?

Fila bruker semikolon som skilletegn (siden norsk Excel bruker komma i desimaltall). Rett med csv.reader(fil, delimiter=";"). Desimaltall som 3,5 må du også gjøre om med .replace(",", ".") før float.

Gjør det på maskinen

Lag en CSV-fil karakterer.csv i VS Code (med en teksteditor, ikke Excel) med kolonnene navn, fag og karakter, og minst åtte rader. Skriv et program som leser fila og skriver ut gjennomsnittskarakteren per elev. Åpne også fila i Excel eller et annet regneark, og se at den ser ut som en tabell.

import csv

summer = {}
antall = {}
with open("karakterer.csv", encoding="utf-8", newline="") as fil:
    for rad in csv.DictReader(fil):
        navn = rad["navn"]
        summer[navn] = summer.get(navn, 0) + int(rad["karakter"])
        antall[navn] = antall.get(navn, 0) + 1

for navn in summer:
    print(navn, round(summer[navn] / antall[navn], 2))
Kodeoppgaver

I disse oppgavene får du CSV som en tekst, slik at du slipper filer.

Skriv funksjonen les_csv(tekst) som gir en liste av ordbøker (en per rad, med overskriftene som nøkler). Verdiene er tekst.

list(csv.DictReader(io.StringIO(tekst))).

Skriv funksjonen sum_kolonne(tekst, kolonne) som gir summen av heltallene i kolonnen.

Les med DictReader og summer int(rad[kolonne]).

Skriv funksjonen norsk_csv(tekst) som leser CSV med semikolon som skilletegn og komma som desimaltegn. Den gir en liste av ordbøker der kolonnen "verdi" er gjort om til float.

delimiter=";", og float(rad["verdi"].replace(",", ".")).

Skriv funksjonen til_csv(rader, kolonner) som gir CSV-tekst (som en tekst) fra en liste av ordbøker, med overskriftsrad først. Bruk csv.writer og io.StringIO. Linjeskift skal være \n.

csv.writer(ut, lineterminator="\n") skriver \n mellom linjene. Skriv overskriftene med writerow(kolonner), og hver rad som [rad[k] for k in kolonner].

Funksjonen skal gi antall kolonner i første rad, men gir feil svar når en verdi inneholder komma. Rett den.

La csv.reader lese første rad.

Skriv funksjonen snitt_per_klasse(tekst) som tar CSV med kolonnene klasse og poeng, og gir en ordbok fra klasse til gjennomsnittlig poeng.

Samle poengene i en liste per klasse i en ordbok, og regn gjennomsnittet til slutt.

Utfordringer

Skriv funksjonen gyldige(tekst) som leser CSV med kolonnene navn og alder, og gir lista med navnene til dem som har en alder som er et heltall mellom \(0\) og \(120\). Rader med alder som ikke er et tall (som "ukjent" eller tomt), hoppes over.

Prøv int(...) i en try/except ValueError.

Gi to fordeler og to ulemper med CSV som format for datautveksling.

Fordeler: alle regneark og programmeringsspråk kan lese og skrive det, og det er en enkel tekstfil som kan åpnes og leses i en teksteditor. Ulemper: det lagrer ingen typer (alt er tekst, også tall og datoer), og det passer dårlig til data med en struktur (lister inni verdier, nivåer), og skilletegn og koding varierer mellom systemer.

Oppsummering

Lese

import csv
with open("f.csv", encoding="utf-8", newline="") as f:
    for rad in csv.DictReader(f):
        print(rad["kolonne"])

Skrive

with open("f.csv", "w", encoding="utf-8", newline="") as f:
    w = csv.DictWriter(f, fieldnames=["a", "b"])
    w.writeheader()
    w.writerows(rader)

Norsk CSV

csv.DictReader(f, delimiter=";")
float(tekst.replace(",", "."))
  • Alle verdier fra CSV er tekst.
  • Bruk csv, ikke split(",").
  • newline="" og encoding="utf-8" (eller "utf-8-sig" fra Excel).

8.2.3 JSON

CSV passer for tabeller, men hva om dataene har en struktur: en elev med et navn, en liste av fag, og for hvert fag en karakter og en dato? Da trenger vi et format som kan ha lister og ordbøker inni hverandre. Det er JSON (JavaScript Object Notation), som er det mest brukte formatet for datautveksling på nettet. JSON ser omtrent ut som Python-ordbøker og lister, noe som gjør det veldig enkelt å bruke fra Python.

Læringsmål

Etter dette delkapittelet skal du kunne

  • lese og forstå JSON-tekst, og vite hvilke Python-typer den tilsvarer,
  • lese og skrive JSON med json.loads, json.dumps, json.load og json.dump,
  • hente ut verdier fra nøstede strukturer,
  • lagre og gjenopprette objekter som JSON,
  • velge mellom CSV og JSON.

JSON-formatet

Her er en elev som JSON:

{
  "navn": "Kari",
  "alder": 17,
  "aktiv": true,
  "fag": ["IT2", "Matte"],
  "adresse": {"by": "Bergen", "postnummer": "5003"},
  "veileder": null
}

JSON har seks typer verdier, og de tilsvarer nesten Python:

JSON Python
objekt {"a": 1} dict
liste [1, 2] list
tekst "hei" str
tall 3, 3.5 int, float
true, false True, False
null None

Reglene er strengere enn i Python: nøklene må være tekst i doble anførselstegn (ikke enkle), det er ikke lov med komma etter siste element, og true/false/null skrives med små bokstaver.

Lese JSON

Med json.loads («load string») gjør du en JSON-tekst om til Python-objekter. Det kalles å deserialisere:

import json

tekst = '''{
  "navn": "Kari", "alder": 17, "aktiv": true,
  "fag": ["IT2", "Matte"],
  "adresse": {"by": "Bergen", "postnummer": "5003"},
  "veileder": null
}'''

elev = json.loads(tekst)
print(type(elev))
print(elev["navn"])
print(elev["fag"][0])
print(elev["adresse"]["by"])
print(elev["veileder"])
print(elev["aktiv"])
<class 'dict'>
Kari
IT2
Bergen
None
True

Resultatet er vanlige Python-ordbøker og lister, som du bruker som du er vant til. Du går inn i strukturen med [...] for hvert nivå: elev["adresse"]["by"]. Har du JSON i en fil, bruker du json.load (uten s) som leser direkte fra et fil-objekt:

import os, tempfile
os.chdir(tempfile.mkdtemp())

with open("elev.json", "w", encoding="utf-8") as fil:
    fil.write(tekst)

with open("elev.json", encoding="utf-8") as fil:
    elev = json.load(fil)
print(elev["fag"])
['IT2', 'Matte']
RegelLese og skrive JSON
Tekst Fil
Fra JSON til Python json.loads(tekst) json.load(fil)
Fra Python til JSON json.dumps(objekt) json.dump(objekt, fil)

Bokstaven s står for string (tekst).

Skrive JSON

Å gjøre Python-objekter om til JSON kalles å serialisere. json.dumps gir en tekst, og json.dump skriver rett til en fil:

elev = {
    "navn": "Kari",
    "karakterer": [5, 4, 6],
    "adresse": {"by": "Tromsø"},
    "aktiv": True,
    "veileder": None,
}

print(json.dumps(elev))
print(json.dumps(elev, indent=2, ensure_ascii=False))
{"navn": "Kari", "karakterer": [5, 4, 6], "adresse": {"by": "Troms\u00f8"}, "aktiv": true, "veileder": null}
{
  "navn": "Kari",
  "karakterer": [
    5,
    4,
    6
  ],
  "adresse": {
    "by": "Tromsø"
  },
  "aktiv": true,
  "veileder": null
}

Første linje er kompakt, uten linjeskift. Med indent=2 blir JSON-en pen og lesbar. ensure_ascii=False gjør at ø skrives som ø og ikke som \u00f8 (som er riktig JSON, men vanskelig å lese). Det er vanlig å bruke begge når du skriver til en fil:

with open("elev2.json", "w", encoding="utf-8") as fil:
    json.dump(elev, fil, indent=2, ensure_ascii=False)

print(open("elev2.json", encoding="utf-8").read())
{
  "navn": "Kari",
  "karakterer": [
    5,
    4,
    6
  ],
  "adresse": {
    "by": "Tromsø"
  },
  "aktiv": true,
  "veileder": null
}

Merk hvordan True ble true og None ble null.

Lag en liste med to ordbøker (navn og poeng), gjør den om til JSON-tekst, og les den tilbake. Er resultatet lik originalen?

json.dumps og så json.loads.

data = [{"navn": "Kari", "poeng": 45}, {"navn": "Ola", "poeng": 38}]
tekst = json.dumps(data)
print(tekst)
print(json.loads(tekst) == data)
[{"navn": "Kari", "poeng": 45}, {"navn": "Ola", "poeng": 38}]
True

Typer som ikke passer

Ikke alt fra Python lar seg skrive som JSON. To ting å passe på:

print(json.dumps({"koordinat": (1, 2)}))
print(json.loads(json.dumps({"koordinat": (1, 2)})))
print(json.dumps({1: "en", 2: "to"}))
print(json.loads(json.dumps({1: "en", 2: "to"})))

try:
    json.dumps({"tall": {1, 2, 3}})
except TypeError as feil:
    print("TypeError:", feil)
{"koordinat": [1, 2]}
{'koordinat': [1, 2]}
{"1": "en", "2": "to"}
{'1': 'en', '2': 'to'}
TypeError: Object of type set is not JSON serializable
  • Tupler blir til lister. Når du leser dem tilbake, har du en liste.
  • Nøkler i JSON må være tekst. Heltall som nøkler blir til tekster ("1"), og kommer ikke tilbake som heltall.
  • Mengder (set), egne objekter og datoer kan ikke skrives rett ut, og gir TypeError.

Lagre egne objekter

Hvordan lagrer du et objekt fra en klasse du har laget selv (kapittel 6)? Du gjør det om til en ordbok først, med en egen metode, og lager et nytt objekt fra ordboken når du leser det tilbake:

class Film:
    def __init__(self, tittel, varighet):
        self.tittel = tittel
        self.varighet = varighet

    def til_dict(self):
        return {"tittel": self.tittel, "varighet": self.varighet}

    @classmethod
    def fra_dict(cls, d):
        return cls(d["tittel"], d["varighet"])

filmer = [Film("Dune", 155), Film("Oppdrag Mars", 118)]

tekst = json.dumps([f.til_dict() for f in filmer], ensure_ascii=False)
print(tekst)

tilbake = [Film.fra_dict(d) for d in json.loads(tekst)]
print(tilbake[1].tittel)
[{"tittel": "Dune", "varighet": 155}, {"tittel": "Oppdrag Mars", "varighet": 118}]
Oppdrag Mars

til_dict og fra_dict er ikke spesielle i Python, vi har bare valgt de navnene. Slik kan du lagre en hel samling objekter i en fil, og lese dem inn igjen neste gang programmet starter. Det er akkurat det du gjør i prosjektene (P1 og P2). Python har også en modul pickle som kan lagre vilkårlige objekter, men den er ikke lesbar for mennesker, bare for Python, og det er farlig å lese en pickle-fil du ikke stoler på. Bruk JSON når du har valget.

CSV eller JSON?

CSV JSON
Struktur flat tabell nøstede lister og ordbøker
Typer alt er tekst tekst, tall, sann/usann, null
Passer til regneark, mange like rader API-er, innstillinger, data med struktur
Størrelse kompakt litt mer plass (nøklene gjentas)
Lesbarhet enkel enkel, med indent

Er dataene en enkel tabell, er CSV ofte det enkleste. Har dataene lister eller ordbøker inni hverandre, trenger du JSON.

AdvarselVanlige feil
  • Å bruke enkle anførselstegn i JSON-tekst. Bare doble er lov.
  • Å glemme at json.load leser fra en fil, og json.loads fra en tekst.
  • Å tro at tupler og heltalls-nøkler kommer uendret tilbake.
  • Å prøve å lagre mengder, datoer eller egne objekter direkte.
  • Å glemme encoding="utf-8" og ensure_ascii=False, og få \u00f8 i fila.
  • Å lese en nøkkel som ikke finnes, og få KeyError. Bruk d.get("nokkel") hvis den kan mangle.
  • Å åpne fila med "w" og slette den før du har lest innholdet.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hva gir hvert uttrykk? Dataene er

d = json.loads('{"navn": "Kari", "fag": ["IT2", "Matte"], "info": {"by": "Bergen"}}')
d["navn"], b) d["fag"][1], c) d["info"]["by"], d) len(d["fag"]).
'Kari'. b) 'Matte'. c) 'Bergen'. d) 2.

Hvilke av disse er gyldig JSON? a) {"a": 1}, b) {'a': 1}, c) {"a": True}, d) {"a": [1, 2,]}, e) {"a": null}.

JSON bruker doble anførselstegn, små bokstaver for true/null, og ikke komma etter siste element.

Bare a) og e). b) har enkle anførselstegn, c) bruker True (skal være true), og d) har komma etter siste element.

Velg riktig funksjon: a) du har JSON som en tekst i en variabel, b) du har en åpnet fil med JSON, c) du vil skrive et objekt til en fil, d) du vil ha JSON-tekst fra et objekt.

  1. json.loads. b) json.load. c) json.dump. d) json.dumps.
Nivå 2
data = {"punkt": (1, 2), 5: "fem", "ok": True}
tilbake = json.loads(json.dumps(data))
print(tilbake)

{'punkt': [1, 2], '5': 'fem', 'ok': True}. Tuppelen ble en liste, heltallsnøkkelen \(5\) ble teksten '5', og True ble true og tilbake til True.

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

Fila er åpnet for skriving ("w"), så den er tom og kan ikke leses (io.UnsupportedOperation), og modusen har dessuten slettet innholdet. For å lese må du åpne med "r" (eller uten modus). For å skrive bruker du json.dump(data, fil).

Gjør det på maskinen

Lag programmet hoyscore.py i VS Code. Det leser en liste med {"navn": ..., "poeng": ...} fra hoyscore.json (en tom liste hvis fila ikke finnes), spør om navn og poeng, legger til, sorterer med høyest først, beholder de ti beste, lagrer fila med indent=2, og skriver ut listen. Kjør det flere ganger, og åpne JSON-fila.

import json
from pathlib import Path

fil = Path("hoyscore.json")
if fil.exists():
    liste = json.loads(fil.read_text(encoding="utf-8"))
else:
    liste = []

navn = input("Navn: ")
poeng = int(input("Poeng: "))
liste.append({"navn": navn, "poeng": poeng})
liste.sort(key=lambda r: r["poeng"], reverse=True)
liste = liste[:10]

fil.write_text(json.dumps(liste, indent=2, ensure_ascii=False),
               encoding="utf-8")

for plass, r in enumerate(liste, start=1):
    print(plass, r["navn"], r["poeng"])

Dette er samme tankegang som i spillprosjektet (P1.6).

Kodeoppgaver

Skriv funksjonen hent_by(json_tekst) som gir by fra objektet adresse i JSON-teksten, eller None hvis adresse eller by mangler.

Bruk .get() på hvert nivå, med en tom ordbok som standard på midten: d.get("adresse", {}).get("by").

Skriv funksjonen sum_poeng(json_tekst) som tar en JSON-liste av objekter med nøkkelen poeng og gir summen.

sum(d["poeng"] for d in json.loads(json_tekst)).

Skriv funksjonen pen_json(objekt) som gir JSON-tekst med innrykk på to mellomrom og æøå skrevet som vanlige bokstaver.

json.dumps(objekt, indent=2, ensure_ascii=False).

Skriv klassen Spiller med navn og poeng, til_dict() og klassemetoden fra_dict(d). Skriv så funksjonene lagre(spillere) (gir JSON-tekst) og last(tekst) (gir lista med Spiller-objekter).

lagre gjør hver spiller om med til_dict() før json.dumps. last bruker fra_dict på hver ordbok.

Funksjonen skal lese JSON, men krasjer på dataene. Rett dataene, ikke funksjonen (du kan endre variabelen tekst).

Hvilke anførselstegn krever JSON?

Skriv funksjonen aktive(json_tekst) som tar en JSON-liste av objekter med navn og aktiv (sann eller usann) og gir navnene på de aktive, i rekkefølgen de står.

[d["navn"] for d in json.loads(json_tekst) if d["aktiv"]].

Utfordringer

Skriv funksjonen flat(json_tekst) som tar et JSON-objekt med nøstede objekter og gir en flat ordbok der nøklene er stier skilt med punktum. Eksempel: {"a": {"b": 1}, "c": 2} blir {"a.b": 1, "c": 2}.

Bruk en hjelpefunksjon som kaller seg selv for hvert objekt (rekursjon), og husk å legge til prefikset.

Velg CSV eller JSON, og begrunn: a) en liste av \(10\,000\) målinger med tidspunkt og verdi, b) innstillingene til et program, med lister og grupper, c) data som skal åpnes i Excel av en lærer, d) svaret fra et vær-API.

  1. CSV: en enkel, flat tabell med like rader, som er kompakt og lett å åpne i regneark. b) JSON: strukturerte data med lister og grupper. c) CSV: Excel kan åpne den direkte. d) JSON: API-er sender nesten alltid JSON, siden dataene ofte har struktur.

Oppsummering

Lese

import json
d = json.loads(tekst)
with open("f.json", encoding="utf-8") as f:
    d = json.load(f)

Skrive

tekst = json.dumps(d, indent=2, ensure_ascii=False)
with open("f.json", "w", encoding="utf-8") as f:
    json.dump(d, f, indent=2, ensure_ascii=False)

Typer

  • objekt → dict, liste → list
  • true/false/null → True/False/None
  • tupler blir lister, nøkler blir tekst
  • Doble anførselstegn i JSON.
  • s i loads/dumps er string.
  • Egne objekter: til_dict() og fra_dict().

8.3 Databaser og SQL

Filer er greie for små datamengder. Når dataene blir store, henger sammen og skal endres av mange samtidig, bruker vi en database.

8.3.1 Relasjonsdatabaser

Tenk deg at kinoen lagrer alle billettene i én stor CSV-fil, med tittel, sal, tidspunkt og kundens navn og telefonnummer på hver linje. Det virker, men noe er galt: filmtittelen står hundrevis av ganger, og endrer kunden telefonnummer, må vi rette det på mange linjer. Vi har sett dette problemet før, som dobbeltlagring i 5.5.1. En relasjonsdatabase løser det ved å dele dataene i flere tabeller som henger sammen.

Læringsmål

Etter dette delkapittelet skal du kunne

  • forklare hva en tabell, en rad, en kolonne, en primærnøkkel og en fremmednøkkel er,
  • dele opp data i flere tabeller uten dobbeltlagring,
  • tegne et ER-diagram og lese relasjonene i det,
  • oversette et klassediagram til tabeller,
  • løse mange-til-mange med en koblingstabell.

Tabeller, rader og nøkler

En tabell har faste kolonner (egenskapene, med hver sin type) og en rad for hvert objekt. Dette er tabellen film:

id tittel varighet
\(1\) Dune \(155\)
\(2\) Oppdrag Mars \(118\)
\(3\) Pondus på tur \(94\)

Kolonnen id er primærnøkkel: en verdi som er unik for hver rad og identifiserer den. Titler kan være like, men id er det aldri. Med primærnøkkelen kan andre tabeller peke på akkurat denne raden:

id film_id sal tidspunkt
\(1\) \(1\) \(1\) 19:00
\(2\) \(1\) \(2\) 21:30
\(3\) \(2\) \(1\) 17:00

Dette er tabellen forestilling. Kolonnen film_id er en fremmednøkkel: den inneholder primærnøkkelen til en rad i en annen tabell. Her sier den hvilken film forestillingen viser. Tittelen lagres bare én gang, i film, og forestillingene peker dit. Skifter filmen tittel, rettes det på ett sted.

DefinisjonNøkler
  • Primærnøkkel: en kolonne (som id) med unik verdi i hver rad, som identifiserer raden.
  • Fremmednøkkel: en kolonne som inneholder primærnøkkelen til en rad i en annen tabell, og som lager forbindelsen mellom tabellene.

Fra klassediagram til tabeller

Dette ligner på det du lærte i kapittel 5: en klasse blir en tabell, og attributtene blir kolonner. Relasjonene blir fremmednøkler.

erDiagram
    FILM ||--o{ FORESTILLING : "vises i"
    FORESTILLING ||--o{ BILLETT : "har"
    FILM {
        int id PK
        string tittel
        int varighet
    }
    FORESTILLING {
        int id PK
        int film_id FK
        int sal
        string tidspunkt
    }
    BILLETT {
        int id PK
        int forestilling_id FK
        int sete
        int pris
    }

Dette er et ER-diagram (entity-relationship). Boksene er tabellene, og linjene er relasjonene. ||--o{ leses «en til null eller flere»: en film vises i null eller flere forestillinger, og hver forestilling har nøyaktig én film. Det er den samme multiplisiteten som 1 og 0..* i klassediagrammet.

RegelFra relasjon til fremmednøkkel
  • Hver klasse blir en tabell, hvert attributt en kolonne, og hver tabell får en primærnøkkel (id).
  • En-til-mange: fremmednøkkelen står i tabellen på «mange»-siden. En forestilling hører til én film, så film_id står i forestilling.
  • Mange-til-mange: lag en koblingstabell med to fremmednøkler.

Mange-til-mange: koblingstabellen

Elever tar mange fag, og hvert fag har mange elever. Du kan ikke legge en fremmednøkkel i noen av tabellene, for hver rad måtte peke på flere. I stedet lager vi en tredje tabell som kobler dem, med én rad for hvert par (som mellomklassen i 5.4.2):

elev_id fag_id karakter
\(1\) \(1\) \(5\)
\(1\) \(2\) \(4\)
\(2\) \(1\) \(6\)

Koblingstabellen karakter har fremmednøklene elev_id og fag_id, og kan også ha egne kolonner (karakteren). Kombinasjonen (elev_id, fag_id) er unik og kan være primærnøkkelen.

En klasse har mange elever, og hver elev går i én klasse. Hvilken tabell får fremmednøkkelen, og hva heter kolonnen?

Fremmednøkkelen står på «mange»-siden.

Tabellen elev får kolonnen klasse_id, som peker på id i tabellen klasse. Mange elever kan ha samme klasse_id, men hver elev har bare én.

Hvorfor flere tabeller?

Å dele dataene slik kalles normalisering. Fordelene er de samme som da vi unngikk dobbeltlagring i kapittel 5:

  • Hver opplysning lagres ett sted, så den kan ikke bli ulik.
  • Det er lett å endre: ett sted å rette.
  • Databasen kan håndheve regler: den kan nekte å lagre en forestilling med en film_id som ikke finnes (referanseintegritet), og kreve at tittel alltid har en verdi.

I tillegg er databaser bygget for å søke raskt i millioner av rader, la mange brukere lese og skrive samtidig, og sørge for at en endring enten blir gjennomført helt eller ikke i det hele tatt. Det klarer ikke en vanlig tekstfil. Det mest brukte språket for å arbeide med relasjonsdatabaser er SQL, som du lærer i neste delkapittel. SQL er en internasjonal standard, så det du lærer, virker (med små forskjeller) i alle store databaser, fra SQLite til de som brukes av banker og nettbutikker.

NoteAndre databaser

Det finnes også andre typer databaser, som dokumentdatabaser (som lagrer JSON-lignende dokumenter) og nøkkel-verdi-databaser. De passer for data uten fast struktur eller med enorme mengder. Relasjonsdatabaser passer best når dataene har en klar struktur og sammenheng, og er det du bruker i dette kurset.

AdvarselVanlige feil
  • Å lagre samme opplysning i flere tabeller (dobbeltlagring) i stedet for å bruke en fremmednøkkel.
  • Å legge fremmednøkkelen i feil tabell (på «en»-siden i stedet for «mange»-siden).
  • Å bruke navn eller tittel som primærnøkkel. De kan være like og kan endres.
  • Å prøve å løse mange-til-mange uten en koblingstabell.
  • Å lage tabeller uten primærnøkkel.
  • Å lage én tabell per kolonne, eller én stor tabell for alt.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Se på tabellene forestilling (id, film_id, sal, tidspunkt) og film (id, tittel, varighet). a) Hva er primærnøkkelen i hver? b) Hvilken kolonne er fremmednøkkel, og hvilken tabell peker den på?

  1. id i begge. b) film_id i forestilling er fremmednøkkel, og peker på id i film.

erDiagram
    KUNDE ||--o{ BESTILLING : "legger inn"

Hvor mange bestillinger kan en kunde ha? Hvor mange kunder hører en bestilling til? Hvilken tabell får fremmednøkkelen?

En kunde kan ha null eller flere bestillinger, og hver bestilling hører til nøyaktig én kunde. bestilling får fremmednøkkelen kunde_id.

bestilling_id kunde_navn kunde_telefon vare
\(1\) Kari 90011122 melk
\(2\) Kari 90011122 brød
\(3\) Ola 91122233 melk

Hvilket problem har tabellen, og hvordan løses det?

Kari og hennes telefonnummer står to ganger (dobbeltlagring). Endrer hun nummer, må vi rette flere rader, og glemmer vi en, blir dataene ulike. Løsningen er å lage en egen tabell kunde (id, navn, telefon) og la bestilling ha kunde_id.

Nivå 2

Klassene Elev (navn, alder) og Klasse (navn) har relasjonen Klasse "1" o-- "*" Elev. Skriv tabellene med kolonner, primærnøkler og fremmednøkkel.

klasse (id, navn)
elev   (id, navn, alder, klasse_id)   -- klasse_id er fremmednøkkel til klasse.id

Elever tar mange fag, og hvert fag har mange elever. Tegn tabellene, og vis hvordan du lagrer at Kari (\(id = 1\)) har karakter \(5\) i IT2 (\(id = 1\)) og \(4\) i matte (\(id = 2\)).

elev   (id, navn)
fag    (id, navn)
karakter (elev_id, fag_id, verdi)

elev:     (1, Kari)
fag:      (1, IT2), (2, Matte)
karakter: (1, 1, 5), (1, 2, 4)

Koblingstabellen karakter har én rad per elev og fag, og lagrer karakteren, som hører til paret.

Hvorfor bruker vi en egen id som primærnøkkel i stedet for navn?

To personer kan ha samme navn, så navnet er ikke garantert unikt. Et navn kan også endres (giftemål, skrivefeil), og da måtte vi rette alle fremmednøklene som peker på det. En id er unik og endres aldri, og er bare et nummer databasen kan bruke til å finne raden.

Kodeoppgaver

I disse oppgavene er tabellene lister av ordbøker. Du gjør det en database gjør, for hånd.

Skriv funksjonen finn(tabell, id) som gir raden (ordboken) med "id" lik id, eller None.

Gå gjennom radene og sammenlign rad["id"].

Skriv funksjonen titler_for(film, forestillinger) som gir lista med filmtittelen for hver forestilling, i rekkefølgen forestillingene står. Hver forestilling har film_id.

Lag først en ordbok fra id til tittel, og slå opp film_id i den.

Skriv funksjonen slaa_sammen(forestillinger, film) som gir en liste av ordbøker med "tittel" og "tidspunkt" for hver forestilling. Det er det SQL kaller en JOIN.

Slå opp filmen for hver forestilling, og bygg en ny ordbok med de to feltene.

Skriv funksjonen ugyldige(forestillinger, film) som gir lista med id til forestillinger der film_id ikke finnes i film.

Lag en mengde med alle film-id-er, og finn forestillingene der film_id ikke er i den.

Skriv funksjonen antall_per_film(forestillinger) som gir en ordbok fra film_id til antall forestillinger av filmen.

antall[film_id] = antall.get(film_id, 0) + 1. Dette er det SQL gjør med GROUP BY og COUNT.

Skriv funksjonen fag_for(elev_id, karakterer, fag) som gir sortert liste med navnene på fagene eleven har karakter i. karakterer er koblingstabellen med elev_id og fag_id.

Finn fag_id-ene for eleven i koblingstabellen, og slå opp navnene i fag.

Utfordringer

Et bibliotek har bøker, forfattere og lånere. En bok har én eller flere forfattere, og en forfatter kan ha skrevet flere bøker. En låner kan låne mange bøker, og vi vil huske når hvert lån startet. Tegn et ER-diagram og skriv tabellene med nøkler.

bok       (id, tittel)
forfatter (id, navn)
forfatterskap (bok_id, forfatter_id)         -- mange-til-mange
laaner    (id, navn)
laan      (id, bok_id, laaner_id, startdato) -- en låner, en bok, når

forfatterskap er koblingstabellen mellom bok og forfatter. laan kobler låner og bok, og har egen kolonne for datoen. Sammenlign med klassediagrammet fra P2.1: mellomklassene i modellen blir koblingstabeller.

Gi et eksempel der en vanlig fil (CSV eller JSON) er bedre enn en database, og forklar.

Et lite program som lagrer en høyscore-liste eller innstillinger. Dataene er få og enkle, én bruker skriver om gangen, og vi trenger ikke søk eller relasjoner. En JSON-fil er enklere å lage, lese og dele, og krever ingen oppsett. En database lønner seg når dataene er mange, henger sammen, skal søkes i raskt eller deles av flere brukere.

Oppsummering

Begreper

  • Tabell: rader og kolonner
  • Primærnøkkel: unik id for raden
  • Fremmednøkkel: peker på en annen tabells primærnøkkel

Relasjoner

  • En-til-mange: fremmednøkkel på «mange»-siden
  • Mange-til-mange: koblingstabell med to fremmednøkler

Fordeler

  • Hver opplysning lagres én gang
  • Databasen håndhever regler
  • Rask søking i store datamengder
  • Klasse → tabell, attributt → kolonne, relasjon → fremmednøkkel.
  • Bruk en egen id som primærnøkkel, ikke navn.
  • ER-diagram viser tabellene og relasjonene.

8.3.2 SQL med sqlite3

SQL (Structured Query Language) er språket du bruker til å snakke med en relasjonsdatabase: lage tabeller, legge inn data, endre dem og hente ut det du trenger. Python har en database innebygd, SQLite, som lagrer hele databasen i én fil og ikke trenger noen installasjon. Den brukes i mobiltelefoner, nettlesere og mange apper, og er et utmerket sted å lære SQL. Du bruker den med modulen sqlite3.

Læringsmål

Etter dette delkapittelet skal du kunne

  • koble til en SQLite-database og kjøre SQL fra Python,
  • lage tabeller med CREATE TABLE, legge inn data med INSERT, og endre og slette med UPDATE og DELETE,
  • hente ut data med SELECT, WHERE, ORDER BY, LIMIT, COUNT, AVG og GROUP BY,
  • slå sammen tabeller med JOIN,
  • bruke parametere (?) i stedet for å sette sammen SQL med tekst, og forklare hvorfor.

Koble til og lage tabeller

import sqlite3

con = sqlite3.connect(":memory:")
con.execute("PRAGMA foreign_keys = ON")

con.executescript("""
CREATE TABLE film (
    id INTEGER PRIMARY KEY,
    tittel TEXT NOT NULL,
    varighet INTEGER
);
CREATE TABLE forestilling (
    id INTEGER PRIMARY KEY,
    film_id INTEGER NOT NULL REFERENCES film(id),
    sal INTEGER,
    tidspunkt TEXT
);
""")
<sqlite3.Cursor at 0x72d5fc2e97c0>
  • sqlite3.connect(":memory:") lager en midlertidig database i minnet, som forsvinner når programmet slutter. Skriver du sqlite3.connect("kino.db"), lagres den i fila kino.db, og kan brukes igjen neste gang.
  • con.execute(sql) kjører én SQL-setning. con.executescript(sql) kjører flere, adskilt med semikolon.
  • CREATE TABLE lager en tabell med kolonner og typer: INTEGER (heltall), TEXT (tekst) og REAL (desimaltall).
  • PRIMARY KEY markerer primærnøkkelen. I SQLite får en INTEGER PRIMARY KEY automatisk neste nummer når du ikke oppgir noen.
  • NOT NULL betyr at kolonnen må ha en verdi. REFERENCES film(id) markerer fremmednøkkelen. PRAGMA foreign_keys = ON sørger for at SQLite faktisk håndhever den (den er av som standard).

Legge inn data

con.execute("INSERT INTO film (tittel, varighet) VALUES (?, ?)", ("Dune", 155))
con.executemany("INSERT INTO film (tittel, varighet) VALUES (?, ?)",
                [("Oppdrag Mars", 118), ("Pondus på tur", 94)])
con.executemany(
    "INSERT INTO forestilling (film_id, sal, tidspunkt) VALUES (?, ?, ?)",
    [(1, 1, "19:00"), (1, 2, "21:30"), (2, 1, "17:00")])
con.commit()

? er plassholdere, og verdiene sendes inn i en tuppel. executemany kjører samme setning for hver tuppel i lista. Endringer blir ikke varige før du kaller con.commit(). Vi går tilbake til hvorfor plassholderne er viktige om litt. id oppgir vi ikke, siden databasen nummererer selv: Dune fikk \(1\), Oppdrag Mars \(2\) og Pondus \(3\).

Hente data med SELECT

SELECT henter data. Resultatet får du med fetchall() (alle rader som en liste av tupler) eller fetchone() (én rad):

print(con.execute("SELECT * FROM film").fetchall())
print(con.execute("SELECT tittel FROM film WHERE varighet < 120 ORDER BY tittel").fetchall())
print(con.execute("SELECT COUNT(*), AVG(varighet), MAX(varighet) FROM film").fetchone())
[(1, 'Dune', 155), (2, 'Oppdrag Mars', 118), (3, 'Pondus på tur', 94)]
[('Oppdrag Mars',), ('Pondus på tur',)]
(3, 122.33333333333333, 155)
  • SELECT * FROM film henter alle kolonner (*) fra tabellen.
  • SELECT tittel FROM film henter bare kolonnen tittel.
  • WHERE varighet < 120 filtrerer radene. Du kan bruke =, <, >, <=, >=, !=, AND, OR, NOT og LIKE 'D%' (tekst som starter med D).
  • ORDER BY tittel sorterer (legg til DESC for synkende rekkefølge), og LIMIT 3 gir bare de tre første.
  • COUNT(*), AVG, MAX, MIN og SUM regner ut verdier for flere rader.

Hver rad er en tuppel, også når du bare henter én kolonne (('Oppdrag Mars',)). Derfor skriver du ofte fetchone()[0] for å få verdien.

RegelSELECT
SELECT kolonner
FROM tabell
WHERE betingelse
ORDER BY kolonne [DESC]
LIMIT antall

Rekkefølgen er alltid SELECT, FROM, WHERE, ORDER BY, LIMIT. Bare SELECT og FROM er påkrevd.

Skriv spørringen som gir tittelen til den lengste filmen.

Sorter synkende på varighet og ta bare ett.

print(con.execute(
    "SELECT tittel FROM film ORDER BY varighet DESC LIMIT 1").fetchone()[0])
Dune

Endre og slette

con.execute("UPDATE film SET varighet = ? WHERE tittel = ?", (160, "Dune"))
print(con.execute("SELECT varighet FROM film WHERE tittel = 'Dune'").fetchone())
cur = con.execute("DELETE FROM film WHERE id = 3")
print(cur.rowcount)
con.commit()
(160,)
1

UPDATE tabell SET kolonne = verdi WHERE ... endrer eksisterende rader, og DELETE FROM tabell WHERE ... sletter rader. Husk WHERE! Uten den endres eller slettes alle radene i tabellen. cur.rowcount forteller hvor mange rader som ble berørt.

Slå sammen tabeller: JOIN

For å få tittelen sammen med tidspunktet, må vi kombinere tabellene forestilling og film. Det gjør JOIN, som kobler rader der fremmednøkkelen er lik primærnøkkelen:

sql = """
SELECT film.tittel, forestilling.tidspunkt
FROM forestilling
JOIN film ON forestilling.film_id = film.id
ORDER BY forestilling.tidspunkt
"""
print(con.execute(sql).fetchall())
[('Oppdrag Mars', '17:00'), ('Dune', '19:00'), ('Dune', '21:30')]

JOIN film ON forestilling.film_id = film.id sier at hver forestilling skal kobles til filmen med riktig id. Du skriver tabell.kolonne for å si hvilken tabell kolonnen kommer fra. Dette er det samme som slaa_sammen du skrev for hånd i 8.3.1, men databasen gjør det raskt også med millioner av rader.

Du kan kombinere JOIN med GROUP BY for å regne ut noe per gruppe:

sql = """
SELECT film.tittel, COUNT(*)
FROM forestilling
JOIN film ON film.id = forestilling.film_id
GROUP BY film.tittel
ORDER BY film.tittel
"""
print(con.execute(sql).fetchall())
[('Dune', 2), ('Oppdrag Mars', 1)]

GROUP BY film.tittel samler radene per film, og COUNT(*) teller radene i hver gruppe: antall forestillinger per film.

Skriv spørringen som gir salene (sal) som viser «Dune», uten gjentakelser.

JOIN, WHERE film.tittel = ... og SELECT DISTINCT.

sql = """
SELECT DISTINCT forestilling.sal
FROM forestilling JOIN film ON film.id = forestilling.film_id
WHERE film.tittel = 'Dune'
ORDER BY forestilling.sal
"""
print(con.execute(sql).fetchall())
[(1,), (2,)]

Aldri sett sammen SQL med tekst

Det er fristende å bygge spørringer med f-strenger, men det er farlig. Se hva som skjer når brukeren skriver noe lurt:

navn = "x' OR '1'='1"

farlig = f"SELECT * FROM film WHERE tittel = '{navn}'"
print(farlig)
print(len(con.execute(farlig).fetchall()))

trygg = con.execute("SELECT * FROM film WHERE tittel = ?", (navn,)).fetchall()
print(trygg)
SELECT * FROM film WHERE tittel = 'x' OR '1'='1'
2
[]

Med f-strengen ble spørringen til ... WHERE tittel = 'x' OR '1'='1', og '1'='1' er alltid sant, så alle radene ble returnert. Dette kalles SQL-injection, og er en av de vanligste og farligste sikkerhetsfeilene i nettsider. En angriper kan lese eller slette hva som helst. Med plassholderen ? behandler databasen verdien som ren tekst, og aldri som SQL, så den lurte teksten finner ingenting.

RegelBruk alltid plassholdere

Skriv aldri f"... '{verdi}'" i SQL. Skriv "... ?" og send verdien som tuppel: con.execute(sql, (verdi,)). Husk komma i en tuppel med ett element.

Feil og lukking

Databasen sjekker reglene du har satt, og gir feil hvis du bryter dem:

try:
    con.execute("INSERT INTO forestilling (film_id, sal, tidspunkt) VALUES (99, 1, '10:00')")
except sqlite3.IntegrityError as feil:
    print("IntegrityError:", feil)

try:
    con.execute("SELECT * FROM finnes_ikke")
except sqlite3.OperationalError as feil:
    print("OperationalError:", feil)
IntegrityError: FOREIGN KEY constraint failed
OperationalError: no such table: finnes_ikke

IntegrityError betyr at du brøt en regel (fremmednøkkel, NOT NULL, unik nøkkel). OperationalError betyr gjerne at tabellen eller kolonnen ikke finnes, eller at SQL-en har en skrivefeil. Når du er ferdig, lukker du forbindelsen med con.close(), og husk con.commit() først hvis du har endret data.

NoteResultater som ordbøker

Vil du ha hver rad som en ordbok i stedet for en tuppel, setter du con.row_factory = sqlite3.Row før du spør. Da kan du skrive rad["tittel"] i stedet for rad[0], og dict(rad) gir en vanlig ordbok.

AdvarselVanlige feil
  • Å bygge SQL med f-strenger (SQL-injection). Bruk ?.
  • Å glemme con.commit(), så endringene forsvinner.
  • Å glemme WHERE i UPDATE eller DELETE, og endre eller slette alle radene.
  • Å glemme komma i tuppelen med ett element: (verdi) er ikke en tuppel, men (verdi,) er det.
  • Å glemme at fetchall() gir tupler, selv for én kolonne.
  • Å glemme PRAGMA foreign_keys = ON og tro at fremmednøkler er sjekket.
  • Å bruke = med NULL. Skriv IS NULL.
  • Å bruke dobbelte anførselstegn rundt tekst i SQL. Bruk enkle ('Dune').

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Tabellen film har kolonnene id, tittel og varighet. Forklar hva hver spørring gjør.

SELECT tittel FROM film WHERE varighet > 120
Henter titlene til filmene som er lengre enn \(120\) minutter. b) Teller hvor mange filmer det er. c) Henter alle kolonner for de to lengste filmene. d) Sletter filmen med id \(5\).
SELECT COUNT(*) FROM film
SELECT * FROM film ORDER BY varighet DESC LIMIT 2
DELETE FROM film WHERE id = 5

Skriv SQL for tabellen elev (id, navn, klasse, poeng): a) navnene til alle elever i 2IT, b) alle elever sortert etter poeng, høyest først, c) gjennomsnittet av poeng.

  1. SELECT navn FROM elev WHERE klasse = '2IT'

  2. SELECT * FROM elev ORDER BY poeng DESC

  3. SELECT AVG(poeng) FROM elev

Hvilken av disse er trygg, og hvilken er utsatt for SQL-injection?

a = con.execute(f"SELECT * FROM elev WHERE navn = '{navn}'")
b = con.execute("SELECT * FROM elev WHERE navn = ?", (navn,))

b er trygg (plassholder). a er utsatt for SQL-injection, siden navn settes rett inn i SQL-teksten.

Nivå 2
con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE t (x INTEGER)")
con.executemany("INSERT INTO t VALUES (?)", [(1,), (2,), (3,)])
print(con.execute("SELECT SUM(x) FROM t").fetchone())
print(con.execute("SELECT x FROM t WHERE x > 1").fetchall())

(6,) og [(2,), (3,)]. Resultatene er tupler, også for én kolonne.

con.execute("UPDATE elev SET poeng = 0")

Hva skjer, og hva er sannsynligvis meningen?

Alle elevene får \(0\) poeng, siden det mangler WHERE. Sannsynligvis skulle bare én elev endres, for eksempel UPDATE elev SET poeng = 0 WHERE id = 3.

Tabellene er film (id, tittel) og forestilling (id, film_id, tidspunkt). Skriv spørringen som gir titlene og tidspunktene sortert etter tidspunkt.

SELECT film.tittel, forestilling.tidspunkt
FROM forestilling
JOIN film ON forestilling.film_id = film.id
ORDER BY forestilling.tidspunkt
Gjør det på maskinen

Lag programmet bokhylle.py i VS Code som bruker databasen bokhylle.db. Det lager tabellen bok (id, tittel, forfatter, sider) hvis den ikke finnes (CREATE TABLE IF NOT EXISTS), legger inn fem bøker, og skriver ut a) alle bøkene sortert på tittel, b) bøker med over \(300\) sider, c) gjennomsnittlig antall sider. Kjør programmet to ganger. Hva skjer med bøkene? Installer utvidelsen SQLite Viewer i VS Code, og åpne bokhylle.db.

import sqlite3

con = sqlite3.connect("bokhylle.db")
con.execute("""CREATE TABLE IF NOT EXISTS bok (
    id INTEGER PRIMARY KEY, tittel TEXT, forfatter TEXT, sider INTEGER)""")
con.executemany(
    "INSERT INTO bok (tittel, forfatter, sider) VALUES (?, ?, ?)",
    [("Kristin Lavransdatter", "Sigrid Undset", 1100),
     ("Sofies verden", "Jostein Gaarder", 520),
     ("Ringenes herre", "J.R.R. Tolkien", 1200),
     ("Hobbiten", "J.R.R. Tolkien", 310),
     ("Fyr", "Ukjent", 120)])
con.commit()

print(con.execute("SELECT * FROM bok ORDER BY tittel").fetchall())
print(con.execute("SELECT tittel FROM bok WHERE sider > 300").fetchall())
print(con.execute("SELECT AVG(sider) FROM bok").fetchone()[0])
con.close()

Kjører du programmet to ganger, har du ti bøker, siden databasen lever i fila bokhylle.db og INSERT kjører hver gang. Hadde du brukt :memory:, ville databasen vært tom hver gang. For å unngå dobler kan du slette fila først, eller sjekke SELECT COUNT(*) før du legger inn.

Kodeoppgaver

I de første oppgavene skriver du selve SQL-spørringen som tekst, og rettingen kjører den mot en liten database med denne tabellen: elev (id, navn, klasse, poeng) med fem elever: Kari (2IT, \(45\)), Ola (2IT, \(38\)), Mia (3IT, \(51\)), Jon (3IT, \(29\)) og Eva (2IT, \(60\)).

Skriv spørringen sporring som gir navnene til elevene i 2IT, sortert alfabetisk.

SELECT navn FROM elev WHERE klasse = '2IT' ORDER BY navn.

Skriv spørringen sporring som gir navn og poeng for elever med mer enn \(40\) poeng, med flest poeng først.

WHERE poeng > 40 og ORDER BY poeng DESC.

Skriv spørringen sporring som gir antall elever og gjennomsnittlig poeng, i én rad.

SELECT COUNT(*), AVG(poeng) FROM elev.

Skriv spørringen sporring som gir hver klasse og gjennomsnittlig poeng i klassen, sortert på klassenavn.

SELECT klasse, AVG(poeng) FROM elev GROUP BY klasse ORDER BY klasse.

Skriv spørringen sporring som gir navnene som begynner på K eller M, sortert. Bruk LIKE.

WHERE navn LIKE 'K%' OR navn LIKE 'M%'.

Databasen har nå også tabellene fag (id, navn) og karakter (elev_id, fag_id, verdi). Skriv spørringen sporring som gir elevnavn, fagnavn og karakter for alle karakterer, sortert på elevnavn og så fagnavn.

FROM karakter JOIN elev ON karakter.elev_id = elev.id JOIN fag ON karakter.fag_id = fag.id.

Skriv funksjonen legg_til(con, navn, klasse, poeng) som legger en elev inn i tabellen elev (med plassholdere) og gir den nye elevens id.

cur = con.execute("INSERT ... VALUES (?, ?, ?)", (navn, klasse, poeng)), og cur.lastrowid gir id-en. Husk con.commit().

Skriv funksjonen finn_elev(con, navn) som gir lista med navn og poeng (som tupler) for elever med akkurat dette navnet. Bruk plassholder.

con.execute("SELECT navn, poeng FROM elev WHERE navn = ?", (navn,)).fetchall().

Funksjonen er utsatt for SQL-injection. Rett den slik at den bruker plassholder.

Bytt '{navn}' med ?, og send (navn,) som andre argument.

Utfordringer

Skriv spørringen sporring som gir navnet til eleven med flest poeng i hver klasse, sortert på klassenavn. (Hint: bruk en underspørring, eller MAX sammen med GROUP BY. I SQLite kan du bruke SELECT navn, MAX(poeng) FROM elev GROUP BY klasse, som gir raden med maksimum.)

SELECT klasse, navn, MAX(poeng) FROM elev GROUP BY klasse ORDER BY klasse. SQLite lar navn følge raden med høyest poeng når MAX brukes.

Hva er forskjellen på sqlite3.connect(":memory:") og sqlite3.connect("kino.db")? Når bruker du hver?

":memory:" lager en database i minnet som forsvinner når programmet slutter. Den er rask og egnet til testing og til oppgaver der dataene lages på nytt hver gang. "kino.db" lager (eller åpner) en fil på disken, så dataene overlever til neste gang programmet kjører. Den bruker du når dataene skal lagres varig.

Oppsummering

Tilkobling

import sqlite3
con = sqlite3.connect("kino.db")
con.execute("PRAGMA foreign_keys = ON")
...
con.commit()
con.close()

Opprette og legge inn

CREATE TABLE film (
  id INTEGER PRIMARY KEY,
  tittel TEXT NOT NULL
);
INSERT INTO film (tittel) VALUES (?);

Hente

SELECT kol FROM tabell
WHERE betingelse
ORDER BY kol DESC
LIMIT 5;

Slå sammen og grupper

SELECT f.tittel, COUNT(*)
FROM forestilling x
JOIN film f ON f.id = x.film_id
GROUP BY f.tittel;
  • Bruk alltid ?-plassholdere, aldri f-strenger.
  • UPDATE og DELETE uten WHERE rammer alle radene.
  • commit() for å lagre endringer.

8.4 API-er og datautveksling

Mye av dataene du vil bruke, ligger ikke i dine egne filer, men hos andre: vær, kollektivtrafikk, aksjekurser, statistikk. Mange tilbyr dem gjennom et API.

8.4.1 Hente data fra et API

Når du åpner en nettside, ber nettleseren en tjener om siden, og får HTML tilbake. Mange tjenester kan også svare på spørsmål fra programmer, ikke bare fra mennesker, og da sender de data, oftest som JSON, i stedet for en ferdig tegnet side. Slike tjenester kalles API-er (Application Programming Interface, programmeringsgrensesnitt). Du spør om været i Bergen, og får temperaturene tilbake som JSON, som du kan bruke i programmet ditt.

Læringsmål

Etter dette delkapittelet skal du kunne

  • forklare hva et API er, og hvordan en nettadresse (URL) er bygget opp,
  • forklare hva en HTTP-forespørsel og et svar med statuskode er,
  • bygge en URL med parametere og hente JSON fra et API,
  • plukke ut data fra et nøstet JSON-svar,
  • lagre et svar i en fil, så programmet også virker uten nett.

Forespørsel og svar

Kommunikasjonen på nettet følger standarden HTTP. Programmet (klienten) sender en forespørsel til en tjener, og tjeneren sender et svar. Den vanligste forespørselen heter GET, og betyr «gi meg dette». Adressen kalles en URL, og har flere deler:

https://api.example.no/v1/vaer?by=Bergen&dager=3
  • https er protokollen (HTTP med kryptering).
  • api.example.no er tjeneren (vertsnavnet).
  • /v1/vaer er stien, som sier hva du vil ha.
  • ?by=Bergen&dager=3 er spørreparametere: nøkkel og verdi, skilt med =, og flere skilt med &. De forteller API-et hva du spør om.

Du kan se delene i Python:

from urllib.parse import urlparse, parse_qs, urlencode

url = "https://api.example.no/v1/vaer?by=Bergen&dager=3"
u = urlparse(url)
print(u.scheme, u.netloc, u.path)
print(parse_qs(u.query))
https api.example.no /v1/vaer
{'by': ['Bergen'], 'dager': ['3']}

Å bygge en adresse med parametere gjør du best med urlencode, som passer på at spesialtegn som æ, ø, å og mellomrom blir riktig skrevet:

parametere = {"latitude": 60.39, "longitude": 5.32, "hourly": "temperature_2m"}
print(urlencode(parametere))
print(urlencode({"q": "Tromsø by"}))
latitude=60.39&longitude=5.32&hourly=temperature_2m
q=Troms%C3%B8+by

Merk at ø ble til %C3%B8 og mellomrom til +. Det er UTF-8-bytene fra 8.1.2, skrevet som prosent og hex.

Svaret har en statuskode som sier hvordan det gikk:

Kode Betydning
\(200\) OK, her er dataene
\(301\), \(302\) adressen er flyttet
\(400\) feil i forespørselen din
\(401\), \(403\) mangler eller har ikke tilgang (nøkkel mangler eller er feil)
\(404\) finnes ikke
\(429\) for mange forespørsler (du må vente)
\(500\)–\(599\) feil hos tjeneren

Tall som starter på \(2\) betyr suksess, \(4\) betyr at du har gjort noe feil, og \(5\) at tjeneren har problemer.

Hente data i Python

Pythons innebygde modul urllib.request kan hente en adresse. Her er et eksempel som henter temperaturer fra et vær-API (koden kjøres ikke her, siden den trenger nett):

import json
from urllib.parse import urlencode
from urllib.request import urlopen

parametere = {"latitude": 60.39, "longitude": 5.32,
              "hourly": "temperature_2m", "forecast_days": 1}
url = "https://api.open-meteo.com/v1/forecast?" + urlencode(parametere)

with urlopen(url, timeout=10) as svar:
    data = json.load(svar)

print(data["hourly"]["temperature_2m"][:3])

urlopen(url, timeout=10) sender forespørselen og gir et svar-objekt som kan leses som en fil, og json.load gjør innholdet om til Python-objekter. timeout=10 betyr at programmet gir opp etter ti sekunder i stedet for å vente for alltid. Mange bruker i stedet pakken requests (som du installerer med pip, se 3.3.2), som er litt enklere:

import requests

svar = requests.get("https://api.open-meteo.com/v1/forecast",
                    params=parametere, timeout=10)
print(svar.status_code)
data = svar.json()
NoteHer virker ikke nettleserversjonen

Python i nettleseren (notatboka og boka) kan ikke hente fra nettet på denne måten. API-kall gjør du i VS Code. I oppgavene i nettleseren øver du på det som skjer etter at svaret er hentet, med en lagret JSON-tekst.

Plukke ut data fra svaret

Svaret fra et API er JSON, og ofte nøstet. Her er et forenklet svar fra et vær-API, lagret som en tekst:

import json

svar_tekst = '''{
  "latitude": 60.39, "longitude": 5.32,
  "hourly": {
    "time": ["2026-11-18T00:00", "2026-11-18T01:00",
             "2026-11-18T02:00", "2026-11-18T03:00"],
    "temperature_2m": [4.1, 3.8, 3.2, 3.5]
  }
}'''

data = json.loads(svar_tekst)
tider = data["hourly"]["time"]
temp = data["hourly"]["temperature_2m"]

for t, c in zip(tider, temp):
    print(t[11:], c)

print(max(temp), tider[temp.index(max(temp))])
00:00 4.1
01:00 3.8
02:00 3.2
03:00 3.5
4.1 2026-11-18T00:00

Svaret har to lister like lange: tidspunktene og temperaturene. zip setter dem sammen, så vi kan gå gjennom begge samtidig. Når du skal bruke et nytt API, åpner du adressen først i nettleseren (eller skriver ut data med json.dumps(data, indent=2)) for å se hvordan svaret er bygget opp, og leser dokumentasjonen til API-et.

Finn laveste temperatur og klokkeslettet i svaret over.

min(temp) og temp.index(...).

laveste = min(temp)
print(laveste, tider[temp.index(laveste)][11:])
3.2 02:00

Lagre svaret i en fil

Du vil ikke alltid spørre tjenesten på nytt. De fleste API-er begrenser hvor mange forespørsler du kan sende, og på eksamen har du ikke nett. En god vane er å lagre svaret i en JSON-fil, og lese fra fila neste gang:

import json
from pathlib import Path

fil = Path("vaer.json")
if fil.exists():
    data = json.loads(fil.read_text(encoding="utf-8"))
else:
    with urlopen(url, timeout=10) as svar:
        data = json.load(svar)
    fil.write_text(json.dumps(data), encoding="utf-8")

Første gang hentes dataene og lagres, og senere leses de fra fila. Dette kalles hurtiglagring (cache). Det gjør programmet raskere, skåner tjenesten, og lar deg jobbe uten nett.

RegelBruk av API-er
  1. Les dokumentasjonen: hva heter adressen, hvilke parametere finnes, hvordan ser svaret ut?
  2. Åpne adressen i nettleseren og se på svaret.
  3. Hent svaret i Python med timeout, og sjekk at det gikk bra.
  4. Plukk ut det du trenger fra JSON-en.
  5. Lagre svaret i en fil, så du kan jobbe uten nett.
NoteNøkler, vilkår og personvern

Mange API-er krever en API-nøkkel, en hemmelig tekst som identifiserer deg. Den skal aldri legges inn i kode du deler eller legger på GitHub (se 11.2). Les også vilkårene: noen API-er har grenser for hvor ofte du kan spørre, og noen data har lisenser som sier hvordan du kan bruke dem. Data om personer er underlagt personvernregler, og må behandles deretter.

AdvarselVanlige feil
  • Å sette sammen en URL med f-strenger og glemme å kode æ, ø, å og mellomrom. Bruk urlencode.
  • Å glemme timeout, så programmet henger for alltid hvis tjeneren ikke svarer.
  • Å anta at svaret alltid har riktig form, og få KeyError når en nøkkel mangler.
  • Å ikke sjekke statuskoden.
  • Å spørre tjenesten på nytt for hver kjøring mens du feilsøker, og bli stoppet for å spørre for ofte.
  • Å legge API-nøkkelen i koden og dele den.
  • Å prøve å hente data uten nett (se 8.4.2).

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hva er protokoll, tjener, sti og parametere i denne adressen?

https://data.example.no/api/v2/stasjoner?kommune=Oslo&maks=10

Protokoll: https. Tjener: data.example.no. Sti: /api/v2/stasjoner. Parametere: kommune=Oslo og maks=10.

Hva betyr a) \(200\), b) \(404\), c) \(429\), d) \(500\)? Hvem har skylden i hvert tilfelle?

  1. OK, alt gikk bra. b) Finnes ikke: adressen er feil (din feil). c) For mange forespørsler: du spør for ofte (din feil, vent litt). d) Feil hos tjeneren (tjenerens feil).

Hva er timeout=10 i urlopen(url, timeout=10), og hva skjer uten den?

Det er hvor mange sekunder programmet venter på svar før det gir opp og utløser en feil. Uten timeout kan programmet vente i uendelig tid hvis tjeneren ikke svarer eller nettet henger.

Nivå 2
data = json.loads('{"by": "Bergen", "vaer": {"temp": 4.5, "vind": [3, 5, 2]}}')

Hva gir a) data["vaer"]["temp"], b) data["vaer"]["vind"][1], c) max(data["vaer"]["vind"])?

  1. 4.5. b) 5. c) 5.

Gi tre grunner til å lagre svaret fra et API i en fil.

Du slipper å spørre tjenesten hver gang (og unngår å bli stoppet for å spørre for ofte), programmet blir raskere, og du kan jobbe uten nett (for eksempel på eksamen eller på en tog). Du får også data som ikke endrer seg mens du feilsøker, så du kan sammenligne resultater.

Hva er feil med denne adressen, og hvordan bygger du den riktig?

by = "Tromsø"
url = "https://api.example.no/vaer?by=" + by + "&dager=3"

Bokstaven ø og andre spesialtegn må kodes i URL-er, og dette gjør ikke teksten. Bygg adressen med urlencode: "https://api.example.no/vaer?" + urlencode({"by": by, "dager": 3}). Da blir det by=Troms%C3%B8&dager=3.

Gjør det på maskinen

Lag programmet vaer.py i VS Code. Det henter timestemperaturene for ditt sted fra et vær-API (finn dokumentasjonen til for eksempel Open-Meteo, eller bruk et annet API du har fått anbefalt av læreren), skriver ut høyeste og laveste temperatur og når de var, og lagrer svaret i vaer.json. Gjør programmet slik at det leser fra vaer.json hvis fila finnes. Slå så av nettet og kjør programmet en gang til. Virker det?

import json
from pathlib import Path
from urllib.parse import urlencode
from urllib.request import urlopen

fil = Path("vaer.json")
if fil.exists():
    data = json.loads(fil.read_text(encoding="utf-8"))
else:
    parametere = {"latitude": 60.39, "longitude": 5.32,
                  "hourly": "temperature_2m", "forecast_days": 1}
    url = "https://api.open-meteo.com/v1/forecast?" + urlencode(parametere)
    with urlopen(url, timeout=10) as svar:
        data = json.load(svar)
    fil.write_text(json.dumps(data), encoding="utf-8")

tider = data["hourly"]["time"]
temp = data["hourly"]["temperature_2m"]
print("Høyest:", max(temp), tider[temp.index(max(temp))])
print("Lavest:", min(temp), tider[temp.index(min(temp))])

Slik virker programmet også uten nett, så lenge fila finnes. Sjekk dokumentasjonen: nøkkelnavn og parametere kan ha endret seg siden denne boka ble skrevet.

Kodeoppgaver

Disse oppgavene øver på det du gjør med svaret, ikke selve nettkallet.

Skriv funksjonen lag_url(base, parametere) som gir base, så ?, og parametrene kodet med urlencode. Er det ingen parametere, gir den bare base.

base + "?" + urlencode(parametere), men bare når parametere ikke er tom.

Skriv funksjonen hoyeste(json_tekst) som tar et svar i formatet fra eksempelet (med hourly.time og hourly.temperature_2m) og gir tuppelen (tidspunkt, temperatur) for den høyeste temperaturen.

max(temp) gir verdien, og temp.index(...) gir plassen i lista, som du kan bruke i time.

Skriv funksjonen par(json_tekst) som gir lista med tupler (tidspunkt, temperatur) for alle målingene, i rekkefølge.

list(zip(tider, temp)).

Skriv funksjonen kategori(kode) som gir "ok" for koder fra \(200\) til \(299\), "omdirigering" for \(300\)–\(399\), "klientfeil" for \(400\)–\(499\), "tjenerfeil" for \(500\)–\(599\), og ellers "ukjent".

kode // 100 gir første siffer.

Skriv funksjonen snitt_per_dag(json_tekst) som gir en ordbok fra dato (de ti første tegnene av tidspunktet, som "2026-11-18") til gjennomsnittstemperaturen den dagen.

tid[:10] gir datoen. Samle temperaturene i en liste per dato, og regn gjennomsnitt til slutt.

Funksjonen skal gi antall målinger, men krasjer med KeyError. Rett den, slik at den gir \(0\) hvis nøkkelen hourly mangler.

Bruk .get("hourly", {}).get("time", []).

Utfordringer

Svaret fra et API er en liste av steder: [{"navn": "Oslo", "maalinger": [3, 4, 5]}, ...]. Skriv funksjonen varmest(json_tekst) som gir navnet på stedet med høyest gjennomsnittstemperatur. Steder uten målinger hoppes over. Er det ingen steder, gir den None.

Regn ut gjennomsnitt for hvert sted som har målinger, og velg det største med max(..., key=...).

Du skal bruke et nytt API du ikke kjenner. Hva gjør du før du skriver koden? Nevn minst tre ting.

Les dokumentasjonen (adresse, parametere, hva svaret inneholder, grenser og vilkår). Sjekk om du trenger en API-nøkkel. Åpne adressen i nettleseren, eller skriv ut svaret med json.dumps(data, indent=2), for å se hvordan JSON-en er bygget opp. Prøv med noen få kall, og lagre svaret i en fil, så du ikke bruker opp grensen for antall kall mens du utvikler.

Oppsummering

URL

https://tjener.no/sti?nokkel=verdi&n=3

https protokoll · tjener · sti · parametere

Hente JSON

from urllib.parse import urlencode
from urllib.request import urlopen
url = base + "?" + urlencode(param)
with urlopen(url, timeout=10) as svar:
    data = json.load(svar)

Statuskoder

  • \(2xx\) ok · \(4xx\) din feil · \(5xx\) tjenerens feil
  • \(404\) finnes ikke · \(429\) for mange kall
  • Bruk urlencode og timeout.
  • Se på svaret før du skriver koden som bruker det.
  • Lagre svaret i en fil, så du kan jobbe uten nett.

8.4.2 Robuste API-kall

Et program som henter data fra nettet, vil før eller siden møte problemer: nettet er nede, tjeneren er treg, tjenesten sier at du spør for ofte, eller svaret har et annet format enn du ventet. Et robust program tåler dette uten å krasje, og gir en forståelig beskjed eller bruker lagrede data. Dette bygger på try/except fra kapittel 4 og på filene du lærte i 8.2.

Læringsmål

Etter dette delkapittelet skal du kunne

  • nevne vanlige feil i API-kall og fange dem med riktige unntak,
  • skrive kode som prøver igjen etter en feil, og som venter lenger for hver gang,
  • bruke en lagret fil som reserve når nettet svikter,
  • skrive nettkode slik at den kan testes uten nett.

Hva kan gå galt?

Situasjon Hva du får
Ingen nett eller tjeneren er nede URLError (eller ConnectionError med requests)
Tjeneren svarer ikke i tide TimeoutError / URLError
Tjeneren svarer med en feilkode (404, 500, 429) HTTPError (med urllib)
Svaret er ikke gyldig JSON json.JSONDecodeError
Svaret mangler feltet du leter etter KeyError

Alle disse er vanlige, og du bør vente dem. I urllib er HTTPError en undertype av URLError, som igjen er en undertype av OSError, og JSONDecodeError er en ValueError. Husk fra 7.1.1 at except også fanger undertypene. Vi kan se noen av feilene uten nett:

import json, urllib.request, urllib.error

try:
    urllib.request.urlopen("http://localhost:1/", timeout=2)
except urllib.error.URLError as feil:
    print("Fanget", type(feil).__name__)

try:
    json.loads("Dette er ikke JSON")
except json.JSONDecodeError as feil:
    print("Fanget", type(feil).__name__, "-", feil)
Fanget URLError
Fanget JSONDecodeError - Expecting value: line 1 column 1 (char 0)

Det første kallet prøver å nå en port der ingenting lytter, og får URLError. Det andre prøver å lese tull som JSON, og får JSONDecodeError.

RegelRobuste kall
  1. Bruk alltid timeout.
  2. Fang de bestemte feilene du venter (ikke en tom except).
  3. Gi en klar beskjed til brukeren, og la programmet fortsette hvis det går an.
  4. Prøv igjen noen få ganger for feil som kan gå over (nett som hakker, 429, 503).
  5. Ha en reserve: en lagret fil med forrige svar.

Prøve igjen

Mange feil er midlertidige. Da hjelper det å vente litt og prøve på nytt. Det er lurt å vente lenger for hver gang (1, 2, 4 sekunder …), så du ikke overbelaster en tjeneste som allerede sliter. Det kalles eksponentiell backoff. Her er en funksjon som tar den funksjonen som henter dataene som parameter. Da kan vi teste den uten nett, ved å gi den en falsk henter:

import time

def hent_med_forsok(hent, url, maks_forsok=3, vent=time.sleep):
    for forsok in range(maks_forsok):
        try:
            return hent(url)
        except OSError as feil:
            print(f"Forsøk {forsok + 1} feilet: {feil}")
            if forsok == maks_forsok - 1:
                raise
            vent(2 ** forsok)

samtaler = []

def uten_nett(url):
    samtaler.append(url)
    if len(samtaler) < 3:
        raise ConnectionError("ingen forbindelse")
    return {"temp": 4.5}

ventet = []
print(hent_med_forsok(uten_nett, "http://x", vent=ventet.append))
print(ventet)
Forsøk 1 feilet: ingen forbindelse
Forsøk 2 feilet: ingen forbindelse
{'temp': 4.5}
[1, 2]

Den falske uten_nett feiler de to første gangene og lykkes den tredje. Funksjonen prøver til den får svar, og ventetidene ble \(1\) og \(2\) sekunder (her bare lagret i en liste, siden vi sendte inn ventet.append i stedet for time.sleep). Etter siste forsøk gir den opp og utløser feilen videre med raise, så den som kalte funksjonen, kan bestemme hva som skjer.

Å sende inn funksjonen som henter dataene, og også funksjonen som venter, kalles injeksjon (dependency injection). Det gjør at du kan teste logikken din (hvor mange forsøk, hvor lenge å vente) uten å bruke nett eller faktisk vente. Det er en vanlig teknikk i all programmering.

def alltid_feil(url):
    raise ConnectionError("nede")

hent_med_forsok(alltid_feil, "x", maks_forsok=2, vent=lambda s: None)

Hva skjer?

Hva gjør funksjonen etter siste forsøk?

Den skriver Forsøk 1 feilet: nede og Forsøk 2 feilet: nede, og etter andre forsøk utløses ConnectionError: nede videre, siden det var siste forsøk. Programmet som kalte funksjonen, må fange feilen.

Reserve: lagret svar

Hvis det ikke går å hente nye data, kan programmet bruke de gamle. Her bruker vi en ordbok som cache (i et ekte program er det en fil):

def hent_eller_reserve(hent, url, cache):
    try:
        data = hent(url)
    except OSError:
        if url in cache:
            print("Ingen nett, bruker lagret svar")
            return cache[url]
        raise
    cache[url] = data
    return data

def virker(url):
    return {"temp": 4.5}

def virker_ikke(url):
    raise ConnectionError("ingen nett")

cache = {}
print(hent_eller_reserve(virker, "x", cache))
print(hent_eller_reserve(virker_ikke, "x", cache))
{'temp': 4.5}
Ingen nett, bruker lagret svar
{'temp': 4.5}

Første gang virker nettet, og svaret lagres. Andre gang er det nede, og vi bruker det lagrede svaret. Finnes ikke noe lagret svar, utløses feilen, for da har vi ingenting å vise.

Sjekke svaret

Selv når kallet går bra, kan svaret være annerledes enn du ventet. Sjekk det, og gi en forståelig beskjed i stedet for å krasje:

def les_temperatur(json_tekst):
    try:
        data = json.loads(json_tekst)
    except json.JSONDecodeError:
        return None
    try:
        return data["hourly"]["temperature_2m"][0]
    except (KeyError, IndexError, TypeError):
        return None

print(les_temperatur('{"hourly": {"temperature_2m": [4.5]}}'))
print(les_temperatur("tull"))
print(les_temperatur('{"feil": "ukjent sted"}'))
print(les_temperatur('{"hourly": {"temperature_2m": []}}'))
4.5
None
None
None

Funksjonen gir None i stedet for å krasje når svaret ikke er gyldig JSON, når nøklene mangler, eller når lista er tom. Den som kaller, sjekker for None og viser en melding til brukeren. Merk at vi fanger flere ulike typer feil i samme except, med en tuppel av typene.

NoteSkriv gode feilmeldinger

En god feilmelding sier hva som skjedde og hva brukeren kan gjøre: «Fikk ikke kontakt med værtjenesten. Sjekk at du har nett, eller prøv igjen om litt.» En dårlig melding er «Feil» eller en lang Python-traceback. Du kan godt skrive den tekniske feilen i en loggfil, men brukeren trenger en forståelig melding.

AdvarselVanlige feil
  • Å glemme timeout, så programmet henger.
  • Å bruke en tom except: som skjuler feil du ikke har tenkt på.
  • Å prøve igjen i en uendelig løkke, uten grense eller ventetid.
  • Å prøve igjen umiddelbart, så du overbelaster en tjeneste som allerede sliter.
  • Å prøve igjen for feil som aldri vil gå over (404, 401).
  • Å anta at svaret har riktig form, og krasje på KeyError.
  • Å skrive koden slik at den bare kan testes med ekte nett.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hva slags feil forventer du i hvert tilfelle? a) Du er uten nett. b) Tjeneren svarer med 404. c) Svaret er HTML i stedet for JSON. d) Svaret mangler nøkkelen temp.

  1. URLError (eller ConnectionError). b) HTTPError (urllib). c) JSONDecodeError. d) KeyError.

Hvorfor venter vi \(1\), \(2\), \(4\) sekunder mellom forsøkene i stedet for å prøve igjen med en gang?

Hvis tjeneren er overbelastet, gjør det bare saken verre at mange programmer spør igjen og igjen med en gang. Ved å vente lenger for hver gang gir vi tjeneren tid til å komme seg, og feil som går over av seg selv, får tid til det. Uten pause kan vi dessuten brukt opp alle forsøkene på noen få millisekunder.

Nivå 2
try:
    svar = hent(url)
except:
    print("Feil")

Gi tre problemer.

  1. Den tomme except fanger alle feil, også skrivefeil i koden og Ctrl+C. 2. Meldingen «Feil» sier ikke hva som skjedde eller hva brukeren kan gjøre. 3. Programmet fortsetter som om det gikk bra, men svar finnes ikke, så neste linje som bruker det, krasjer. Fang bestemte feil (URLError, JSONDecodeError), gi en klar melding, og avgjør hva som skal skje videre.

Hvilke bør du prøve igjen på, og hvilke ikke? a) ingen nett, b) 404, c) 429, d) 503, e) 401.

Prøv igjen på a) (nettet kan komme tilbake), c) (vent litt, og forsøk igjen) og d) (tjeneren kan komme seg). Ikke prøv igjen på b) (adressen er feil og blir ikke riktig av å vente) og e) (du mangler tilgang, og må fikse nøkkelen).

Kodeoppgaver

I disse oppgavene får funksjonene en falsk hent-funksjon, så du slipper nett.

Skriv funksjonen trygg_json(tekst) som gir Python-objektet fra JSON-teksten, eller None hvis teksten ikke er gyldig JSON.

try/except json.JSONDecodeError.

Skriv funksjonen temperatur(json_tekst) som gir data["hourly"]["temperature_2m"][0], men gir None hvis teksten ikke er JSON, nøkkelen mangler eller lista er tom.

Fang json.JSONDecodeError og (KeyError, IndexError, TypeError).

Skriv funksjonen hent_med_forsok(hent, url, maks_forsok, vent). Den kaller hent(url). Går det bra, gir den svaret. Utløser hent en ConnectionError, venter den med vent(sekunder) (første gang \(1\), så \(2\), \(4\), …) og prøver igjen. Etter maks_forsok mislykkede forsøk utløser den feilen videre. Den venter ikke etter siste forsøk.

Løkke over range(maks_forsok). I except: er det siste forsøk, raise. Ellers vent(2 ** forsok).

Skriv funksjonen hent_eller_cache(hent, url, cache). Den kaller hent(url) og lagrer svaret i ordboken cache med url som nøkkel. Utløser hent en ConnectionError, gir den svaret fra cache hvis det finnes, og utløser ellers feilen.

try: ... except ConnectionError: if url in cache: return cache[url] og raise.

Skriv funksjonen ventetid(forsok, maks=30) som gir ventetiden i sekunder før forsøk nummer forsok (starter på \(0\)): \(1\), \(2\), \(4\), \(8\), … men aldri mer enn maks.

min(2 ** forsok, maks).

Skriv funksjonen hent_alle(hent, urler) som gir en ordbok fra hver adresse til svaret, men None for adresser der hent utløser en ConnectionError. Programmet skal fortsette med de neste.

try/except inni løkka, så én feil ikke stopper resten.

Funksjonen skal prøve tre ganger og så gi opp ved å utløse feilen. Når alle forsøkene feiler, gir den i stedet None, så programmet som kaller den, tror at alt gikk bra. Rett den.

pass svelger feilen. Er det tredje forsøk, kast feilen videre med raise.

Utfordringer

Skriv hent_smart(hent, url, maks_forsok, vent). hent(url) kan utløse ConnectionError (prøv igjen) eller ValueError (ugyldig forespørsel, prøv ikke igjen, utløs med en gang). Ellers som i hent_med_forsok, med ventetid \(1, 2, 4, \ldots\).

Fang bare ConnectionError i except. ValueError slipper da rett gjennom.

På eksamen har du ikke nett, men oppgaven sier «hent data fra API-et». Hva gjør du?

Oppgaven vil i praksis gi deg en lagret JSON- eller CSV-fil med svaret. Du leser fra fila (json.load eller csv.DictReader) og bruker den samme koden for å plukke ut data som du ville brukt på et svar fra nettet. Skriver du koden slik at funksjonen som henter er adskilt fra koden som bruker dataene, kan du enkelt bytte ut nettkallet med å lese fra fil.

Oppsummering

Feil å vente

  • Ingen nett: URLError / ConnectionError
  • Tjenerfeil: HTTPError
  • Ugyldig svar: JSONDecodeError
  • Mangler felt: KeyError

Prøve igjen

for forsok in range(maks):
    try:
        return hent(url)
    except ConnectionError:
        if forsok == maks - 1:
            raise
        vent(2 ** forsok)

Reserve

except ConnectionError:
    if url in cache:
        return cache[url]
    raise
  • Alltid timeout. Alltid en grense for antall forsøk.
  • Fang bestemte feil, og gi en klar melding.
  • Send inn hent som parameter, så koden kan testes uten nett.

8.5 Sikring av data

Data har verdi, og det som har verdi, må beskyttes mot å gå tapt, bli ødelagt eller havne i feil hender.

8.5.1 Sikkerhetskopi, tilgang og kryptering

Tenk deg at all koden og alle prosjektene dine ligger på én datamaskin, og at den blir stjålet, faller i bakken eller blir rammet av et virus som krypterer alle filene. Hva gjør du da? På skolen og i arbeidslivet er det ikke bare mulig at dette skjer, det er sikkert at det vil skje før eller siden. Å sikre data handler om tre ting: at dataene ikke går tapt (sikkerhetskopi), at bare de rette får tilgang (tilgangsstyring), og at de ikke kan leses av andre selv om de skulle komme på avveie (kryptering).

Læringsmål

Etter dette delkapittelet skal du kunne

  • forklare hvorfor og hvordan vi tar sikkerhetskopi, og bruke 3-2-1-regelen,
  • forklare forskjellen på autentisering og autorisasjon, og prinsippet om minst mulig tilgang,
  • forklare forskjellen på hashing og kryptering, og på symmetrisk og asymmetrisk kryptering,
  • lagre passord trygt med hash og salt,
  • bruke hashing til å sjekke at en fil ikke er endret.

Sikkerhetskopi

Data kan gå tapt på mange måter: diskfeil, tyveri, brann, utilsiktet sletting, virus, eller at du overskriver feil fil. Den eneste beskyttelsen er å ha en sikkerhetskopi (backup). En enkel og vanlig huskeregel er 3-2-1:

Regel3-2-1-regelen
  • 3 kopier av dataene (originalen og to sikkerhetskopier),
  • på 2 ulike typer lagring (for eksempel maskinen og en ekstern disk),
  • med 1 kopi et annet sted (for eksempel i skyen, eller hjemme hos en annen), i tilfelle brann eller tyveri.

Husk også:

  • Automatiser. En sikkerhetskopi du må huske å ta, blir ikke tatt.
  • Test at du kan gjenopprette. En sikkerhetskopi du ikke har prøvd å bruke, kan være ubrukelig.
  • Sikkerhetskopi er ikke det samme som Git. Git tar vare på historikken til koden din (se 11.2), og GitHub er en kopi, men en backup bør også dekke data som ikke er i Git, som databasefiler og innstillinger.
  • Beskytt sikkerhetskopiene. De inneholder de samme sensitive dataene som originalen.

Med Python kan du kopiere filer med shutil, og gi hver kopi et navn med tidspunktet, så du ikke overskriver den forrige:

import shutil, tempfile, os
from datetime import datetime
from pathlib import Path

mappe = Path(tempfile.mkdtemp())
original = mappe / "rapport.txt"
original.write_text("viktig innhold", encoding="utf-8")

def ta_backup(fil, backup_mappe, tidspunkt):
    backup_mappe.mkdir(exist_ok=True)
    stempel = tidspunkt.strftime("%Y-%m-%d_%H%M")
    ny = backup_mappe / f"{fil.stem}_{stempel}{fil.suffix}"
    shutil.copy2(fil, ny)
    return ny

kopi = ta_backup(original, mappe / "backup", datetime(2026, 11, 18, 14, 30))
print(kopi.name)
print(kopi.read_text(encoding="utf-8"))
rapport_2026-11-18_1430.txt
viktig innhold

shutil.copy2 kopierer fila (og beholder tidsstemplene), og strftime formaterer tidspunktet som tekst. Vi sender tidspunktet inn som parameter, så funksjonen er lett å teste. Navnet blir rapport_2026-11-18_1430.txt. Vil du kopiere en hel mappe, bruker du shutil.copytree.

Tilgangsstyring

Det er ikke nok å beskytte mot tap. Noen data skal bare noen få se. Her er to begreper man må kunne skille:

  • Autentisering er å bevise hvem du er (brukernavn og passord, fingeravtrykk, kode fra en app).
  • Autorisasjon er å avgjøre hva du har lov til når vi vet hvem du er.

Et viktig prinsipp er minst mulig tilgang (least privilege): hver bruker og hvert program skal ha akkurat den tilgangen som trengs for oppgaven, og ikke mer. En elev trenger ikke tilgang til lærernes karakterlister, og en app som viser været, trenger ikke tilgang til kontaktlista di. Da blir skaden mindre hvis en konto blir kapret.

Tilgang gis ofte gjennom roller. Her er en enkel modell med en ordbok:

rettigheter = {
    "elev": {"les_egne"},
    "laerer": {"les_egne", "les_klasse", "skriv_karakter"},
    "admin": {"les_egne", "les_klasse", "skriv_karakter", "slett_bruker"},
}

def har_tilgang(rolle, handling):
    return handling in rettigheter.get(rolle, set())

print(har_tilgang("laerer", "skriv_karakter"))
print(har_tilgang("elev", "skriv_karakter"))
print(har_tilgang("ukjent", "les_egne"))
True
False
False

Ukjente roller får ingen rettigheter, og det er riktig: er du i tvil, nekt tilgang. Gode passord er lange (heller flere ord enn et kort, rotete passord), unike for hver tjeneste, og lagret i en passordbehandler. To-faktor-innlogging (passord pluss noe du har, som en mobilapp) gjør det mye vanskeligere å bryte seg inn.

Hashing: passord skal aldri lagres som tekst

Når en bruker oppretter en konto, må du kunne sjekke passordet senere. Men du skal aldri lagre selve passordet. Kommer databasen på avveie, har angriperen alle passordene, og siden mange bruker det samme passordet flere steder, rammer det langt utover din tjeneste.

Løsningen er en hash-funksjon. Den gjør en tekst om til en kort «fingeravtrykk»-tekst, og har tre viktige egenskaper: samme tekst gir alltid samme hash, en liten endring gir en helt annen hash, og det er (nesten) umulig å gå baklengs fra hashen til teksten.

import hashlib

print(hashlib.sha256("hei".encode("utf-8")).hexdigest())
print(hashlib.sha256("Hei".encode("utf-8")).hexdigest()[:16])
print(len(hashlib.sha256(b"").hexdigest()))
f9d1af62d004d4da648929bc7dde552685979d6e6a78dc8f9b64eb08e9c4ccb7
e661b9dd3a729319
64

sha256 er en vanlig hash-funksjon, og gir alltid \(64\) hex-sifre (\(256\) bits), uansett hvor lang teksten er. «hei» og «Hei» gir helt ulike hasher. Vi lagrer hashen, og når brukeren logger inn, hasher vi det de skrev og sammenligner med den lagrede hashen. Passordet er aldri lagret.

Men en ren hash er ikke nok. Mange bruker de samme passordene, og angripere har ferdige lister med hashene til millioner av vanlige passord. Løsningen er salt: en tilfeldig tekst som er forskjellig for hver bruker, og som legges til passordet før hashing. Da får to brukere med samme passord ulike hasher, og de ferdige listene er ubrukelige. I tillegg bruker man en bevisst treg hash-funksjon, slik at det tar lang tid å prøve mange passord:

import secrets

def lag_hash(passord, salt):
    return hashlib.pbkdf2_hmac(
        "sha256", passord.encode("utf-8"), salt.encode("utf-8"), 100_000
    ).hex()

salt = secrets.token_hex(16)
lagret = lag_hash("hemmelig123", salt)

def sjekk_passord(forsok, salt, lagret):
    return lag_hash(forsok, salt) == lagret

print(sjekk_passord("hemmelig123", salt, lagret))
print(sjekk_passord("feil", salt, lagret))
print(lag_hash("hemmelig123", "a") == lag_hash("hemmelig123", "b"))
True
False
False

secrets.token_hex(16) lager en tilfeldig salt (bruk secrets, ikke random, til sikkerhetsformål). pbkdf2_hmac er en hash laget for passord, som gjentar beregningen \(100\,000\) ganger. Vi lagrer saltet og hashen (saltet er ikke hemmelig). Samme passord med ulikt salt gir ulik hash.

RegelLagre passord
  1. Lagre aldri passord som tekst.
  2. Lag et tilfeldig salt per bruker.
  3. Lagre saltet og hashen av salt og passord, med en treg hash-funksjon (som pbkdf2_hmac).
  4. Ved innlogging: hash det brukeren skrev inn med samme salt, og sammenlign.

Hashing brukes også til å sjekke at en fil ikke er endret: regn ut hashen av fila, og sammenlign den med den kjente hashen. Er de like, er innholdet identisk. Det brukes når du laster ned programmer.

Du har to tekster, a og b. Hvordan kan du sjekke om de er helt like uten å sammenligne dem tegn for tegn?

Sammenlign hashene.

a = "Innholdet i fila"
b = "Innholdet i fila."
ha = hashlib.sha256(a.encode()).hexdigest()
hb = hashlib.sha256(b.encode()).hexdigest()
print(ha == hb)
print(ha[:12], hb[:12])
False
72d5695a2b9c 37a827e95a9d

Et enkelt punktum gir en helt ulik hash. Er hashene like, er innholdet (nesten sikkert) identisk.

Kryptering

Hashing kan ikke reverseres. Kryptering er det motsatte: data gjøres uleselig med en nøkkel, og kan gjøres lesbar igjen med riktig nøkkel. Det brukes når du må kunne få dataene tilbake: meldinger, filer, nettrafikk.

  • Symmetrisk kryptering bruker samme nøkkel til å låse og låse opp (som AES). Den er rask, men avsender og mottaker må på en trygg måte dele nøkkelen.
  • Asymmetrisk kryptering bruker et nøkkelpar: en offentlig nøkkel som alle kan få, og en privat nøkkel som bare eieren har. Hva som krypteres med den offentlige, kan bare åpnes med den private. Da kan hvem som helst sende deg en hemmelig melding uten at dere har delt noe hemmelig først. Den er tregere, så i praksis bruker man den til å dele en symmetrisk nøkkel.

Når du åpner en nettside med https, skjer akkurat dette (protokollen heter TLS): nettleseren og tjeneren bruker asymmetrisk kryptering til å avtale en nøkkel, og så bruker de symmetrisk kryptering til selve trafikken. Slik kan ingen som lytter på nettet, lese passordet ditt. Derfor skal alle API-er og nettsider bruke https, ikke http.

I forrige delkapittel lagde vi et enkelt Cæsar-chiffer. Det viser hovedideen, men er ikke trygt. Det finnes bare \(25\) nøkler, og de kan prøves på et øyeblikk. Lag aldri din egen kryptering til noe viktig. Bruk velprøvde biblioteker (som pakken cryptography) og standarder.

AdvarselKoding er ikke kryptering

Mange tror at koding som Base64 beskytter dataene. Det gjør den ikke. Den gjør bare bytes om til tegn som kan sendes som tekst, og alle kan gjøre den om igjen uten noen nøkkel:

import base64

kodet = base64.b64encode("passord123".encode("utf-8"))
print(kodet)
print(base64.b64decode(kodet).decode("utf-8"))
b'cGFzc29yZDEyMw=='
passord123

«Koding» (UTF-8, Base64) er åpen og kan reverseres av alle. «Hashing» kan ikke reverseres. «Kryptering» kan reverseres, men bare med nøkkelen.

Personvern

Når dataene handler om personer, kommer også loven inn. I Norge og EU gjelder personvernforordningen (GDPR). Noen hovedprinsipper: samle bare inn de dataene du trenger (dataminimering), bruk dem bare til det du sa de skulle brukes til, ha samtykke eller et annet lovlig grunnlag, slett dem når de ikke trengs lenger, og sikre dem mot uvedkommende. Personen har rett til å se, rette og i mange tilfeller få slettet dataene om seg selv. Dette er viktig når du lager systemer som lagrer navn, adresser eller karakterer, som i prosjektene dine, og du kommer tilbake til det i kapittel 12.

AdvarselVanlige feil
  • Å ha bare én kopi av viktige data.
  • Å ta backup, men aldri teste at den kan gjenopprettes.
  • Å lagre passord som tekst, eller bare som en hash uten salt.
  • Å bruke random i stedet for secrets til sikkerhet.
  • Å tro at Base64 eller et Cæsar-chiffer er trygt.
  • Å lage sin egen kryptering.
  • Å gi alle brukere full tilgang «for å gjøre det enkelt».
  • Å legge passord, nøkler og personopplysninger på GitHub.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Forklar hva 3-2-1-regelen betyr. Oppfyller denne løsningen regelen: originalen på pc-en og én kopi på en ekstern disk som ligger ved siden av pc-en?

Tre kopier, på to typer lagring, med én kopi et annet sted. Løsningen oppfyller ikke regelen: det er bare to kopier, og begge ligger på samme sted. Skjer det en brann eller et innbrudd, kan begge gå tapt. Legg til en kopi i skyen eller et annet sted.

Hva er hva? a) Du taster passordet ditt. b) Systemet sjekker at du har lov til å slette en fil. c) Du bruker fingeravtrykk for å låse opp telefonen. d) Systemet nekter eleven å endre en karakter.

  1. Autentisering. b) Autorisasjon. c) Autentisering. d) Autorisasjon.

Hva er hva? a) Teksten gjøres om til en fast lengde, og kan ikke gjøres om igjen. b) Teksten gjøres uleselig, og kan åpnes med en nøkkel. c) Bytes gjøres om til tegn, uten nøkkel, og kan gjøres om av alle.

  1. Hashing. b) Kryptering. c) Koding (for eksempel Base64).
Nivå 2

To brukere velger passordet «hemmelig123». Hva er problemet hvis vi bare lagrer sha256 av passordet, og hvordan hjelper salt?

Begge får samme hash, så den som ser én hash, vet at de har samme passord, og kan slå opp hashen i en ferdig liste over vanlige passord. Med et tilfeldig salt per bruker blir hashene ulike, og de ferdige listene er ubrukelige. Angriperen må gå løs på hver bruker for seg.

Hva passer best? a) Du krypterer en fil på din egen disk, og er den eneste som skal åpne den. b) Mange ukjente personer skal kunne sende deg hemmelige meldinger. c) Nettleseren og en nettbank skal avtale en nøkkel for å snakke sammen.

  1. Symmetrisk (én nøkkel, som du holder hemmelig). b) Asymmetrisk (alle bruker din offentlige nøkkel, og bare du har den private). c) Asymmetrisk til å avtale nøkkelen, og så symmetrisk til selve samtalen (slik TLS gjør).

Forklar prinsippet, og gi et eksempel fra en skole.

Hver bruker og hvert program skal bare ha de rettighetene som trengs for oppgaven. På en skole kan en elev lese egne karakterer, en lærer skrive karakterer i egne fag, og bare administratoren kan slette brukere. Blir en elevkonto kapret, kan angriperen ikke endre karakterer.

Kodeoppgaver

Skriv funksjonen sha(tekst) som gir SHA-256-hashen til teksten (UTF-8) som en tekst med hex-sifre.

hashlib.sha256(tekst.encode("utf-8")).hexdigest().

Skriv funksjonen lag_hash(passord, salt) som gir hashlib.pbkdf2_hmac("sha256", passord, salt, 1000) (begge som UTF-8-bytes) som hex-tekst. Skriv også sjekk_passord(forsok, salt, lagret) som gir True hvis forsøket gir den lagrede hashen.

hashlib.pbkdf2_hmac("sha256", passord.encode(), salt.encode(), 1000).hex(), og sammenlign.

Skriv funksjonen backup_navn(filnavn, tidspunkt) som gir navnet på sikkerhetskopien: filnavnet uten endelse, så _, så tidspunktet som ÅÅÅÅ-MM-DD_TTMM, så endelsen. tidspunkt er et datetime-objekt.

Path(filnavn).stem og .suffix, og tidspunkt.strftime("%Y-%m-%d_%H%M").

Skriv funksjonen ta_backup(fil, mappe) som kopierer fila til mappen (som lages hvis den ikke finnes) med samme navn, og gir banen til kopien som Path.

mappe.mkdir(exist_ok=True) og shutil.copy2(fil, mappe / fil.name).

Skriv funksjonen like_filer(sti1, sti2) som gir True hvis de to filene har samme innhold. Sammenlign SHA-256-hasher av bytes.

hashlib.sha256(Path(sti).read_bytes()).hexdigest() for begge filene.

Skriv funksjonen har_tilgang(rolle, handling) som bruker ordboken rettigheter (fra rolle til mengde av handlinger). Ukjente roller har ingen tilgang.

handling in rettigheter.get(rolle, set()).

Skriv funksjonen er_sterkt(passord) som gir True hvis passordet har minst \(12\) tegn, og både store og små bokstaver og minst ett siffer.

any(t.isupper() for t in passord) og tilsvarende for islower og isdigit.

Funksjonen lagrer passordet som tekst. Rett den slik at den lagrer en hash (sha256) av saltet og passordet, og sjekker innlogging mot hashen.

Hash salt + passord med hashlib.sha256(...).hexdigest() både når du lagrer og når du sjekker.

Utfordringer

Skriv funksjonen slett_gamle(navn, behold) som tar en liste med filnavn på sikkerhetskopier (der navnet inneholder datoen, som rapport_2026-11-18_1430.txt) og gir lista med navnene som bør slettes, når de behold nyeste skal beholdes. Navnene sorteres etter datoen i navnet.

Navnene har datoen i et fast format, så vanlig alfabetisk sortering gir tidsrekkefølge. Sorter, og ta alle unntatt de behold siste.

Du lager et program som lagrer elevenes navn og karakterer. Beskriv hvordan du vil sikre dataene: hvor lagres de, hvem får tilgang, hva skjer ved tap, og hva er viktig med tanke på personvern.

Et mulig svar: dataene lagres i en database med tilgang bare for de som trenger det (elever ser egne karakterer, lærere sine fag, administrator alt, minst mulig tilgang). Brukerne logger inn med passord som er lagret med salt og en treg hash. All trafikk går over https. Databasen sikkerhetskopieres automatisk etter 3-2-1-regelen, og jeg tester at kopien kan gjenopprettes. Jeg samler bare inn de opplysningene jeg trenger (dataminimering), sletter dem når de ikke trengs lenger, og passer på at API-nøkler og passord ikke ligger i koden eller på GitHub.

Oppsummering

Backup: 3-2-1

  • 3 kopier
  • 2 typer lagring
  • 1 på et annet sted

Automatiser, og test gjenoppretting.

Tilgang

  • Autentisering: hvem er du?
  • Autorisasjon: hva har du lov til?
  • Minst mulig tilgang

Hash, koding, kryptering

  • Hash: én vei (sha256)
  • Koding: åpen (Base64, UTF-8)
  • Kryptering: nøkkel åpner den

Passord

salt = secrets.token_hex(16)
h = hashlib.pbkdf2_hmac(
    "sha256", pw.encode(), salt.encode(), 100_000
).hex()
  • Lagre aldri passord som tekst, og lag aldri din egen kryptering.
  • Base64 er koding, ikke kryptering.
  • Bruk https, og ha ikke nøkler eller passord i koden.

8.6 Bruk det i prosjektene

8.7 Oppgaver

Disse oppgavene blander temaene fra hele kapittelet. Flere oppgaver finner du i notatboka (lenkene øverst i kapittelet).

Hva bruker du? a) lagre en høyscore-liste for et spill, b) lagre \(50\,000\) billetter som må søkes i raskt og henge sammen med filmer og kunder, c) få været fra en tjeneste på nettet, d) åpne en tabell fra et regneark i Python, e) lagre passord.

  1. JSON-fil (liten, enkel struktur). b) Database med SQL (mange rader, relasjoner, raske søk). c) API (urlopen eller requests), og lagre svaret i en fil. d) CSV (csv.DictReader). e) Hash med salt, aldri som tekst.

Skriv funksjonen csv_til_db(csv_tekst) som tar CSV-tekst med kolonnene navn, klasse og poeng, lager en database i minnet med tabellen elev (navn, klasse, poeng), legger inn radene (poeng som heltall) og gir databasen (sqlite3-forbindelsen).

CREATE TABLE, så DictReader og executemany med (r["navn"], r["klasse"], int(r["poeng"])).

Skriv funksjonen db_til_json(con) som leser alle radene i tabellen elev (navn, klasse, poeng) (sortert på navn) og gir dem som en JSON-tekst: en liste av objekter med nøklene navn, klasse og poeng.

Sett con.row_factory = sqlite3.Row og bruk dict(rad), eller lag ordbøkene selv av tuplene.

Brukeren skriver et navn i en nettside, og programmet lagrer det i en database og viser en melding. Beskriv minst tre ting du må tenke på for at dette skal være trygt og robust.

Bruk plassholdere (?) i SQL, så navnet ikke kan inneholde SQL-kode (SQL-injection). Sjekk at navnet er gyldig (ikke tomt, ikke altfor langt). Bruk UTF-8 gjennom hele kjeden, så æ, ø og å ikke blir rot. Sikkerhetskopier databasen. Husk at navn er personopplysninger, så bare de som trenger det, skal ha tilgang, og du skal ikke samle inn mer enn du trenger. Gå trafikken over nett, skal den gå over https.

Finn et lite, åpent datasett (for eksempel fra SSB eller en kommune, som CSV eller JSON). Last det ned, les det i Python, og svar på to spørsmål ved å regne på dataene. Lagre resultatet i en ny fil og i en SQLite-database, og skriv to SQL-spørringer som gir de samme svarene. Sammenlign hvordan det føltes å bruke fil og database.

Sjekk at filen er lest med riktig koding og skilletegn, at tall er gjort om til int eller float, at spørsmålene er besvart riktig i begge løsningene (Python og SQL gir samme tall), at SQL bruker plassholdere der verdier kommer utenfra, og at du har tenkt på kilde, lisens og eventuelle personopplysninger i datasettet.

8.8 Oppsummering

Digital representasjon

Tall

bin(10); int("1010", 2)
hex(255); int("ff", 16)
f"{5:08b}"

\(n\) bits gir \(2^n\) verdier.

Tegn

ord("å"); chr(229)
"å".encode("utf-8")     # 2 bytes

UTF-8 er standarden.

Filer og formater

Tekstfil og pathlib

with open("f.txt", "w", encoding="utf-8") as f:
    f.write("tekst\n")
Path("data") / "f.txt"

CSV

csv.DictReader(f, delimiter=";")

Alt er tekst.

JSON

json.loads(tekst); json.dumps(d)
json.load(f); json.dump(d, f)

Databaser og API-er

SQL

con = sqlite3.connect("f.db")
con.execute("SELECT * FROM t WHERE x = ?", (v,))
con.commit()

API

url = base + "?" + urlencode(param)
with urlopen(url, timeout=10) as r:
    data = json.load(r)

Fang feil, prøv igjen, lagre svaret.

Sikring

Sikring

  • Backup: 3-2-1
  • Minst mulig tilgang
  • Passord: salt og hash
  • https
  • encoding="utf-8" og with open(...).
  • Bruk plassholdere i SQL, aldri f-strenger.
  • Ha en lagret fil som reserve for API-et. Data kommer som filer på eksamen.
  • Lag aldri din egen kryptering.