4.2 Filskriving og lagring (tekst og `pickle`)

Åpner en fil for skriving. 'w' står for write.

To ting skjer med én gang, før du har skrevet et eneste tegn:

1. Finnes ikke fila, blir den opprettet.
2. Finnes den, blir den tømt. Alt som lå der, er borte.

Det er ingen advarsel og ingen angremulighet. Skal du beholde det som lå der fra før, er 'a' modusen du vil ha (neste løkke).

Skriver en streng til fila på gjeldende posisjon. Den skriver nøyaktig det du gir den — ikke noe mer.

Særlig: write legger ikke på et linjeskift, slik print gjør. Vil du ha linjeskift, må du skrive det selv.

write tar bare strenger. Gir du den et tall, stopper programmet med TypeError — tallet må gjennom str() først.

Regelen som skiller en lesbar fil fra en ubrukelig: hver linje du skriver, må avsluttes med '\n'.

Formen boka bruker er f.write(tekst + '\n') — linjeskiftet skjøtes på i samme kall, så du ikke kan glemme det.

Uten linjeskiftet havner alt du skriver etter hverandre på én eneste lang linje. Fila er ikke ødelagt, men den er umulig å lese tilbake med for linje in f:, fordi det bare finnes én linje.

Lukker fila — og det er viktigere når du skriver enn når du leser.

Det du skriver, samles opp i en buffer i minnet og flyttes over til disken i porsjoner. close() tømmer bufferet. Glemmer du den, kan de siste linjene mangle i fila, selv om programmet ditt ikke gjorde noe galt.

Regelen er den samme som ved lesing: hver open har en close, og den står etter løkka som skriver.

Gjør et tall (eller hva som helst annet) om til den strengen print ville vist.

print(str(120) + ' glass')
print(str(12.4))
print(str(['a', 'b']))

Utskrift:

120 glass
12.4
['a', 'b']

Du trenger str hver gang et tall skal skjøtes sammen med tekst med +, og hver gang et tall skal inn i write. Det er den motsatte veien av int() og float() fra kap. 4.1.

Setter elementene i en liste sammen til én streng, med separatoren imellom. Den er det nøyaktige speilbildet av .split(';').

rad = ['Bergen', '120']
print(';'.join(rad))
print(', '.join(['ost', 'brød', 'melk']))
print(';'.join(rad).split(';'))

Utskrift:

Bergen;120
ost, brød, melk
['Bergen', '120']

Alle elementene må være strenger. Er ett av dem et tall, stopper programmet med TypeError — konverter med str() i en løkke først.

Siste linje viser rundturen: join og split opphever hverandre. Det er derfor formatet du skriver, kan leses tilbake av den samme funksjonen som leste originalfila.

Åpner fila for tilføying (append). Alt du skriver, havner bakerst; det som lå der fra før, blir stående. Finnes ikke fila, opprettes den.

f = open('logg2.txt', 'w')
f.write('første økt\n')
f.close()

f = open('logg2.txt', 'a')
f.write('andre økt\n')
f.close()

f = open('logg2.txt', 'r')
print(f.read().strip())
f.close()

Utskrift:

første økt
andre økt

Valget mellom 'w' og 'a' er et innholdsvalg, ikke et teknisk et: skal fila være en fasit som lages på nytt hver gang ('w'), eller en logg som vokser ('a')? Les oppgaveteksten, den sier det alltid.

Samme automatiske lukking som ved lesing, og her betyr den mer: bufferet tømmes selv om programmet stopper med en feil midt i skrivingen.

with open('kvittering.txt', 'w') as f:
    f.write('Sum: 253\n')

with open('kvittering.txt', 'r') as f:
    print(f.read().strip())

Utskrift:

Sum: 253

Boka bruker likevel open … close som hovedform, fordi det er den arkivets løsningsforslag bruker. with er fullt gyldig og gir full pott.

Formaterer et tall som en streng med et bestemt antall desimaler eller en bestemt bredde. Formen er den arkivets løsningsforslag bruker.

print('{:.2f}'.format(12.43333))
print('{:6.2f}|'.format(12.4))
print('{} har {} glass'.format('Bergen', 120))

