8.1 Nøstede lister og ordbøker

En liste der elementene er lister.

uker = [[14, 9, 20], [11, 0, 7]]
print(len(uker))
print(uker[0])
print(len(uker[0]))

Utskrift:

2
[14, 9, 20]
3

len på ytterlista teller de indre listene, ikke tallene. Her er svaret 2,
ikke 6.

uker[0] gir hele den første indre lista, og den skrives ut med hakeparenteser og komma — akkurat som en vanlig liste.

De indre listene trenger ikke være like lange. [[1, 2], [3], [4, 5, 6]] er en helt gyldig nøstet liste.

To hakeparenteser etter hverandre: den første velger den indre lista, den andre velger et element i den.

uker = [[14, 9, 20], [11, 0, 7]]
print(uker[0][2])
print(uker[1][0])
print(uker[-1][-1])

Utskrift:

20
11
7

Les fra venstre: uker[0] er første uke, [2] er tredje dag i den.

Rekkefølgen er hele fellen. uker[0][2] og uker[2][0] er to helt ulike
oppslag — og det siste stopper programmet her, fordi ytterlista bare har to elementer.

Negativ indeks virker på begge nivåer, som ellers.

En løkke inne i en løkke. Den ytre gir deg de indre listene, den indre gir deg tallene:

uker = [[14, 9, 20], [11, 0, 7]]
total = 0 for uke in uker:
    for tall in uke:
        total = total + tall print(total)

Utskrift:

61

Løkkevariabelen i den ytre løkka er en liste, ikke et tall. Det er den
vanligste lesefeilen: for uke in uker: gir [14, 9, 20] første runde.

Akkumulatoren står utenfor begge løkkene, og resultatet brukes etter begge.
Står total = 0 mellom de to for-linjene, nullstilles den for hver indre liste.

Antall runder til sammen er summen av lengdene til de indre listene — her 3 pluss
3, altså 6.

En ordbok der verdiene selv er ordbøker.

uke = {"mandag": {"spinning": 14, "yoga": 9}, "tirsdag": {"spinning": 20}}
print(len(uke))
print(uke["mandag"])
print(uke["mandag"]["yoga"])

Utskrift:

2
{'spinning': 14, 'yoga': 9}
9

len på ytterordboka teller ytternøklene — her 2, ikke 3.

uke["mandag"] gir hele den indre ordboka, og den skrives ut med krøllparenteser, enkle anførselstegn rundt nøklene og kolon mellom nøkkel og verdi.

De indre ordbøkene trenger ikke ha de samme nøklene. Tirsdag mangler yoga, og det er helt i orden.

To hakeparenteser etter hverandre, som med lister — men med nøkler i stedet for tall.

uke = {"mandag": {"spinning": 14, "yoga": 9}, "tirsdag": {"spinning": 20}}
print(uke["tirsdag"]["spinning"])

Utskrift:

20

Begge nivåer kan mangle. uke["onsdag"] stopper programmet med
KeyError: 'onsdag', og uke["tirsdag"]["yoga"] stopper med
KeyError: 'yoga' — selv om ytternøkkelen finnes.

Derfor må en trygg oppslagsfunksjon sjekke begge nivåene, hver for seg. Det kommer i løkke 3.

Den ytre løkka gir ytternøklene, den indre gir indrenøklene:

uke = {"mandag": {"spinning": 14, "yoga": 9}, "tirsdag": {"spinning": 20}}
for dag in uke:
    for akt in uke[dag]:
        print(dag, akt, uke[dag][akt])

Utskrift:

mandag spinning 14 mandag yoga 9 tirsdag spinning 20

Begge løkkevariablene er nøkler, ikke verdier. Verdien hentes med det doble
oppslaget uke[dag][akt].

Den indre løkka går over uke[dag] — den indre ordboka for nettopp den dagen. Skriver du for akt in uke: i den indre løkka, går du gjennom dagene to ganger.

Antall runder til sammen er summen av størrelsene på de indre ordbøkene — her
2 pluss 1, altså 3.

Med faste grenser ganges antallet:

antall = 0 for i in range(3):
    for j in range(4):
        antall = antall + 1 print(antall)

Utskrift:

12

Tre ytre runder ganger fire indre.

Med varierende grenser må du legge sammen:

