4.1 Filinnlesing: les fil → 2D-tabell eller streng

En tekstfil er en sammenhengende tekst der linjene skilles av et usynlig linjeskifttegn, som i Python skrives '\n'. Tegnet er én bokstav på lik linje med a og ; — det ser du bare ikke.

Derfor gjelder to ting som forvirrer alle første gang:

- Hver linje du leser fra en fil ender på '\n' (den aller siste kan mangle det).
- print legger på sitt eget linjeskift i tillegg. Skriver du ut en ulest-renset linje, får du en blank linje under.

Løsningen på begge er .strip(), som du møter i løkke 2.

Åpner en tekstfil for lesing og gir deg et filobjekt — en peker som husker hvor langt du har lest.

'r' står for read. Det er standardverdien, så open('maalinger.txt') betyr det samme, men boka skriver modusen ut fordi du snart skal skrive 'w', 'a', 'wb' og 'rb' i samme posisjon.

f = open('maalinger.txt', 'r')
forste = f.readline()
print(forste)
f.close()

Utskrift:

Blindern;12.4;61

Legg merke til den blanke linja i utskriften: linja fra fila har med seg sitt eget '\n', og print legger på ett til.

Filnavnet er en helt vanlig streng, så du kan bygge det: navn + '.txt'. Finnes ikke fila, stopper programmet med en feil som heter FileNotFoundError — den håndterer vi i kap. 4.3.

Lukker fila og frigjør den. Når du leser, er trekket for en glemt close() lite; når du skriver, kan det koste selve dataene (kap. 4.2).

Regelen i denne boka: hver open har en close, og close står etter løkka — ikke inne i den. Lukker du fila inne i løkka, krasjer neste runde.

Går gjennom fila én linje av gangen, uten at du trenger en teller eller en stoppbetingelse. Løkka avslutter av seg selv når fila er slutt.

Variabelen linje er en streng med hele linja, inkludert linjeskiftet på slutten.

f = open('maalinger.txt', 'r')
for linje in f:
    print(linje.strip())
f.close()

Utskrift:

Blindern;12.4;61
Kjevik;15.1;54
Værnes;9.8;73

Dette er formen boka bruker overalt. Den er kortere og tryggere enn while-varianten med readline(), fordi du ikke kan glemme å lese neste linje.

Navnekollisjon å være klar over: f er filobjektet her. f brukes også som prefikset i en f-streng (f'{x:.2f}', se kap. 3.4). De to har ingenting med hverandre å gjøre, og du ser forskjellen på at f-strengen har en fnutt rett etter f.

Linja 'Kjevik;15.1;54' er for datamaskinen bare 14 tegn. At det er et sted, en temperatur og en luftfuktighet, er noe du vet — og parsingen er der du forteller programmet det.

I dette faget er parsingen alltid den samme lenken: linje.strip().split(separator), etterfulgt av int() eller float() på tallfeltene.

De tre du møter på eksamen er semikolon (';'), komma (',') og tabulator ('\t', ett tabulatortegn). Mellomrom er den fjerde, og den har en egen form: .split() uten argument.

Skriv aldri separatoren på slump. Se på fila først — det tar to sekunder og redder hele oppgaven.

Gir en ny streng uten blanktegn i begge ender — mellomrom, tabulator og linjeskift.

raa = 'Kjevik;15.1;54\n'
print(len(raa))
ren = raa.strip()
print(len(ren))
print(ren)

Utskrift:

15
14
Kjevik;15.1;54

Lengden går fra 15 til 14: linjeskiftet er ett tegn, og det var det eneste som forsvant. Semikolonene inni linja blir aldri rørt, fordi .strip() bare tar fra endene.

Originalen raa er uendret — strenger kan ikke endres, du får alltid en ny.

Med et argument fjerner .strip() de tegnene du oppgir, fra begge ender, i stedet for blanktegn:

print('***Blindern***'.strip('*'))
print('  Kjevik  '.strip())
print('..12.4..'.strip('.'))

Utskrift:

Blindern
Kjevik
12.4

Merk at argumentet er en mengde tegn, ikke en tekst som må stå samlet: .strip('.*') fjerner både punktum og stjerner. Varianten uten argument er den du bruker i 99 % av filoppgavene.

Deler en streng i en liste av felt, med separatoren som skille. Separatoren selv blir borte.

felt = 'Kjevik;15.1;54'.split(';')
print(felt)
print(len(felt))
print(felt[0], felt[2])

Utskrift:

['Kjevik', '15.1', '54']
3
Kjevik 54

Antall felt er alltid antall separatorer pluss én. Har en linje tre felt og du ber om felt[3], stopper programmet med IndexError.

Er separatoren fraværende i strengen, får du en liste med ett element — hele strengen. Det er det du ser når du har brukt feil skilletegn.

Uten argument deler .split() på vilkårlig mange blanktegn — ett mellomrom eller ti, og tabulator også. Tomme felt oppstår ikke.

print('Blindern   12.4      61'.split())
print('Blindern 12.4 61'.split(' '))
print('Blindern   12.4      61'.split(' '))

