7.2 DRILL — Ledd 1: les fil → 2D-tabell/ordbok

Slik ser fila ut:

Innholdet i ladestasjoner.txt:

navn;kommune;uttak;pris
Storsenteret;Bodo;12;4.90
Fjordbrygga;Bodo;4;5.25
Nordparken;Fauske;8;4.50
Rutebilstasjonen;Fauske;6;5.10

De seks stegene, rett ned:

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

for rad in les_stasjoner('ladestasjoner.txt'):
    print(rad)

Utskrift:

['navn', 'kommune', 'uttak', 'pris']
['Storsenteret', 'Bodo', 12, 4.9]
['Fjordbrygga', 'Bodo', 4, 5.25]
['Nordparken', 'Fauske', 8, 4.5]
['Rutebilstasjonen', 'Fauske', 6, 5.1]

Legg merke til at prisene skrives 4.9 og ikke 4.90. Det er ikke en feil — float husker tallverdien, ikke hvor mange desimaler den var skrevet med. Trenger du to desimaler i utskriften, formaterer du der: '{:.2f}'.format(4.9).

Slik ville sensor sett på det. Deloppgaven er verdt rundt 10 %, og de fem tingene som gir uttelling hver for seg er: filnavnet som parameter, overskriftsraden lest med readline() før løkka, strip() før split(';'), konverteringen av begge tallkolonnene, og return av tabellen.

Flere korrekte løsninger. with open(filnavn) as f: uten close() er like riktig. Å legge overskriftsraden i en egen returverdi (return overskrift, tabell) er også riktig, så lenge du sier fra i en kommentar — men les oppgaveteksten: her ba den eksplisitt om overskriften som rad 0.

Og en kantfeil som ikke koster mye: hadde du glemt float() på priskolonnen, ville koden fortsatt kjørt, og strukturen vært riktig. Det er en typefeil i ett felt, ikke en strukturfeil — sensor trekker for feltet, ikke for oppgaven.

Slik ser fila ut. Kolonnene står pent, men mellom dem står det ett tegn, ikke fem mellomrom:

Innholdet i kantinesalg.txt:

kaffe	34	22.00
vaffel	19	28.00
suppe	11	65.00

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

print(les_salg('kantinesalg.txt'))

Utskrift:

[['kaffe', 34, 22.0], ['vaffel', 19, 28.0], ['suppe', 11, 65.0]]

Kontrollen som avslører feil skilletegn på to sekunder: skriv ut len(felt) for den første linja. Får du 1, delte du på feil tegn — hele linja ble liggende som ett felt.

linje = 'kaffe\t34\t22.00'
print(len(linje.split(' ')))
print(len(linje.split('\t')))

Utskrift:

1
3

Slik ville sensor sett på det: her er '\t' hele forskjellen mellom full pott og null på deloppgaven. Er du i tvil på eksamen, skriver du .split() uten argument i stedet — den takler både tabulator og mellomrom, og gir riktig resultat på denne fila fordi ingen av feltene har mellomrom i seg. Skriv én setning om at du antok det.

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

t = les_med_overskrift('ladestasjoner.txt')
print(t[0])
print(len(t))

Utskrift:

['navn', 'kommune', 'uttak', 'pris']
5

Fem rader: én overskrift og fire stasjoner.

Måte 2 — to returverdier:

def les_todelt(filnavn):
    f = open(filnavn, 'r')
    overskrift = f.readline().strip().split(';')
    tabell = []
    for linje in f:
        tabell.append(linje.strip().split(';'))
    f.close()
    return overskrift, tabell

o, t = les_todelt('ladestasjoner.txt')
print(o)
print(len(t))

Utskrift:

['navn', 'kommune', 'uttak', 'pris']
4

Måte 3 — kast overskriften:

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

t = les_uten_overskrift('ladestasjoner.txt')
print(len(t))
print(t[0])

Utskrift:

4
['Storsenteret', 'Bodo', '12', '4.90']

Slik ville sensor sett på det: alle tre gir full pott på deloppgave a). Forskjellen dukker opp i deloppgave c), analysen. Med måte 1 og 2 kan du skrive overskrift.index('pris'); med måte 3 må du skrive rad[3], og da har du hardkodet kolonnerekkefølgen — som er feilkode #4 og et uttalt fullscore-krav.

Velg måte 3 bare når oppgaven eksplisitt sier at fila ikke har overskrift, eller når den oppgir kolonnerekkefølgen som gitt.

Grepet er å slå opp kolonnenumrene én gang, rett etter at overskriften er lest, og deretter bruke dem i løkka:

def les_robust(filnavn):
    f = open(filnavn, 'r')
    overskrift = f.readline().strip().split(';')
    k_nr = overskrift.index('medlemsnr')
    k_poeng = overskrift.index('poeng')
    tabell = [overskrift]
    for linje in f:
        felt = linje.strip().split(';')
        felt[k_nr] = int(felt[k_nr])
        felt[k_poeng] = int(felt[k_poeng])
        tabell.append(felt)
    f.close()
    return tabell

