3.1 Lister

En verdi som holder flere andre verdier i en bestemt rekkefølge.

Du skriver den med hakeparenteser og komma mellom elementene:

ledige = [4, 7, 12, 9, 3]
print(ledige)

Utskrift:

[4, 7, 12, 9, 3]

Tre egenskaper er verdt å merke seg med én gang. Rekkefølgen er fast — det fjerde tallet blir værende det fjerde. Lista kan endres etter at den er laget, i motsetning til en tekst. Og den kan vokse: du kan legge til nye elementer underveis.

Et enkelt element i lista kalles et element, og plassen det står på, kalles en indeks.

En liste skrevet rett inn i koden. Den kan være tom, og elementene trenger ikke være av samme type:

tomme = []
blandet = [3, "buss", True]
print(tomme, len(tomme))
print(blandet)

Utskrift:

[] 0
[3, 'buss', True]

Den tomme lista [] er ikke en kuriositet — den er startpunktet i det viktigste listemønsteret i faget: du begynner med en tom liste og fyller den underveis.

Legg merke til at teksten buss vises med enkle anførselstegn når hele lista skrives ut. Det er slik Python viser strenger inne i en liste, og det er et detaljspørsmål som avgjør poeng i et auto-rettet svarfelt.

Gir antall elementer i lista, som et heltall:

dager = ["mandag", "tirsdag", "onsdag"]
print(len(dager))
print(len(dager) - 1)
print(dager[len(dager) - 1])

Utskrift:

3
2 onsdag

Legg merke til de to første linjene. Lengden er 3, men den siste indeksen er
2. Den forskjellen på én er kilden til feilkode #5, av-med-én, og den skal du
møte igjen hver gang du skriver range(len(...)).

len virker også på tekster, akkurat som du så i forkunnskapene.

Henter ut elementet som står på plass i. Tellingen starter på null:

plasser = [12, 8, 5, 20]
print(plasser[0])
print(plasser[2])
print(plasser[0] + plasser[2])

Utskrift:

12
5
17

Det første elementet har indeks 0, det andre har indeks 1, og det siste har indeks len(liste) - 1. Å blande «det andre elementet» med «indeks 2» er den vanligste kilden til feil svar i en sporingsoppgave.

Uttrykket plasser[2] er en helt vanlig verdi. Du kan regne med den, sende den til en funksjon eller sammenligne den, akkurat som med en variabel.

Teller bakfra. -1 er det siste elementet, -2 det nest siste:

plasser = [12, 8, 5, 20]
print(plasser[-1], plasser[-2])
print(plasser[3] == plasser[-1])

Utskrift:

20 5
True

Merk at det ikke finnes noen -0; null teller forfra. Formen liste[-1] er praktisk fordi du slipper å regne ut lengden først, og den brukes flittig i fagets løsningsforslag.

Går gjennom lista element for element. Løkkevariabelen får verdien til elementet, ikke plassen:

priser = [30, 45, 20]
total = 0 for pris in priser:
    total = total + pris print(total)

Utskrift:

95

Dette er den formen du skal bruke når du bare trenger verdiene. Den er kortere, den kan ikke bomme på grensene, og den er det fagets løsningsforslag velger når de kan.

Legg merke til at den ser nøyaktig ut som løkka over en tekst i forkunnskapene.
Forskjellen er bare hva elementene er.

Går gjennom plassene i stedet for verdiene. Løkkevariabelen i er en indeks, og du henter selv ut elementet:

priser = [30, 45, 20]
for i in range(len(priser)):
    print(i, priser[i])

Utskrift:

0 30
1 45
2 20

range(len(priser)) gir tallene 0, 1 og 2 — nøyaktig de lovlige indeksene, og ikke én mer. Det er derfor formen er trygg akkurat slik den står.

Bruk den bare når du faktisk trenger plassen: når du skal skrive tilbake til
lista, når du skal sammenligne to naboelementer, eller når du skal hoppe over annethvert. Trenger du bare verdiene, er for e in liste: bedre.

Svarer True eller False på om verdien finnes i lista:

linjer = ["31", "20", "37"]
print("20" in linjer)
print("21" in linjer)
print(20 in linjer)

Utskrift:

True
False
False

Siste linje er fellen. Tallet 20 og teksten "20" er ikke samme verdi, så testen svarer False selv om det «ser riktig ut». Det er den samme type-forvekslingen som i feilkode #3.

