3.2 Ordbøker

En samling par av en nøkkel og en verdi, der du slår opp verdien ved å oppgi nøkkelen.

Du skriver den med krøllparenteser, kolon mellom nøkkel og verdi, og komma mellom parene:

levert = {"kartong": 12, "glass": 7, "metall": 3}
print(levert)
print(levert["glass"])

Utskrift:

{'kartong': 12, 'glass': 7, 'metall': 3}
7

Sammenlign med lista: der er plassen et tall du må holde styr på selv, her er plassen et navn du velger. Det er hele forskjellen, og den gjør oppslag enkle: du trenger ikke lete gjennom samlingen for å finne det du er ute etter.

Ordboka heter dict i Python, etter det engelske ordet for ordbok. Du vil se det navnet i feilmeldinger.

En ordbok skrevet rett inn i koden. Den kan være tom:

tom = {}
antall = {"kartong": 12, "glass": 7}
print(tom, len(tom))
print(antall, len(antall))

Utskrift:

{} 0
{'kartong': 12, 'glass': 7} 2

len(...) gir antall par, ikke antall tegn eller verdier.

Den tomme ordboka {} er startpunktet i alle tre idiomene du skal lære her — akkurat som den tomme lista var det i forrige kapittel. Merk at det er krøllparenteser, ikke hakeparenteser: [] er en tom liste, {} er en tom ordbok.

De to halvdelene av et par.

Nøkkelen er det du slår opp på — som regel en tekst, men den kan også være et
tall. Verdien er det du får igjen, og den kan være hva som helst: et tall, en tekst, en liste, eller senere i boka et helt objekt.

I {"kartong": 12} er "kartong" nøkkelen og 12 verdien. Rekkefølgen i skrivemåten er alltid nøkkel først, så kolon, så verdi.

Én regel skiller de to: nøklene er unike, mens verdiene godt kan gjenta seg.
To varer kan ha tallet 12, men det finnes bare én "kartong".

Henter verdien som hører til nøkkelen. Skrivemåten er den samme hakeparentesen som i en liste — men innholdet er en nøkkel, ikke en plass:

levert = {"kartong": 12, "glass": 7, "metall": 3}
print(levert["glass"])
print(levert["kartong"] + levert["metall"])

Utskrift:

7
15

Resultatet er en helt vanlig verdi. Du kan regne med den, sammenligne den eller sende den videre til en funksjon.

Rekkefølgen betyr ingenting for oppslaget. levert["metall"] finner det
samme uansett om metall står først eller sist. Det er derfor du slipper å telle.

Setter inn et nytt par — eller overskriver verdien hvis nøkkelen finnes fra før:

levert = {"kartong": 12}
levert["glass"] = 7 levert["kartong"] = 20 print(levert)

Utskrift:

{'kartong': 20, 'glass': 7}

Legg merke til at de to siste linjene ser helt like ut, men gjør to ulike ting.
Den første oppretter nøkkelen "glass", som ikke fantes. Den andre
erstatter verdien til "kartong", og det gamle tallet 12 er borte for godt.

Dette er en viktig forskjell fra lista: der måtte plassen finnes fra før for at
liste[i] = v skulle virke. I en ordbok lages nøkkelen ved behov.

Svarer True eller False på om nøkkelen finnes:

levert = {"kartong": 12, "glass": 7}
print("glass" in levert)
print("plast" in levert)
print(12 in levert)

Utskrift:

True
False
False

Siste linje er fellen. Testen ser bare på nøklene, aldri på verdiene — og 12 er en verdi her, ikke en nøkkel.

in er selve sikkerhetsnettet foran et oppslag: slår du opp en nøkkel som ikke finnes, stopper programmet. Vanen som lønner seg er å skrive if k in d: før
d[k] hver gang du ikke er helt sikker.

Går gjennom nøklene, ikke verdiene. Verdien henter du selv med et oppslag:

levert = {"kartong": 12, "glass": 7}
for vare in levert:
    print(vare, levert[vare])

Utskrift:

kartong 12 glass 7

Dette er den ene tingen alle bommer på første gang: løkkevariabelen er
nøkkelen. Vil du ha verdien, skriver du levert[vare] inne i løkka.

