Oversikt

Filhåndtering forekommer på omtrent to av tre eksamenssett, med 5–17 poeng. Den ligger nesten alltid inne i oppgave 4: konstruktøren kaller en hjelpemetode som leser filen og bygger opp objektets datastruktur. IN1000 bruker den enkle oppskriften — ikke with-blokker og ikke csv-modulen.

Standardoppskriften for lesing

fil = open(filnavn)          # apner for lesing
for linje in fil:            # en linje av gangen
    linje = linje.strip()    # fjerner linjeskiftet
    if linje == "":          # hopper over tomme linjer
        continue
    deler = linje.split()    # deler pa mellomrom -> liste med ord
    navn = deler[0]
    tall = int(deler[1])     # ALT fra fil er tekst
fil.close()

Fire ting å legge merke til:

strip() er nødvendig. En «tom» linje i en tekstfil er egentlig strengen "\n", som ikke er lik "".
Uten filtreringen av tomme linjer gir deler[0] IndexError.
split() uten argument deler på ett eller flere mellomrom. split(";") deler nøyaktig på semikolon — to på rad gir da et tomt felt.
Uten int() får du TypeError når du senere skal regne. Feilen dukker ofte opp langt unna årsaken, siden deler[2] + deler[3] i seg selv er lovlig strengsammensetting.

Bygge en ordbok fra fil

Dette er den klart vanligste eksamensoppgaven. Filen poeng.txt:

ida 12
ola 7
ida 5
kim 20

def les_poeng(filnavn):
    poeng = {}
    fil = open(filnavn)
    for linje in fil:
        linje = linje.strip()
        if linje == "":
            continue
        deler = linje.split()
        navn = deler[0]
        verdi = int(deler[1])
        if navn not in poeng:
            poeng[navn] = 0
        poeng[navn] += verdi
    fil.close()
    return poeng

print(les_poeng("poeng.txt"))
# {'ida': 17, 'ola': 7, 'kim': 20}

Opptellingsmønsteret igjen: ny nøkkel får startverdi 0 før vi legger til.

Skriving til fil

ut = open(filnavn, "w")      # "w" TOMMER filen umiddelbart
ut.write("melk;30\n")        # write legger IKKE til linjeskift
ut.close()                   # uten close kan innhold mangle

ut = open(filnavn, "a")      # "a" legger til pa slutten
ut.write("kommentar;ingen\n")
ut.close()

To feller: write tar bare strenger (ut.write(30) gir TypeError: write() argument must be str, not int), og den legger ikke til linjeskift. Og "w" tømmer filen allerede når open kalles — også hvis du aldri rekker å skrive noe.

Du kan ha to filer åpne samtidig, én for lesing og én for skriving, men aldri skrive til den samme filen du leser fra.

Fil i konstruktøren

class Serie:
    def __init__(self, serienavn):
        self._serienavn = serienavn
        self._episoder = {}
        self._tags = {}
        self._les_fra_fil()

    def _les_fra_fil(self):
        fil = open(self._serienavn + ".txt")
        nummer = 1
        for linje in fil:
            linje = linje.strip()
            if linje == "":
                continue
            tagger = linje.split()
            self._episoder[nummer] = tagger
            for tag in tagger:
                if tag not in self._tags:
                    self._tags[tag] = 0
                self._tags[tag] += 1
            nummer += 1
        fil.close()

Tre detaljer eksamen belønner: hjelpemetoden har understrek og ingen parametre (filnavnet bygges av instansvariabelen), episodenummeret telles opp med en egen variabel siden for linje in fil ikke gir noen teller, og én linje oppdaterer to datastrukturer.

Poenget med å lese filen inn i en datastruktur i konstruktøren er at alle senere søk skjer i minnet. Objektet blir en representasjon av filinnholdet.

Flere linjer per post

Når hver post går over flere linjer, passer ikke for linje in fil. Da bruker du readline(), som returnerer den tomme strengen når filen er slutt:

def les_personer(filnavn):
    personer = {}
    fil = open(filnavn)
    navn = fil.readline().strip()
    while navn != "":
        aar = int(fil.readline().strip())
        by = fil.readline().strip()
        personer[navn] = [aar, by]
        navn = fil.readline().strip()
    fil.close()
    return personer

Les-før-løkke-mønsteret igjen: les navnet én gang før while, og les neste navn som siste setning inne i løkka. Rekkefølgen på readline()-kallene er algoritmen — bytter du om to av dem, får du ValueError når int("Oslo") forsøkes.

Robusthet uten try/except

IN1000 bruker ikke unntakshåndtering. Skal koden tåle ugyldige linjer, sjekker du på forhånd:

if len(deler) != 3:
    continue
if not deler[1].isdigit():
    continue

Merk at "-5".isdigit() er False — minustegnet er ikke et siffer.

Et fullstendig eksempel: kampresultater

Eksamen H2018 hadde en kjede av deloppgaver bygget rundt én fil. Filen kamper.txt:

brann molde 2 0
sarpsborg molde 1 1
brann viking 3 2

def ekstraher_lagliste(fn):
    lag = []
    fil = open(fn)
    for linje in fil:
        linje = linje.strip()
        if linje == "":
            continue
        deler = linje.split()
        lag.append(deler[0])
        lag.append(deler[1])
    fil.close()
    return lag

def forkort_lagliste(lagliste):
    ny = []
    for lag in lagliste:
        if lag not in ny:
            ny.append(lag)
    return ny

def legg_inn_null(lagliste):
    d = {}
    for lag in lagliste:
        d[lag] = 0
    return d

def regn_poengsum(fn):
    tabell = legg_inn_null(forkort_lagliste(ekstraher_lagliste(fn)))
    fil = open(fn)
    for linje in fil:
        linje = linje.strip()
        if linje == "":
            continue
        d = linje.split()
        hjemme, borte = d[0], d[1]
        mh, mb = int(d[2]), int(d[3])
        if mh > mb:
            tabell[hjemme] += 3
        elif mb > mh:
            tabell[borte] += 3
        else:
            tabell[hjemme] += 1
            tabell[borte] += 1
    fil.close()
    return tabell

print(regn_poengsum("kamper.txt"))
# {'brann': 6, 'molde': 1, 'sarpsborg': 1, 'viking': 0}

Legg merke til hvordan hver deloppgave er en liten funksjon som den neste bygger på. Det er slik hele Del 3 er konstruert — og du får bruke funksjonene selv om du ikke rakk å skrive dem.

Filen leses to ganger

I eksempelet over åpnes filen på nytt i regn_poengsum. Det er helt greit: når for linje in fil er ferdig, står lesepekeren på slutten, og en ny for-løkke over samme filobjekt gir ingenting. Skal du gå gjennom innholdet flere ganger, må du enten åpne filen på nytt eller lese alt inn i en liste først.

Skrive en rapport

def skriv_rapport(tabell, filnavn):
    ut = open(filnavn, "w")
    for lag in tabell:
        ut.write(lag + ";" + str(tabell[lag]) + "\n")
    ut.close()

Resultatet blir én linje per lag. Husk str() og "\n" — write gjør ingen av delene for deg.

Feilsøkingstabell for filkode

Symptom	Sannsynlig årsak
`FileNotFoundError`	Feil filnavn, eller filen ligger ikke i samme mappe
`IndexError` på `deler[1]`	Tom linje eller feil skilletegn i `split()`
`ValueError` i `int()`	Feltet inneholder tekst, eller `strip()` mangler
`TypeError` ved regning	`int()` mangler på et felt fra filen
Filen er tom etterpå	Åpnet med `"w"` der `"a"` var ment
Siste linjer mangler	`fil.close()` mangler

Studieguide: Filhåndtering