in er praktisk i en betingelse, men den forteller deg bare om verdien finnes — ikke hvor. Trenger du plassen, må du telle deg fram selv med en løkke.

Legger til ett nytt element bakerst i lista. Lista endres på stedet — det lages ingen ny:

ledige = []
ledige.append(4)
ledige.append(9)
print(ledige, len(ledige))

Utskrift:

[4, 9] 2

Legg merke til formen: append skrives etter lista med et punktum mellom.
Det er en metode — en funksjon som hører til verdien den står bak. Du møter samme skrivemåte igjen på tekster og på dine egne klasser senere i boka.

append returnerer ingenting. Skriver du ledige = ledige.append(4), mister du hele lista og sitter igjen med None. Det er en klassisk nybegynnerfeil, og den er stum til du prøver å bruke resultatet.

Bytter ut elementet på plass i. Lista må allerede ha en verdi der:

plasser = [12, 8, 5]
plasser[1] = 99 print(plasser)

Utskrift:

[12, 99, 5]

Dette er den ene tingen du trenger indeksløkka til: skal du endre lista mens du går gjennom den, må du vite hvilken plass du er på. En løkke av formen
for e in liste: gir deg bare en kopi av verdien, og å tilordne til e endrer ingenting i lista.

Merk forskjellen fra append: tilordning bytter ut noe som finnes, mens
append gjør lista én lengre.

Skjøter to lister til en ny liste. De opprinnelige er urørt:

a = [1, 2]
b = [3]
print(a + b)
print(a)

Utskrift:

[1, 2, 3]
[1, 2]

Plusstegnet gjør altså det samme på lister som på tekster: det setter dem etter hverandre. Det legger ikke sammen elementene parvis — [1, 2] + [3, 4] gir
[1, 2, 3, 4], ikke [4, 6].

blandet = [1, "to", 3.0, True]
print(blandet)
print(blandet[1])
print(blandet[2])

Utskrift:

[1, 'to', 3.0, True]
to
3.0

Merk de tre forskjellene mellom første og andre linje. Hele lista får hakeparenteser; ett element får ikke. Teksten inne i lista får anførselstegn;
den samme teksten skrevet ut alene får ikke. Og desimaltallet 3.0 beholder punktum og null begge steder — det er en float, og det er ikke det samme som
3.

I et auto-rettet svarfelt er alle tre forskjellene forskjellen på rett og galt.

En enkeltverdi i lista. I [4, 7, 12] er 4, 7 og 12 de tre elementene.

Elementene trenger ikke ha samme type, men i praksis har de nesten alltid det — en liste med målinger inneholder tall, og en liste med stoppesteder inneholder tekster. Blandede lister forekommer, men de er vanskeligere å skrive kode for, fordi du ikke vet hva du får.

Senere i boka blir elementene objekter du selv har laget, og det er nettopp da lista blir kraftig.

Plassen et element står på, talt fra null.

Det gir tre tall som er lette å blande, og som du bør si høyt for deg selv:
lengden er antallet, den første indeksen er 0, og den siste indeksen er
len(liste) - 1.

En indeks er alltid et heltall. Skriver du liste[1.0] eller liste["1"], stopper programmet — indeksen må være av riktig type.

Den ene forskjellen som produserer flest gale svar i faget.

For lista [10, 20, 30] er lengden 3, mens den siste indeksen er 2. Derfor er liste[len(liste)] alltid en feil, mens liste[len(liste) - 1] alltid er det siste elementet — det samme som liste[-1].

Den samme forskjellen er grunnen til at range(len(liste)) treffer nøyaktig de lovlige indeksene: range stopper før stoppverdien.

Feilmeldingen Python gir når du ber om en plass som ikke finnes. Siste linje lyder IndexError: list index out of range.

Den kommer nesten alltid fra ett av tre steder: en indeks som er én for stor, en løkke som går én runde for langt, eller en liste som viste seg å være tom.

I en sporingsoppgave er «programmet stopper med en feilmelding» et fullgodt svar
— men du bør kunne peke på hvilken linje som feiler.

Lista [], med lengde 0.

Den er ikke en spesialtilfelle du kan overse. En løkke over en tom liste kjører
null runder, så alt du gjorde før løkka, står uendret når du kommer til
linja etter. Det er derfor teller- og bygg-mønstrene håndterer tomme lister av seg selv.

Det som ikke går av seg selv, er å indeksere. liste[0] på en tom liste stopper programmet, og det er hele grunnen til at tomsjekken står øverst i finn-beste-funksjoner.