antall = 0 for i in range(4):
    for j in range(i):
        antall = antall + 1 print(antall)

Utskrift:

6

Den indre løkka går 0, 1, 2 og 3 ganger — til sammen 6. range(0) gir ingen runder i det hele tatt, og det er den delen folk glemmer.

Skriv opp én linje per ytre runde når grensene varierer. Det tar ti sekunder
og fjerner hele fellen.

Tre plasseringer, tre helt ulike svar:

tall = [[1, 2], [3, 4]]

utenfor = 0 for rad in tall:
    for x in rad:
        utenfor = utenfor + x print("utenfor:", utenfor)

for rad in tall:
    mellom = 0 for x in rad:
        mellom = mellom + x print("mellom: ", mellom)

for rad in tall:
    for x in rad:
        innerst = 0 innerst = innerst + x print("innerst:", innerst)

Utskrift:

utenfor: 10 mellom:  7 innerst: 4

Utenfor begge løkkene: summen av alt.

Mellom løkkene: nullstilles for hver indre liste, så til slutt står den på
summen av den siste — her 3 pluss 4.

Innerst: nullstilles hver eneste runde, så den står på det siste
elementet.

Å se hvilken av de tre plasseringene koden har, er ofte hele sporingsoppgaven.

En liste der elementene selv er lister: [[3, 8], [1, 4, 9], [7]].

len på ytterlista teller de indre listene — her 3, ikke 6.

De indre listene trenger ikke være like lange, og det er nettopp derfor antall runder i en to nivåers løkke må legges sammen og ikke ganges.

En ordbok der verdiene selv er ordbøker:
{"mandag": {"spinning": 14, "yoga": 9}}.

Ytternøkkelen er den ene inndelingen, indrenøkkelen den andre, og verdien er tallet.

De indre ordbøkene trenger ikke ha de samme nøklene. Det er hovedgrunnen til at et dobbelt oppslag må sjekke begge nivåene.

Les fra venstre: den første hakeparentesen velger den indre strukturen, den andre velger et element i den.

Rekkefølgen er hele fellen. y[0][2] og y[2][0] er to helt ulike oppslag,
og det ene kan stoppe programmet mens det andre virker.

En løkke inne i en løkke.

For lister: for indre in y: og for x in indre: — den ytre variabelen er en
liste.

For ordbøker: for ytre in d: og for indre in d[ytre]: — begge variablene er nøkler, og verdien hentes med d[ytre][indre].

Skriver du for indre in d: i den indre løkka, går du gjennom ytternøklene to ganger.

To sjekker, ikke én:

        if ytre not in d:
            d[ytre] = {}
        if indre not in d[ytre]:
            d[ytre][indre] = 0 d[ytre][indre] = d[ytre][indre] + v

Blokken er en mal og er merket som ikke-kjørbar.

Først den indre ordboka, så den indre nøkkelen, så akkumuleringen. Hopper du over den første, stopper programmet på ytternøkkelen — feilkode #14.

Ytternøkkelen sjekkes først, alltid.

if indre not in d[ytre]: slår opp d[ytre] før not in rekker å virke. På en ytternøkkel som ikke finnes, stopper programmet der.

Samme regel gjelder i en trygg oppslagsfunksjon: if dag not in d: return 0 først, if akt not in d[dag]: return 0 etterpå.

Inne i den ytre løkka: nullstilles for hver indre liste, og gir «per
rad»-svar.

Innerst i den indre løkka: nullstilles hver runde, og står til slutt på det
siste elementet.

Å se hvilken av de tre plasseringene koden har, er ofte hele sporingsoppgaven — og å velge riktig plassering er et selvstendig poeng i sjanger
G.

Med faste grenser ganges antallet: range(3) inne i range(4) gir 12 runder.

Med varierende grenser legges de sammen: range(i) inne i range(4) gir
0 pluss 1 pluss 2 pluss 3, altså 6.

range(0) gir null runder. Det er den delen folk glemmer, og den er plantet med vilje i sporingsoppgavene.

Det totale antallet finnes i ingen av dem. Skal du telle alt, må du gå gjennom begge nivåene med en teller.

For en nøstet ordbok er det det samme: len(d) er antall ytternøkler,
len(d["a"]) er antall indrenøkler under a.