Rekkefølgen er den parene ble satt inn i. Det er ikke noe du skal bygge en løsning på, men det er greit å vite når du sporer en utskrift.

levert = {"kartong": 12, "glass": 7, "metall": 3}
print(len(levert))
total = 0 for vare in levert:
    total = total + levert[vare]
print(total)

Utskrift:

3
22

Legg merke til at akkumulatormønsteret er helt uendret fra
kap. 1.3: startverdi før løkka, oppdatering inne i den, bruk etter. Det eneste nye er at verdien hentes med et oppslag.

Det er verdt å si høyt: len teller par, ikke kilo. Å blande antall nøkler med summen av verdiene er en klassisk lesefeil i en sporingsoppgave.

En verdi i en ordbok kan være hva som helst — også en liste.

grupper = {"kort": [12, 8, 3], "lang": [45]}
print(grupper["kort"])
print(grupper["kort"][1])
print(len(grupper), len(grupper["kort"]))

Utskrift:

[12, 8, 3]
8
2 3

Legg merke til den doble hakeparentesen på linje 2: grupper["kort"] gir lista, og [1] henter det andre elementet i den. Du leser slike uttrykk fra venstre, ett steg om gangen.

Og merk de to len-ene på siste linje. Den ene teller grupper og gir 2, den andre teller elementer i én gruppe og gir 3. De svarer på helt ulike spørsmål, og å blande dem er en klassisk lesefeil.

Én nøkkel med tilhørende verdi, altså én oppføring i ordboka. "glass": 7 er ett par.

len(ordbok) teller nøyaktig disse — ikke tegnene i nøklene og ikke summen av verdiene.

Når du sporer en ordbok gjennom en løkke, er det parene du skal skrive opp på nytt for hver runde. Det er den eneste måten å holde styr på hva som ble opprettet når.

En ordbok kan ikke ha to like nøkler. Skriver du d["glass"] = 7 og deretter
d["glass"] = 9, står det 9 igjen — den gamle verdien er borte.

Det er nettopp derfor tilordning kan brukes både til å opprette og til å oppdatere: Python trenger ikke spørre deg hva du mente.

Verdiene har ingen slik regel. To ulike nøkler kan gjerne peke på samme tall, og i en telling gjør de det ofte.

Tekster og tall er de to nøkkeltypene du trenger i dette faget, og de dekker alt du møter på eksamen: navn, koder, årstall, lengder.

En liste kan derimot ikke være nøkkel. Prøver du det, stopper programmet.
Grunnen er at nøkkelen må være en verdi som ikke kan endres etter at den er brukt — og en liste kan jo endres.

Verdien har ingen slik begrensning. Der kan du legge hva du vil, også lister og etter hvert dine egne objekter.

Python husker rekkefølgen parene ble satt inn i, og både print(ordbok) og
for k in ordbok: følger den.

Det gjør sporingsoppgaver forutsigbare: den nøkkelen som ble opprettet først, kommer først. Merk at det er opprettelsen som teller — å overskrive en verdi flytter ikke nøkkelen bakerst.

Bygg likevel aldri en løsning på rekkefølgen. Ber oppgaven om «den første», er det som regel den første i inndataene, ikke i ordboka.

En ordbok fra element til antall, bygget med teller-idiomet. Resultatet ser slik ut: {'glass': 3, 'kartong': 1}.

Kjenn den igjen på oppgaveteksten: «tell hvor mange ganger», «hvor mange av hver», «hvor mange ganger forekommer».

Den er halve svaret på ethvert «hvilken flest»-spørsmål. Andre halvdel er finn-beste-løkka, og de to skrives helst som hver sin funksjon — da rettes de hver for seg.

En ordbok der hver verdi er en liste: {'kort': [12, 8], 'lang': [45]}.

Kjenn den igjen på oppgaveteksten: «samle», «gruppér etter», «hvilke hører til hver».

Forskjellen fra teller-ordboka er bare startverdien og oppdateringen — tom liste i stedet for 0, append i stedet for + 1. Skjelettet er ellers identisk, og det er verdt å se de to som ett mønster med to varianter.

