7.3 DRILL — Ledd 2: parsing og datatransformasjon

def tekst_til_liste(s):
    ut = []
    for felt in s.split():
        ut.append(float(felt))
    return ut

print(tekst_til_liste('64.32 58.91 72.07'))

Utskrift:

[64.32, 58.91, 72.07]

Snittet, som gjenbruker den:

def tekst_til_liste(s):
    return [float(felt) for felt in s.split()]

def snitt(liste):
    return sum(liste) / len(liste)

print(snitt(tekst_til_liste('64.32 58.91 72.07')))

Utskrift:

65.1

Legg merke til at svaret har mange desimaler. Det er ikke en feil: 65.10000000000001 er nøyaktig det Python regner ut, fordi flyttall lagres binært og noen desimaltall ikke går opp. Trenger du et pent tall, formaterer du i utskriften:

print('{:.2f}'.format(65.10000000000001))

Utskrift:

65.10

Slik ville sensor sett på det: de to formene av tekst_til_liste er sidestilt. Det som gir uttelling, er at funksjonen returnerer lista og at snitt kaller den i stedet for å dele strengen på nytt.

Kantfeilen å nevne: snitt krasjer med ZeroDivisionError på ei tom liste. Sier ikke oppgaven noe om det, skriver du én setning: «antar at lista har minst ett element». Skal den være robust, er formen if len(liste) == 0: return None — se kap. 7.6.

Slik ser fila ut:

Innholdet i stevne.txt:

Ida Nervik;Havorn;1:04.32
Jonas Lie;Delfin;0:58.91
Amina Kaur;Havorn;1:12.07
Petter Ruud;Storm;1:04.09

Omregningen:

def tid_til_sekunder(tekst):
    deler = tekst.split(':')
    minutter = int(deler[0])
    sekunder = float(deler[1])
    return minutter * 60 + sekunder

print(tid_til_sekunder('1:04.32'))
print(tid_til_sekunder('0:58.91'))

Utskrift:

64.32
58.91

Innlesingen som gjenbruker den:

def tid_til_sekunder(tekst):
    deler = tekst.split(':')
    return int(deler[0]) * 60 + float(deler[1])

def les_stevne(filnavn):
    f = open(filnavn, 'r')
    tabell = []
    for linje in f:
        felt = linje.strip().split(';')
        felt[2] = tid_til_sekunder(felt[2])
        tabell.append(felt)
    f.close()
    return tabell

for rad in les_stevne('stevne.txt'):
    print(rad)

Utskrift:

['Ida Nervik', 'Havorn', 64.32]
['Jonas Lie', 'Delfin', 58.91]
['Amina Kaur', 'Havorn', 72.07]
['Petter Ruud', 'Storm', 64.09]

Slik ville sensor sett på det. Deloppgaven med tid_til_sekunder er typisk 5–10 %, og de tre tingene som gir uttelling er: delingen på kolon, * 60 på minuttdelen, og at funksjonen returnerer et tall i stedet for å skrive det ut.

At les_stevne kaller tid_til_sekunder i stedet for å gjenta regnestykket, er det som gir gjenbrukspoengene i den neste deloppgaven.

Flere korrekte løsninger: minutter, sekunder = tekst.split(':') med utpakking rett i tilordningen er like riktig, og kortere. Begge gir full pott.

Kantfeilen: kommer en tid uten kolon ('58.91'), krasjer deler[1] med IndexError. Nevn det i én setning hvis fila kan være slik — her sa oppgaven at formatet er fast.

Slik ser fila ut:

Innholdet i joggeturer.txt:

2026-05-02;1842;7.1
2026-05-05;2711;10.4
2026-05-09;1503;5.8

Omregningen:

def klokkeformat(sekunder):
    timer = sekunder // 3600
    minutter = (sekunder % 3600) // 60
    rest = sekunder % 60
    return str(timer).zfill(2) + ':' + str(minutter).zfill(2) + ':' + str(rest).zfill(2)