Formen for å hente en verdi når begge nivåer kan mangle:

def hent(d, ytre, indre):
    if ytre not in d:
        return 0 if indre not in d[ytre]:
        return 0 return d[ytre][indre]

Blokken er en mal og er merket som ikke-kjørbar.

Tidlig retur er riktig her, i motsetning til i en finn-beste-løkke: funksjonen
har ingenting mer å gjøre når den vet at nøkkelen mangler.

Hva den skal returnere ved «ikke funnet», sier oppgaveteksten. 0 er naturlig når svaret skal regnes med; None når det skal sammenlignes.

Å summere bort det ene nivået: fra dag → rett → antall til rett → totalt antall.

Formen er teller-idiomet med en to nivåers løkke rundt seg, og resultatet er en
vanlig ordbok.

Kjenn den igjen i oppgaveteksten på «gi en ordbok fra … til totalt antall …»
eller «samlet for alle dagene».

En helt vanlig og lovlig situasjon: [[1, 2], [3], [4, 5, 6]], eller en dag som mangler en aktivitet.

Løkkene bryr seg ikke — for x in indre: går så mange runder som den strukturen er lang.

Men antall runder må da legges sammen, ikke ganges, og et dobbelt oppslag må sjekke begge nivåene. Begge deler er plantet i eksamensoppgavene.

Samme idé, to ulike inngangsnøkler.

Lista har rekkefølge og indekseres med tall. Bruk den når posisjonen betyr
noe — «rad 0 er spiller 1».

Ordboka slås opp med navn og har ingen posisjon utover
innsettingsrekkefølgen. Bruk den når inndelingene har navn — «mandag», «spinning».

Oppgaveteksten sier som regel hvilken: «en liste av lister» eller «en ordbok fra
… til en ordbok fra … til …».

Typisk når svaret skal være «hvilken spiller», og spillerne er nummerert etter plassen i lista.

Verdien hentes da med liste[i]. Trenger du bare verdien, er for x in liste: enklere og mindre å bomme på.

Å snu de to gjør at funksjonen svarer ja så snart ett element passer — feilkode #7, for tidlig retur.

Linjen etter løkka er obligatorisk. Glemmer du den, gir funksjonen None, og
None oppfører seg som usant i en if — så feilen er stum.

Tre linjer ekstra gjør resten mye lettere å lese — og å rette. I en nøstet struktur, der du allerede har to nivåer å holde styr på, er det verdt hvert tegn.

Det gir ingen ekstra poeng i seg selv, men det reduserer sjansen for å blande indeksene betraktelig.

To funksjoner over nøstede lister eller ordbøker, 4–5 poeng hver, til sammen
8–10 poeng.

Den andre bygger ofte på den første: «bruk funksjonen fra a) til å …». Da kan du kalle den selv om du ikke fikk den helt riktig — sensor vet hva den skulle gjøre.

Sjangeren står i 4 av 6 moderne sett (67 %), og den er den siste oppgaven i settet.

Begge nivåer husker den rekkefølgen nøklene ble opprettet i.

Bygger du ordboka ovenfra og ned fra en liste, får du nøklene i den rekkefølgen dataene kom.

Det er verdt å vite når du skal spore en utskrift av hele strukturen — Python skriver den ut med krøllparenteser, enkle anførselstegn rundt tekstnøkler, kolon mellom nøkkel og verdi, og komma mellom parene.

Å slå opp eller legge til på en nøkkel som ikke er opprettet — nå på to nivåer.

d[ytre][indre] = 0 uten at d[ytre] = {} er gjort først, stopper med KeyError på ytternøkkelen. Det er den vanligste feilen i hele kapitlet.

Motgiften er mekanisk: skriv to if-sjekker hver gang du bygger en nøstet struktur, i rekkefølgen ytre, indre.

Fordi virkeligheten ofte har to inndelinger samtidig: dag og aktivitet, uke
og dag, spiller og runde.

Alternativet — én ordbok med sammensatte nøkler som "mandag-spinning" — virker, men gjør det umulig å spørre «hva skjedde på mandag?» uten å plukke tekster fra hverandre.

Den nøstede strukturen holder de to inndelingene atskilt, og det er nettopp det som gjør «summer per dag» og «summer per aktivitet» til to enkle løkker.