Utskrift:

12.43
 12.40|
Bergen har 120 glass

.2f er to desimaler, 6.2f er to desimaler i et felt som er seks tegn bredt (høyrejustert). Tallet avrundes, det klippes ikke.

Formatering hører hjemme ved utskrift og lagring, ikke ved beregning: regn med full presisjon, og rund av først når mennesket skal lese tallet.

Den nyere skrivemåten for det samme. Prefikset f foran fnutten gjør at det som står i klammene, regnes ut og settes inn.

x = 12.43333
navn = 'Bergen'
print(f'{x:.2f}')
print(f'{navn} har {120} glass')
print(f'{navn:<12}|{x:6.2f}|')

Utskrift:

12.43
Bergen har 120 glass
Bergen      | 12.43|

Formatspråket etter kolonet er identisk med det i .format() — .2f, 6.2f, <12 betyr det samme begge steder.

f-strenger er varslet inn i pensum i det nyeste løsningsforslaget i arkivet (verifiser mot gjeldende pensum — varslet inn 2019). Den eldre .format()-formen er alltid gyldig, og begge gir full pott. Bruk den du husker best.

Fyller ut en streng med mellomrom til den er n tegn bred — rjust mot høyre (tall), ljust mot venstre (tekst).

print('Bergen'.ljust(12) + str(120).rjust(5))
print('Tromsø'.ljust(12) + str(45).rjust(5))
print('Stavanger'.ljust(12) + str(88).rjust(5))

Utskrift:

Bergen        120
Tromsø         45
Stavanger      88

Er strengen allerede bredere enn n, skjer ingenting — den blir aldri klippet.

Dette er den enkleste veien til en rapport med rette kolonner, og den virker like godt mot fil som mot skjerm: f.write(linje + '\n') i stedet for print(linje).

En tekstfil inneholder tegn som mennesker kan lese, delt i linjer. Alle filene så langt i boka har vært tekstfiler.

En binærfil inneholder rå byte som er ment for programmer, ikke for øyne. Åpner du den i en teksteditor, ser du søppel. Bildefiler, lydfiler og pickle-filer er binærfiler.

Skillet får to praktiske konsekvenser: binærfiler åpnes med 'b' i modusen ('wb', 'rb'), og innholdet i dem vises aldri i denne boka — det ville ikke betydd noe.

Poenget er at strukturen kommer tilbake identisk: en ordbok med lister inni, med tall som fortsatt er tall, forblir nøyaktig det. Ingen parsing, ingen konvertering, ingen tapte typer.

I Python heter verktøyet pickle, og de to operasjonene heter dump (lagre) og load (hente).

Henter inn standardmodulen pickle. Linja står øverst i programmet, og uten den finnes ikke navnet pickle.

pickle er en del av Python og trenger ingen installasjon. Det er en av de svært få modulene denne boka bruker i det hele tatt — resten av faget klarer seg med språket selv.

Åpner en fil i binærmodus for henholdsvis skriving og lesing. b-en er det eneste som skiller dem fra 'w' og 'r'.

Bruker du 'w' der 'wb' skal stå, stopper programmet med TypeError: write() argument must be str, not bytes — en feilmelding som er lett å kjenne igjen når du først har sett den.

Regelen er enkel: pickle krever alltid b i modusen, begge veier.

Skriver hele objektet — ordbok, liste, 2D-tabell, tuppel — til en åpen binærfil, i én operasjon.

Rekkefølgen på argumentene er objektet først, fila etterpå. Bytter du om, stopper programmet.

Du kan lagre nøstede strukturer (en ordbok av lister av tall) uten å tenke på formatet i det hele tatt. Det er hele salgsargumentet.

Leser objektet tilbake fra en åpen binærfil og returnerer det. Strukturen er identisk med den som ble lagret: samme nøkler, samme typer, samme nesting.

Ett argument, fila. Husk å ta imot returverdien — pickle.load(f) uten tilordning kaster resultatet.

Er fila skrevet av dump, virker load. Er den ikke det, stopper programmet — pickle leser bare sitt eget format.