tabell = les_robust('medlemmer.txt')
print(tabell[1])
print(tabell[0].index('poeng'))

Utskrift:

[104, 'Sigrid Aas', 'Klatreklubben', 312]
3

Hvorfor oppslaget står utenfor løkka: .index(...) går gjennom overskriftsraden på nytt hver gang den kalles. Står den inne i løkka, gjør programmet den samme jobben én gang per linje. På fire linjer merkes det ikke, men det er en vane verdt å ha — og koden blir kortere.

Slik ville sensor sett på det: dette er selve fullscore-formen for deloppgave a). Den koster to ekstra linjer og gjør funksjonen immun mot en omstokket kolonnerekkefølge — som er nøyaktig det robusthetskravet i kap. 7.6 handler om.

Kantfeilen å kjenne til: finnes ikke kolonnenavnet, krasjer .index(...) med ValueError: 'poeng' is not in list. Er du usikker på om kolonnen finnes, kan du teste med if 'poeng' in overskrift: først.

def les_til_ordbok(filnavn):
    f = open(filnavn, 'r')
    f.readline()
    d = {}
    for linje in f:
        felt = linje.strip().split(';')
        felt[3] = int(felt[3])
        d[felt[0]] = felt[1:]
    f.close()
    return d

d = les_til_ordbok('medlemmer.txt')
print(d['118'])
print(len(d))

Utskrift:

['Mo Amin', 'Turlaget', 287]
3

Merk forskyvningen: poengsummen lå i kolonne 3 i fila, men ligger på indeks 2 i verdilista.

Ordbok 2 — teller per klubb. Nøkkelen gjentar seg, og verdien skal legges sammen:

def antall_per_klubb(filnavn):
    f = open(filnavn, 'r')
    f.readline()
    d = {}
    for linje in f:
        felt = linje.strip().split(';')
        klubb = felt[2]
        d[klubb] = d.get(klubb, 0) + 1
    f.close()
    return d

print(antall_per_klubb('medlemmer.txt'))

Utskrift:

{'Klatreklubben': 2, 'Turlaget': 1}

Ordbok 3 — gruppering. Nøkkelen gjentar seg, og alle radene skal tas vare på:

def navn_per_klubb(filnavn):
    f = open(filnavn, 'r')
    f.readline()
    d = {}
    for linje in f:
        felt = linje.strip().split(';')
        klubb = felt[2]
        if klubb not in d:
            d[klubb] = []
        d[klubb].append(felt[1])
    f.close()
    return d

print(navn_per_klubb('medlemmer.txt'))

Utskrift:

{'Klatreklubben': ['Sigrid Aas', 'Elin Berg'], 'Turlaget': ['Mo Amin']}

Slik ville sensor sett på det: de tre er ikke tre vanskelighetsgrader, men tre svar på tre forskjellige spørsmål. Velger du gruppering der oppgaven ba om et oppslag, får du riktig kode på feil oppgave — og det gir lite uttelling selv om koden virker.

Les returtypen i oppgaveteksten en ekstra gang. {klubb: antall} og {klubb: [navn]} er ulike bestillinger, og forskjellen er synlig i klammene.

Én ting til: her leser hver funksjon fila selv, fordi de er tre uavhengige eksempler. I en ekte besvarelse ville du lest fila én gang i main og gitt tabellen til alle tre — se kap. 7.1.

Slik ser fila ut:

Innholdet i stemplinger.txt:

# vaktliste uke 11 - eksportert fra timeregistreringen
Hassan;mandag;7.5

Vera;mandag;6.0
Hassan;tirsdag;8.0

# helg foert manuelt
Vera;loerdag;4.5

To tester øverst i løkka, i denne rekkefølgen — tom først, kommentar etterpå:

def les_vakter(filnavn):
    f = open(filnavn, 'r')
    tabell = []
    for linje in f:
        linje = linje.strip()
        if linje == '':
            continue
        if linje.startswith('#'):
            continue
        felt = linje.split(';')
        felt[2] = float(felt[2])
        tabell.append(felt)
    f.close()
    return tabell

for rad in les_vakter('stemplinger.txt'):
    print(rad)

Utskrift:

['Hassan', 'mandag', 7.5]
['Vera', 'mandag', 6.0]
['Hassan', 'tirsdag', 8.0]
['Vera', 'loerdag', 4.5]

Sju linjer i fila, fire rader ut. To tomme og to kommentarer er borte.

Hvorfor rekkefølgen på testene betyr noe: hadde du skrevet if linje[0] == '#' i stedet, ville den krasjet med IndexError: string index out of range på den første tomme linja — for en tom streng har ingen posisjon 0. Med .startswith('#') er det trygt uansett, men tomtesten først er en god vane.

Slik ville sensor sett på det: de to continue-testene er verdt poeng i seg selv når oppgaveteksten ber om dem. Hopper du over dem, krasjer programmet på første tomme linje — og da får du null på deloppgaven selv om resten er perfekt.

Antakelsen å skrive ned: her antas det at en kommentarlinje aldri inneholder data, og at ingen navn begynner med #. Én setning om det holder.