Å starte med ny = [] og legge til med append i en løkke.

Mønsteret dekker tre oppgavetyper som ser forskjellige ut i teksten: filtrere
(«en ny liste med bare de som …»), omforme («en ny liste der hvert element er …») og kombinere («en ny liste med differansene mellom …»).

Kjenn igjen skjelettet, så er alle tre den samme oppgaven: tom liste før,
append inne, return etter.

Skriver du b = a når a er en liste, får du ikke en kopi. Du får et navn til på den samme lista, og en endring gjennom det ene navnet sees gjennom det andre:

a = [1, 2]
b = a b.append(3)
print(a)
print(b)

Utskrift:

[1, 2, 3]
[1, 2, 3]

Dette er feilkode #15, og det er et av de vanskeligste punktene i faget. Tall og tekster oppfører seg annerledes — der gir b = a i praksis to uavhengige verdier.

Hele mekanismen har et navn, referanser, og den får en grundig gjennomgang i del 5 om klasser og objekter. Her holder det å vite at en liste ikke kopieres av et likhetstegn.

Fellesordet for verdier som har elementer i rekkefølge, og som du kan gå gjennom med for e in ...:. Både lister og tekster er sekvenser.

Det er derfor så mye av det du lærte om tekster, virker uendret på lister:
len(...), indeksering med hakeparentes, negativ indeks og in-testen oppfører seg likt.

Den store forskjellen er at en liste kan endres, mens en tekst ikke kan. Du kan skrive liste[0] = 9, men tekst[0] = "a" stopper programmet.

En liste kan sendes inn i en funksjon som et hvilket som helst annet argument:
def antall_over(tallene, grense):.

Inne i funksjonen er tallene et navn på den samme lista som utenfor, ikke en kopi. Leser du bare fra den, spiller det ingen rolle. Kaller du derimot
tallene.append(...), endrer du kallerens liste også — og det er sjelden det du vil på eksamen.

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

def plassen_til(liste, verdi):
    for i in range(len(liste)):
        if liste[i] == verdi:
            return i return -1

print(plassen_til([9, 4, 7], 7))
print(plassen_til([9, 4, 7], 5))

Utskrift:

2
-1

Verdien -1 for «ikke funnet» kalles en sentinel-verdi — en verdi som betyr noe annet enn de vanlige. Den er trygg her, fordi en plass aldri kan være negativ. Er -1 derimot gyldige data, kolliderer de to betydningene, og da er
None det bedre valget. Det er feilkode #10.

En liste kan inneholde tall, tekster og boolske verdier om hverandre:
[3, "buss", True].

Python tillater det, men koden din må tåle det. En løkke som legger sammen elementene, stopper i det den treffer teksten — og feilmeldingen dukker opp midt i løkka, ikke der lista ble laget.

I praksis holder du typene ensartede, og lar i stedet en klasse holde sammen opplysninger av ulik art. Det er hele poenget med objektorientering, og det er dit boka er på vei.

Formen liste[1:3] gir en ny liste med elementene fra indeks 1 til og med
2 — stoppverdien er eksklusiv, som i range.

Konstruksjonen kalles et utsnitt, og den nevnes her fordi du vil se den i kode andre har skrevet. Denne boka bruker den ikke, og eksamensoppgavene krever den ikke: fasitens svar på «de tre første» er en løkke med range(0, 3) og append.

Lærer du utsnitt før du behersker løkka, får du et verktøy uten det håndverket kurset faktisk måler.

Spørsmålet er alltid det samme: trenger du plassen?

Trenger du bare verdiene — telle, summere, sjekke, bygge en ny liste — skriver du for e in liste:. Trenger du plassen — skrive tilbake til lista, sammenligne naboer, hoppe over annethvert, eller returnere hvor noe sto — skriver du
for i in range(len(liste)):.

Begge gir full uttelling når svaret er riktig. Men den første kan ikke bomme på grensene, og på en hjelpemiddelfri eksamen er det et reelt argument.

En liste husker rekkefølgen elementene ble lagt inn i, og append legger alltid til bakerst.

Det gjør lista til riktig valg når rekkefølgen er en del av dataene: køen på sykkelutleien, stoppene langs ruta, målingene time for time.

Skal du derimot slå opp på en nøkkel — «hvor mange ganger forekom dette ordet?», «hvem eier denne boka?» — er lista feil verktøy. Da trenger du en ordbok, og det er neste kapittel.