print(klokkeformat(1842))
print(klokkeformat(2711))
print(klokkeformat(45))

Utskrift:

00:30:42
00:45:11
00:00:45

Hele loggen, med innlesingen fra kap. 7.2 gjenbrukt:

def klokkeformat(sekunder):
    timer = sekunder // 3600
    minutter = (sekunder % 3600) // 60
    return str(timer).zfill(2) + ':' + str(minutter).zfill(2) + ':' + str(sekunder % 60).zfill(2)

f = open('joggeturer.txt', 'r')
for linje in f:
    felt = linje.strip().split(';')
    print(felt[0], klokkeformat(int(felt[1])), felt[2] + ' km')
f.close()

Utskrift:

2026-05-02 00:30:42 7.1 km
2026-05-05 00:45:11 10.4 km
2026-05-09 00:25:03 5.8 km

Slik ville sensor sett på det: de tre uttrykkene med // og % er selve svaret, og zfill er detaljen som skiller full pott fra nesten. Skriver du str(timer) + ':' + ... uten padding, får du 0:30:42 — riktig regnet, men ikke det formatet oppgaven ba om.

Kontrollregningen (gjør den for hånd, det tar femten sekunder): 1842 sekunder. $1842 // 3600 = 0$. $1842 \% 3600 = 1842$, og $1842 // 60 = 30$. $1842 \% 60 = 42$. Altså 00:30:42. Stemmer med utskriften.

Kantfeilen å kjenne til: funksjonen forutsetter et heltall. Sender du inn 1842.5, gir // et flyttall, og du får 0.0:30.0:42.5. Konverter med int() først hvis varigheten kan ha desimaler.

Innholdet i vannmaaler.txt:

2026-02-01     418   kjeller
2026-03-01       503    kjeller
2026-04-01   477       kjeller

def les_maaler(filnavn):
    f = open(filnavn, 'r')
    tabell = []
    for linje in f:
        felt = linje.split()
        felt[1] = int(felt[1])
        tabell.append(felt)
    f.close()
    return tabell

for rad in les_maaler('vannmaaler.txt'):
    print(rad)

Utskrift:

['2026-02-01', 418, 'kjeller']
['2026-03-01', 503, 'kjeller']
['2026-04-01', 477, 'kjeller']

Merk at .strip() er droppet her: .split() uten argument fjerner linjeskiftet på kjøpet, fordi linjeskift også er et blanktegn. Å ha .strip() med er ikke feil — bare unødvendig.

Fila med komma og enhet:

Innholdet i kassalapp.txt:

melk;2;24,90 kr
kaffe;1;89,50 kr
egg;3;41,00 kr

def les_lapp(filnavn):
    f = open(filnavn, 'r')
    tabell = []
    for linje in f:
        felt = linje.strip().split(';')
        felt[1] = int(felt[1])
        felt[2] = float(felt[2].split()[0].replace(',', '.'))
        tabell.append(felt)
    f.close()
    return tabell

for rad in les_lapp('kassalapp.txt'):
    print(rad)

Utskrift:

['melk', 2, 24.9]
['kaffe', 1, 89.5]
['egg', 3, 41.0]

Den ene tette linja gjør tre ting i rekkefølge: .split()[0] kaster enheten, .replace(',', '.') bytter desimaltegnet, float(...) gjør resten om til tall.

Slik ville sensor sett på det: kjeden av tre kall er lovlig og gir full pott, men den er vanskelig å lese. Deler du den i tre linjer med hvert sitt navn, får du den samme uttellingen og en lettere sjekk:

raa = '24,90 kr'
uten_enhet = raa.split()[0]
med_punktum = uten_enhet.replace(',', '.')
print(float(med_punktum))

Utskrift:

24.9

Kantfeilen: rekkefølgen er ikke likegyldig. float('24,90 kr'.replace(',', '.')) krasjer fortsatt, fordi ' kr' står igjen. Enheten må bort først.

Slik ser fila ut:

Innholdet i sykkelruter.txt:

rutenr;navn;lengde;stigning
R1;Elvestien;14.2;85
R2;Toppturen;9.8;430
R3;Havnerunden;6.5;20

Innlesing og ordbokbygging, med overskriftsraden hoppet over i ordboka:

def les_ruter(filnavn):
    f = open(filnavn, 'r')
    tabell = [f.readline().strip().split(';')]
    for linje in f:
        felt = linje.strip().split(';')
        felt[2] = float(felt[2])
        felt[3] = int(felt[3])
        tabell.append(felt)
    f.close()
    return tabell

def lag_ordbok(tabell, k):
    d = {}
    for rad in tabell[1:]:
        d[rad[k]] = rad
    return d

tabell = les_ruter('sykkelruter.txt')
paa_nummer = lag_ordbok(tabell, 0)
paa_navn = lag_ordbok(tabell, tabell[0].index('navn'))
print(paa_nummer['R2'])
print(paa_navn['Havnerunden'])
print(len(paa_navn))

Utskrift:

['R2', 'Toppturen', 9.8, 430]
['R3', 'Havnerunden', 6.5, 20]
3

Slik ville sensor sett på det: at lag_ordbok tar k som parameter er det som gjør at den kan kalles to ganger. En besvarelse med lag_ordbok_paa_nummer og lag_ordbok_paa_navn — to nesten like funksjoner — gjør den samme jobben, men mister gjenbrukspoengene.

Legg merke til at det andre kallet finner kolonnen med tabell[0].index('navn') i stedet for tallet 1. Det er det samme fullscore-grepet som i kap. 7.2: koden overlever en omstokket kolonnerekkefølge.

Kantfeilen: paa_navn['Havnerunda'] — med skrivefeil — gir KeyError. Skal oppslaget tåle en ukjent nøkkel, bruker du paa_navn.get('Havnerunda', None), som gir None i stedet for å krasje.

def tid_til_sekunder(tekst):
    deler = tekst.split(':')
    return int(deler[0]) * 60 + float(deler[1])

def sekunder_til_tid(total):
    minutter = int(total // 60)
    return str(minutter) + ':' + '{:05.2f}'.format(total - minutter * 60)

print(tid_til_sekunder('1:12.07'))
print(sekunder_til_tid(72.07))

Utskrift:

72.07
1:12.07

Deloppgave b) — innlesingen som kaller a):

def les_stevne(filnavn):
    f = open(filnavn, 'r')
    tabell = []
    for linje in f:
        felt = linje.strip().split(';')
        felt[2] = tid_til_sekunder(felt[2])
        tabell.append(felt)
    f.close()
    return tabell

Deloppgave c) — utskriften som kaller a) den andre veien:

def skriv_resultatliste(tabell):
    for rad in tabell:
        print(rad[0].ljust(14) + rad[1].ljust(10) + sekunder_til_tid(rad[2]))

Utskrift: ingen — blokken definerer bare funksjonen. Den skriver først noe når den blir kalt.

Deloppgave d) — main, som leser fila én gang:

def main(filnavn):
    tabell = les_stevne(filnavn)
    skriv_resultatliste(tabell)

Kaller du main('stevne.txt') etter at de fire funksjonene over er definert, skriver programmet:

Utskrift:

Ida Nervik    Havorn    1:04.32
Jonas Lie     Delfin    0:58.91
Amina Kaur    Havorn    1:12.07
Petter Ruud   Storm     1:04.09

Slik ville sensor sett på det: tid_til_sekunder kalles fra innlesingen, sekunder_til_tid fra utskriften, og ingen av de to regnestykkene står skrevet mer enn ett sted. Det er gjenbruk i praksis, og det er verdt poeng i hver eneste deloppgave som bruker det.

Legg også merke til at tabellen inneholder tall, ikke tidsstrenger, hele veien fra innlesingen til utskriften. Konverteringen tilbake til tekst skjer først i det siste øyeblikket, når noe skal vises for et menneske. Det er en god regel i alle programmer: regn med tall, vis tekst.