1.5 Dictionaries og nøstede dictionaries

En ordbok er en samling par av nøkkel og verdi. Du skriver den med krøllparenteser, kolon mellom nøkkel og verdi, og komma mellom parene.

Nøkkelen er det du slår opp på, verdien er det du får. En tom ordbok skrives {}.

temperatur = {'Blindern': 4.2, 'Tryvann': -1.5, 'Bygdoy': 5.0}
print(temperatur['Tryvann'])
print(len(temperatur))
print(temperatur)

Utskrift:

-1.5
3
{'Blindern': 4.2, 'Tryvann': -1.5, 'Bygdoy': 5.0}

Merk hvordan Python skriver ut en hel ordbok: krøllparenteser, fnutter rundt strengnøklene, kolon og mellomrom. Det er den formen du må gjengi tegn for tegn i en sporingsoppgave.

Hakeparentes med nøkkelen inni gir verdien: temperatur['Tryvann'] er -1.5.

Dette er den store forskjellen fra en liste. I en liste betyr x[1] «element nummer 1 regnet fra 0». I en ordbok betyr d[1] «verdien som hører til nøkkelen 1» — og finnes ikke den nøkkelen, stopper programmet. Posisjon spiller ingen rolle.

Finnes ikke nøkkelen, får du feilen KeyError med nøkkelen i meldingen.

Samme skrivemåte brukes til to ting, og Python avgjør selv hvilken:

- Finnes nøkkelen ikke, blir paret lagt til.
- Finnes den fra før, blir verdien overskrevet.

Det er ingen egen «legg til»-metode slik lister har append.

temperatur = {'Blindern': 4.2}
temperatur['Tryvann'] = -1.5
temperatur['Blindern'] = 4.8
print(temperatur)

Utskrift:

{'Blindern': 4.8, 'Tryvann': -1.5}

Første linje la til et nytt par, andre linje endret et som fantes. Ordboka har fortsatt to par.

Sjekker om nøkkelen finnes, og gir True eller False. Den ser bare på nøklene — aldri på verdiene.

temperatur = {'Blindern': 4.2, 'Tryvann': -1.5}
print('Tryvann' in temperatur)
print(-1.5 in temperatur)

Utskrift:

True
False

Andre linje er fellen: -1.5 er en verdi i ordboka, men ingen nøkkel, så svaret er False. Vil du lete i verdiene, må du skrive -1.5 in temperatur.values().

Denne testen er den vanlige måten å unngå KeyError på: sjekk først, slå opp etterpå.

Antall par i ordboka — altså antall nøkler, ikke antall tegn eller antall nivåer.

For en nøstet ordbok teller len bare det ytterste nivået: har du tre stasjoner med tolv måneder hver, gir len(data) tallet 3. Vil du telle månedene for én stasjon, skriver du len(data['Blindern']).

En for-løkke rett på ordboka går gjennom nøklene — ikke verdiene, ikke parene.

Vil du ha verdien også, slår du den opp inne i løkka med d[k].

nedbor = {'mandag': 4, 'tirsdag': 0, 'onsdag': 12}
for dag in nedbor:
    print(dag, nedbor[dag])

Utskrift:

mandag 4
tirsdag 0
onsdag 12

Dette er den vanligste dict-løkka i faget, og den vanligste sporingsfellen er å tro at dag er verdien. Løkkevariabelen er alltid nøkkelen.

De er ikke lister, men de kan brukes i en for-løkke og i sum, max, min og len. Trenger du en ekte liste (for å indeksere eller skrive ut), pakker du dem i list(...).

nedbor = {'mandag': 4, 'tirsdag': 0, 'onsdag': 12}
print(list(nedbor.keys()))
print(list(nedbor.values()))
print(sum(nedbor.values()))

Utskrift:

['mandag', 'tirsdag', 'onsdag']
[4, 0, 12]
16

sum(nedbor.values()) er kortformen for hele akkumulatormønsteret fra kap. 1.3, på én linje.

Gir paret (nøkkel, verdi) for hvert par i ordboka, slik at du kan pakke det ut i to løkkevariabler i én operasjon.

Et slikt par kalles en tuppel: en fast sammenstilling av to eller flere verdier, skrevet med komma og vanligvis parenteser rundt. Den ligner en liste, men kan ikke endres etterpå. Du møter tupler igjen som returverdi fra funksjoner i kap. 1.6.

Rekkefølgen er alltid nøkkel først, verdi etterpå — akkurat som enumerate alltid gir indeks først.

nedbor = {'mandag': 4, 'tirsdag': 0, 'onsdag': 12}
for dag, mm in nedbor.items():
    print(f'{dag:9s}{mm:3d} mm')

Utskrift:

mandag     4 mm
tirsdag    0 mm
onsdag    12 mm

Bredden 9 og 3 i f-strengen sørger for at kolonnene står rett — se kap. 1.4.

Fra Python 3.7 husker en ordbok innsettingsrekkefølgen: parene kommer ut i den rekkefølgen de ble satt inn, uansett hva nøklene heter.

Den er altså ikke sortert alfabetisk, og ikke tilfeldig.

d = {}
d['c'] = 3
d['a'] = 1
d['b'] = 2
print(d)
print(list(d))

Utskrift:

{'c': 3, 'a': 1, 'b': 2}
['c', 'a', 'b']

Legg merke til at list(d) gir nøklene, ikke parene — det er samme regel som for for k in d. I en sporingsoppgave må du derfor holde orden på i hvilken rekkefølge nøklene ble satt inn.

Lager en ordbok av to sekvenser: den første leverer nøklene, den andre verdiene, parret posisjon for posisjon.