Utskrift:

['Blindern', '12.4', '61']
['Blindern', '12.4', '61']
['Blindern', '', '', '12.4', '', '', '', '', '', '61']

Se på den siste: med ' ' som eksplisitt separator blir hvert ekstra mellomrom til et tomt felt. Derfor er .split() uten argument den riktige når fila er kolonnejustert med varierende mellomrom.

Bokas parselenke, lest fra venstre: .strip() gir en ny streng uten linjeskiftet, og .split(sep) deler den i felt.

linje = 'Værnes;9.8;73\n'
felt = linje.strip().split(';')
print(felt)
print(felt[-1] == '73')

Utskrift:

['Værnes', '9.8', '73']
True

Rekkefølgen er fast. Gjør du det motsatt — linje.split(';') og så .strip() på hele lista — får du ikke engang lov: en liste har ingen .strip().

felt = ['Kjevik', '15.1', '54']
print(felt[2] + felt[2])
print(int(felt[2]) + int(felt[2]))
print(float(felt[1]) * 2)

Utskrift:

5454
108
30.2

Første linje er feilen i ren form: + på to strenger skjøter dem sammen. Programmet krasjer ikke — det svarer 5454.

Tommelfingerregel: konverter i samme linje som du henter feltet, mens du husker hva kolonnen betyr. Bruk float for alt som kan ha desimaler (pris, temperatur, tid) og int for antall.

Den første linja i en datafil, som navngir kolonnene i stedet for å inneholde data.

Du kjenner den igjen på at feltene er ord der resten av fila har tall. Behandlingen er alltid den samme: les den for seg, før løkka, og bruk den enten til å hoppe over eller til å slå opp kolonnenavn.

Eksamensoppgaven sier alltid om fila har en slik rad. Står det ingenting, har den det ikke.

Leser én linje og flytter posisjonen i fila ett hakk fram. Linja kommer med linjeskiftet på slutten.

Kalt før en for-løkke er dette den vanlige måten å hoppe over overskriftsraden: løkka fortsetter der readline slapp.

f = open('utlaan.txt', 'r')
overskrift = f.readline()
print(overskrift.strip())
antall = 0
for linje in f:
    antall = antall + 1
f.close()
print('Datalinjer:', antall)

Utskrift:

tittel;låner;dager
Datalinjer: 3

Er fila slutt, gir readline() den tomme strengen ''. En blank linje midt i fila gir '\n' — de to er ikke det samme.

Leser hele fila og gir deg en liste med alle linjene, hver med sitt linjeskift.

f = open('maalinger.txt', 'r')
linjer = f.readlines()
f.close()
print(linjer)
print(len(linjer))
print(linjer[0].strip())

Utskrift:

['Blindern;12.4;61\n', 'Kjevik;15.1;54\n', 'Værnes;9.8;73\n']
3
Blindern;12.4;61

Praktisk når du trenger tilfeldig tilgang til linjene (for eksempel den siste), eller vil vite antallet før du begynner. Ulempen er at hele fila havner i minnet på én gang — irrelevant for en eksamensfil på ti linjer.

Leser hele fila som én streng, med alle linjeskiftene inni.

f = open('maalinger.txt', 'r')
tekst = f.read()
f.close()
print(len(tekst))
print(tekst.count('\n'))
print(tekst.strip().split('\n'))

Utskrift:

46
3
['Blindern;12.4;61', 'Kjevik;15.1;54', 'Værnes;9.8;73']

Dette er «les fil til streng»-varianten. Den brukes når oppgaven handler om teksten som helhet — telle tegn eller ord, snu teksten, lete etter et delord.

tekst.strip().split('\n') gir deg linjene tilbake som en liste, uten linjeskift. Det er ofte den ryddigste veien.

Finner posisjonen til et kolonnenavn i overskriftsraden, slik at du slipper å anta at «dager» er kolonne 2.

overskrift = ['tittel', 'låner', 'dager']
print(overskrift.index('dager'))
print(overskrift.index('tittel'))

Utskrift:

2
0

Dette er et eksplisitt fullscore-krav på eksamen (feilkode #4 — anta fast kolonnerekkefølge). Skriver du felt[2], virker koden på akkurat den fila og ryker hvis kolonnene bytter plass. Skriver du felt[overskrift.index('dager')], virker den uansett.

Finnes ikke navnet, stopper programmet med ValueError — det er en ærlig feil, og bedre enn et stille galt svar.

Åpner fila og lukker den automatisk når blokken er ferdig — også hvis det skjer en feil underveis.

with open('maalinger.txt', 'r') as f:
    tabell = []
    for linje in f:
        tabell.append(linje.strip().split(';'))
print(len(tabell))
print(f.closed)

Utskrift:

3
True

f.closed er sann etterpå: fila er lukket uten at du skrev close().

Bokas hovedform er likevel open … close, fordi det er den formen løsningsforslagene i arkivet bruker, og fordi den gjør de to stegene synlige for sensor. with er fullt gyldig og gir full pott — bruk den formen du husker best under press, men bland dem aldri i samme funksjon.