Løkka som finner nøkkelen med størst verdi, med beste og beste_antall oppdatert sammen inne i if-en.

Den vanligste feilen er å oppdatere bare beste. Da sammenlignes alt mot startverdien 0 for alltid, og svaret blir den siste nøkkelen med positiv verdi.

Den nest vanligste er å returnere beste_antall når oppgaven ba om beste.
Les spørsmålet en siste gang før du skriver return: ba den om hvilken eller om hvor mange?

Valget avgjøres av ett spørsmål: slår du opp på plass eller på navn?

Er rekkefølgen selve dataene — køen, ruta, målingene time for time — er lista riktig. Skal du finne noe igjen på et navn, en kode eller et årstall, er ordboka riktig, og du slipper å lete.

En huskeregel: må du skrive en løkke bare for å finne det du skal bruke, har du sannsynligvis valgt feil struktur.

Mønsteret der én nøkkel peker på flere ting: {nøkkel: [liste]}.

Det er formen grupperings-idiomet lager, og det er den samme formen den store klassemodelleringen bruker når ett objekt skal holde mange andre — et bibliotek med sine bøker, en klubb med sine medlemmer.

Kjenner du igjen strukturen her, kjenner du den igjen der. Forskjellen er bare at elementene i lista blir objekter i stedet for tall.

Samme tre steg som for lister, med {} i stedet for []:

gamle = {"a": 3, "b": 9}
ny = {}
for k in gamle:
    if gamle[k] > 5:
        ny[k] = gamle[k]
print(ny)
print(gamle)

Utskrift:

{'b': 9}
{'a': 3, 'b': 9}

Merk at den opprinnelige ordboka er urørt — det er hele poenget med å bygge en ny. Å endre ordboka du fikk inn som parameter, er sjelden det oppgaven ber om, og det gir overraskelser hos den som kalte funksjonen.

En ordbok sendes inn i en funksjon som et hvilket som helst annet argument.

Inne i funksjonen er navnet et navn på den samme ordboka som utenfor, ikke en kopi. Leser du bare fra den, spiller det ingen rolle. Skriver du d[k] = v, endrer du kallerens ordbok også.

Den trygge stilen er den du har brukt her: les fra ordboka du fikk inn, bygg
en ny, og returner den nye.

Linja som øker en teller. Den gjør tre ting i én: slår opp den gamle verdien, legger til én, og skriver resultatet tilbake på samme nøkkel.

Fordi høyresiden leses først, må nøkkelen finnes fra før. Det er hele grunnen til at if k not in d: d[k] = 0 står rett foran.

Kortformen d[k] += 1 betyr nøyaktig det samme, og begge er greie på eksamen.
Velg én av dem og hold deg til den gjennom hele besvarelsen.

En funksjon som bygger en ordbok, returnerer {} når det ikke var noe å legge inn. Det er et riktig svar, ikke en feil.

Den som mottar svaret, må bare tåle det. En løkke over en tom ordbok kjører null runder og går fint. Et oppslag gjør det ikke.

Skal funksjonen din i stedet si «fant ingenting», er None det ærlige svaret — og det er nettopp derfor finn-beste starter med beste = None.

Å endre verdiene i en løkke er trygt: for k in d: d[k] = d[k] * 2 virker som forventet.

Å legge til eller fjerne nøkler mens løkka går, er derimot ikke trygt.
Python kan stoppe med en feilmelding, fordi samlingen du løper gjennom, endrer størrelse under føttene på deg.

Regelen som holder: løp gjennom den ene samlingen, bygg den andre. Det er nøyaktig det både teller-idiomet og bygg-mønsteret gjør — de leser fra en liste og skriver til en ordbok.

Python har Counter, set(...), sum(...), max(..., key=...) og
d.get(k, 0), som gjør flere av oppgavene i dette kapitlet til én linje.

Boka bruker dem ikke. Fagets løsningsforslag skriver den eksplisitte løkka, fordi løkka er ferdigheten som måles — og på den store klassemodelleringen finnes det ingen ferdig funksjon å ty til.

Snarveiene er verdt å kjenne til, slik at du forstår kode andre har skrevet.
Men lær grunnformen først, og lever den på eksamen.