8.1 Fillesing til nøstet dictionary

Åpner fila filnavn for lesing og gir deg et filobjekt — en variabel som representerer den åpne fila — under navnet infile. Alt du vil gjøre med fila, står innrykket inne i with-blokken. Når blokken er ferdig, lukkes fila automatisk, også hvis programmet krasjer underveis. Det er hele grunnen til at man bruker with: du kan ikke glemme å lukke.

Finnes ikke fila, stopper programmet med FileNotFoundError. Navnet infile er ikke magisk — det er bare et variabelnavn, men det er navnet sensor forventer å se.

with open('finnes_ikke.txt') as infile:
    for line in infile:
        print(line)

Siste linje i feilmeldingen er:

Utskrift:

FileNotFoundError: [Errno 2] No such file or directory: 'finnes_ikke.txt'

Å iterere over filobjektet betyr å gå gjennom fila én linje av gangen. Hver runde i løkka setter line til neste linje i fila — som en streng, med linjeskiftet på slutten. Det siste er den viktigste detaljen i hele kapitlet: linja Kvitheia;7.9;1180 kommer inn som 'Kvitheia;7.9;1180\n'.

Løkka leser bare én linje i minnet av gangen, så mønsteret virker like godt på en fil med fire linjer som på en med fire millioner. Du kan ikke gå tilbake: når løkka er ferdig, er fila lest til ende.

with open('stasjoner.txt') as infile:
    n = 0
    for line in infile:
        n += 1
print(n)

Utskrift:

4

Gir en ny streng der alle blanktegn — mellomrom, TAB og linjeskift — er fjernet fra begge ender. Midt i strengen røres ingenting. Originalen endres ikke; .strip() returnerer en kopi, så du må bruke returverdien.

Ved fillesing er dette rutinehandlingen på hver linje: line.strip() kvitter deg med linjeskiftet før du deler opp.

linje = '  Kvitheia \n'
print('[' + linje.strip() + ']')
print('[' + linje + ']')

Utskrift:

[Kvitheia]
[  Kvitheia 
]

Deler en streng i biter der separator står, og gir en liste av bitene. Separatoren selv kastes. 'a;b;c'.split(';') gir ['a', 'b', 'c'] — tre biter fra to semikolon.

Uten argument, altså bar .split(), deles det på vilkårlige blanktegn (én eller flere mellomrom, TAB, linjeskift), og tomme biter droppes. Det er en helt annen oppførsel, og forveksling mellom de to er en av de vanligste feilene i sjangeren: er fila semikolonseparert, gir bar .split() deg én eneste bit.

linje = 'Ingrid Hauge;5003;1998\n'
print(linje.strip().split(';'))
print(linje.split())

Utskrift:

['Ingrid Hauge', '5003', '1998']
['Ingrid', 'Hauge;5003;1998']

Gjør en tallstreng om til et tall. Alt som kommer ut av en fil er tekst, også når det ser ut som et tall, så konverteringen må gjøres eksplisitt. int('1180') gir heltallet 1180; float('8.6') gir flyttallet 8.6.

Begge tåler blanktegn rundt tallet — også et linjeskift. int('1180\n') er altså 1180, ikke en feil. Det er verdt å merke seg, for det betyr at en glemt .strip() ikke gir feilmelding når siste felt er et tall; den slår først til når siste felt er tekst. Er strengen ikke et gyldig tall, får du ValueError.

print(int('1180\n'), float(' 8.6 '))

Utskrift:

1180 8.6

En nøstet ordbok må bygges utenfra og inn. data[ytre][indre] = verdi virker bare hvis data[ytre] allerede er en ordbok. Er den ikke opprettet, får du KeyError — Python leter etter nøkkelen ytre for å sette noe inn i den, og finner den ikke.

Standardgrepet er derfor to linjer: sjekk om den ytre nøkkelen finnes, opprett en tom ordbok hvis ikke, og sett først deretter inn.

data = {}
for stasjon in ['Vest', 'Aust', 'Vest']:
    if stasjon not in data:
        data[stasjon] = {'antall': 0}
    data[stasjon]['antall'] += 1
print(data)

Utskrift:

{'Vest': {'antall': 2}, 'Aust': {'antall': 1}}

'Vest' opprettes bare første gang; andre gang finnes nøkkelen, og telleren økes i den ordboka som alt ligger der.

Har hver rad i fila sin egen ytre nøkkel, kan du hoppe over sjekken og skrive hele den indre ordboka i én tilordning: data[felt[0]] = {'temp': ..., 'nedbor': ...}. Trenger flere rader å samles under samme ytre nøkkel, må du bruke sjekken.

Bygger en ordbok av to lister: første liste blir nøkler, andre blir verdier, paret posisjon for posisjon. Det er en snarvei når feltnavnene er kjent på forhånd, eller når de kommer fra en header-linje.

zip stopper ved den korteste av de to listene — den fyller ikke ut. Er det tre feltnavn og to verdier, får du en ordbok med to par, uten noen advarsel.

print(dict(zip(['temp', 'nedbor'], [7.9, 1180])))
print(dict(zip(['temp', 'nedbor', 'vind'], [7.9, 1180])))

Utskrift:

{'temp': 7.9, 'nedbor': 1180}
{'temp': 7.9, 'nedbor': 1180}

De to linjene gir samme ordbok, og det er nettopp poenget: 'vind' forsvant lydløst.