zip stopper ved den korteste av de to — det fyller ikke ut. Er navnelista lengre enn tallista, forsvinner de overskytende navnene uten noen feilmelding. Det er samme regel som i kap. 1.3, og den er lett å overse her fordi resultatet ser helt normalt ut.

stasjoner = ['Blindern', 'Tryvann', 'Bygdoy']
maalinger = [4.2, -1.5]
print(dict(zip(stasjoner, maalinger)))

Utskrift:

{'Blindern': 4.2, 'Tryvann': -1.5}

Tre navn inn, to tall inn, to par ut. Bygdøy ble borte.

Slår opp som d[nøkkel], men gir standardverdien i stedet for å stoppe programmet når nøkkelen mangler.

Utelater du standardverdien, blir den None — Pythons verdi for «ingenting», som skrives ut som None. Merk at .get aldri endrer ordboka: den setter ikke inn noe.

temperatur = {'Blindern': 4.2, 'Tryvann': -1.5}
print(temperatur.get('Tryvann', 0.0))
print(temperatur.get('Fornebu', 0.0))
print(temperatur.get('Fornebu'))
print(temperatur)

Utskrift:

-1.5
0.0
None
{'Blindern': 4.2, 'Tryvann': -1.5}

Siste linje viser at ordboka er uendret — 'Fornebu' ble aldri lagt til.

En nøkkel kan bare finnes én gang. Skriver du samme nøkkel to ganger i samme krøllparentes, vinner den siste — uten advarsel.

temperatur = {'Blindern': 4.2, 'Tryvann': -1.5, 'Blindern': 4.8}
print(temperatur)
print(len(temperatur))

Utskrift:

{'Blindern': 4.8, 'Tryvann': -1.5}
2

Merk at 'Blindern' beholder sin plass fra første gang den ble satt inn, men får verdien fra siste. Det er nøyaktig samme regel som ved oppdatering.

Nøkler må være verdier som ikke kan endres: strenger, tall og sannhetsverdier går bra. Tekstnøkler er det vanlige i faget, men årstall som heltall er også naturlig.

En liste kan ikke være nøkkel — den kan endres, og Python nekter med en TypeError. Verdien derimot kan være hva som helst, også en liste eller en ny ordbok. Nettopp det siste er det nøstede ordbøker bygger på.

En ordbok der hver verdi selv er en ordbok. Oppslaget skjer i to trinn, fra venstre: data['Blindern'] gir hele den indre ordboka, og data['Blindern']['juni'] går ett skritt videre og gir tallet.

data = {}
data['Blindern'] = {}
data['Blindern']['mai'] = 12.4
data['Blindern']['juni'] = 16.1
data['Tryvann'] = {'mai': 9.8, 'juni': 13.2}
print(data['Blindern']['juni'])
print(data)

Utskrift:

16.1
{'Blindern': {'mai': 12.4, 'juni': 16.1}, 'Tryvann': {'mai': 9.8, 'juni': 13.2}}

De to stasjonene er bygget på hver sin måte — den første par for par, den andre med hele den indre ordboka ferdig skrevet. Resultatet er det samme.

En nøstet ordbok leses med en løkke inne i en løkke: den ytre gir deg de ytre nøklene, den indre går over d[ytre].

Vil du ha både indre nøkkel og verdi, bruker du .items() på det indre nivået. Og trenger du hele den indre ordboka som en enhet — for eksempel for å summere den — kan du bruke .items() på det ytre nivået i stedet:

data = {'nord': {'uke1': 3, 'uke2': 5}, 'sor': {'uke1': 8}}
total = 0
for omrade in data:
    for uke in data[omrade]:
        total += data[omrade][uke]
print(total)

Utskrift:

16

De indre ordbøkene trenger ikke ha like mange nøkler. Her har 'nord' to uker og 'sor' bare én, og løkka bryr seg ikke.

Ordbok når tingene har et navn og du henter dem etter navn: stasjon, bydel, år, artsnavn.

maaling = {2020: 5.1, 2021: 6.3}
print(maaling[2021])
liste = [5.1, 6.3]
print(liste[1])

Utskrift:

6.3
6.3

Samme svar, to helt ulike spørsmål: ordboka ble spurt om året 2021, lista om plass nummer 1. Blander du de to, får du enten feil tall eller en KeyError — og på eksamen er «hvilken av disse to er dette?» selve poenget i mange flervalgsspørsmål.

Nøklene er unike, verdiene trenger ikke være det: to stasjoner kan gjerne ha målt samme temperatur, men to nøkler kan ikke hete det samme.

En fast sammenstilling av flere verdier, skrevet med komma: ('mandag', 4). Den ligner en liste, men kan ikke endres etter at den er laget.

Du møter tupler tre steder i boka: som par fra .items() og enumerate, som flere returverdier fra en funksjon i kap. 1.6, og som tidsintervallet (0, T) i ODE-løserne i kap. 7.2.

Pythons verdi for «ingenting». Den skrives ut som None, uten fnutter.

Du møter den to steder: som standardsvar fra .get når nøkkelen mangler og du ikke har oppgitt noe annet, og som returverdi fra en funksjon som mangler return — se kap. 1.6. Begge deler er klassiske sporingsfeller, for None er ikke det samme som 0 eller tom streng.

Standardoppgaven i Del 8 leser en tekstfil der hver linje har tre felt, og bygger nøyaktig den nøstede ordboka du har sett her — typisk data[stasjon][år] = verdi.

Selve fillesingen legger bare to linjer til mønsteret: åpne fila, og del hver linje i felt. Alt det andre er det du har lært i dette kapitlet. Se kap. 8.1.