Leser én linje fra fila og flytter leseposisjonen fram til neste. Kalt før løkka er dette standardgrepet for å hoppe over en header-linje, altså den første linja som inneholder kolonnenavn i stedet for data.

Returverdien er linja som streng, med linjeskift. Vil du bruke kolonnenavnene som feltnavn, tar du vare på den; vil du bare hoppe over den, kaller du readline() uten å bruke resultatet til noe.

with open('nedbor.txt') as infile:
    forste = infile.readline()
    n = 0
    for line in infile:
        n += 1
print(forste.strip())
print(n)

Utskrift:

stasjon;jan;feb;mar
3

Fila har fire linjer, men løkka ser bare tre: readline() har alt spist den første.

Sjekker om en nøkkel finnes i ordboka, og gir True eller False. På en ordbok ser testen på nøklene, ikke på verdiene. Den er billig: Python går rett på nøkkelen, uansett hvor stor ordboka er.

Testen har to bruksområder i dette kapitlet: å opprette den indre ordboka bare første gang (if navn not in data:), og å unngå KeyError når du er usikker på om nøkkelen finnes.

d = {'Kvitheia': 1180}
print('Kvitheia' in d, 'Fornebu' in d)
print(1180 in d)

Utskrift:

True False
False

Siste linje er poenget: 1180 er en verdi, ikke en nøkkel, så testen er False.

Gir deg nøkkel og verdi samtidig, ett par per runde i løkka, slik at du kan skrive for navn, verdier in data.items(): i stedet for for navn in data: etterfulgt av data[navn]. Rekkefølgen er innsettingsrekkefølgen.

I en nøstet ordbok er verdier selv en ordbok, så du fortsetter med verdier['temp']. To nivåer krever to løkker: en over data.items() og en over den indre.

d = {'Kvitheia': {'x': 1}, 'Nordvika': {'x': 4}}
for navn, verdier in d.items():
    print(navn, verdier['x'], end=' ')

Utskrift:

Kvitheia 1 Nordvika 4 

Merk end=' ': alt havner på én linje, og det står ett mellomrom helt til slutt — også etter det siste tallet, der utskriften bare stopper uten linjeskift.

En fil som inneholder tegn organisert i linjer, atskilt av linjeskift. Alt i en tekstfil er tekst — også det som ser ut som tall. Derfor må hvert tallfelt konverteres med int eller float etter innlesing. IN1900 leser bare rene tekstfiler; andre filformater er utenfor pensum.

Variabelen with open(...) as infile: gir deg. Den representerer den åpne fila og holder styr på hvor langt du har lest. Fordi leseposisjonen bare går framover, kan du ikke iterere over samme filobjekt to ganger — andre gang er fila tom. Trenger du to gjennomlesinger, åpner du fila på nytt.

Tegnet som skiller feltene på en linje: semikolon, komma, TAB eller mellomrom. Separatoren bestemmer argumentet til .split(). Det finnes ingen måte å gjette den — du leser den ut av fila (eller av oppgavetekstens gjengivelse av fila). En linje med tre semikolon har fire felt.

Den første linja i en fil, når den inneholder kolonnenavn i stedet for data. Den hoppes over med infile.readline() før løkka, eller brukes som kilde til feltnavnene i den indre ordboka. Glemmer du den, ender kolonnenavnet inne i en int() og gir ValueError.

En ordbok der verdiene selv er ordbøker: data[ytre][indre]. Ved fillesing er den ytre nøkkelen det som identifiserer raden (stasjon, ID, land, kandidat), og de indre nøklene er feltnavnene. Dette er datastrukturen sjanger L nesten alltid ber om, og den kan ha tre nivåer når samme rad-ID har flere målinger.

Ytre nøkkel er den du slår opp først (data['Ospedalen']) og gir deg en struktur. Indre nøkkel slår opp i den strukturen (data['Ospedalen']['nedbor']) og gir deg et element. Å forveksle de to — å tro at data['Ospedalen'] gir et tall — er den vanligste sporingsfeilen i sjangeren.

Å gjøre tekstfeltene om til tall der de skal regnes med, og la dem være tekst der de ikke skal. Regelen er å konvertere med én gang, inne i innlesingsløkka, slik at strukturen inneholder ferdige tall. felt[1] + felt[2] på tekst skjøter strengene sammen uten å klage, så en glemt konvertering gir feil svar, ikke feilmelding.

Et oppslag i en ordbok går rett på nøkkelen og koster like lite uansett hvor stor ordboka er. Et søk i en liste går gjennom radene til det treffer, og koster i verste fall like mye som listas lengde. Det er hovedgrunnen til at fillesingsoppgaver ber om en ordbok når dataene skal slås opp på navn eller ID.

En ordbok kan ikke ha samme nøkkel to ganger. Leser du to linjer med samme stasjonsnavn og setter inn med data[navn] = ..., overskriver den andre den første — ordboka får én oppføring, med den siste linjas verdier. Skal begge målingene beholdes, må neste nøkkelnivå (typisk dato) skille dem.

Feilen du får når du slår opp en nøkkel som ikke finnes: data['Fornebu'] når 'Fornebu' ikke er satt inn, eller data[ytre][indre] = verdi når den indre ordboka ikke er opprettet. Den forebygges med if nøkkel not in data:. Feiltypene er katalogisert i kap. 2.2.