Introduktion
Python-programmører bruger intensivt arrays, lister og ordbøger som serialiserede datastrukturer. Vedvarende lagring af disse datastrukturer kræver enten en fil eller en database for at fungere korrekt.
I denne artikel tager vi et kig på, hvordan man skriver en liste til fil, og hvordan man læser denne liste tilbage i hukommelsen.
Til skrive data i en fil, Og til læse data fra en fil, tilbyder programmeringssproget Python standardmetoderne write()
, read()
for at håndtere en enkelt linje, samt writelines()
, readlines()
til håndtering af flere linjer. Desuden er både pickle
og json
moduler tillader også smarte måder at håndtere serialiserede datasæt på.
Brug af Læs() , skrive() Metoder
At beskæftige sig med tegn (strenge) det grundlæggende read()
, write()
metoder fungerer fremragende. Gem sådan en liste linje for linje i filen listfile.txt
kan gøres som følger:
places = ['Berlin', 'Cape Town', 'Sydney', 'Moscow']
with open('listfile.txt', 'w') as filehandle:
for listitem in places:
filehandle.write(f'{listitem}n')
listitem
forlænges med et linjeskift "n"
, først og derefter gemt i outputfilen. Nu kan vi tage et kig på, hvordan man læser hele listen fra filen listfile.txt
tilbage i hukommelsen:
places = []
with open('listfile.txt', 'r') as filehandle:
for line in filehandle:
curr_place = line[:-1]
places.append(curr_place)
Husk, at du skal fjerne linjeskiftet fra enden af strengen. I dette tilfælde hjælper det os, at Python også tillader listeoperationer på strenge. Denne fjernelse udføres simpelthen som en listeoperation på selve strengen, som beholder alt undtagen det sidste element. Dette element indeholder tegnet "n"
der repræsenterer linjeskiftet på UNIX/Linux-systemer.
Brug af skrivelinjer() , læselinjer() Metoder
Som nævnt i begyndelsen af denne artikel, indeholder Python også de to metoder – writelines()
, readlines()
– at skrive og læse flere linjer i et trin hhv. Lad os skrive hele listen til en fil på disken:
places_list = ['Berlin', 'Cape Town', 'Sydney', 'Moscow']
with open('listfile.txt', 'w') as filehandle:
filehandle.writelines(f"{place for place in places_list}n")
For at læse hele listen fra en fil på disk skal vi:
places = []
with open('listfile.txt', 'r') as filehandle:
filecontents = filehandle.readlines()
for line in filecontents:
curr_place = line[:-1]
places.append(curr_place)
Ovenstående kode følger en mere traditionel tilgang lånt fra andre programmeringssprog. Lad os skrive det i en mere Pytonisk vej:
places = []
with open('listfile.txt', 'r') as filehandle:
places = [current_place.rstrip() for current_place in filehandle.readlines()]
For det første læses filindholdet via readlines()
. For det andet i en for
løkke fra hver linje linjeskift tegnet fjernes ved hjælp af rstrip()
metode. For det tredje tilføjes strengen til listen over steder som et nyt listeelement.
I sammenligning med listen før er koden meget mere kompakt, men kan være sværere at læse for begyndere Python-programmører.
Brug af Joblib-modulet
De indledende metoder, der er forklaret indtil nu, gemmer listen på en måde, så mennesker stadig kan læse den - bogstaveligt talt en sekventiel liste i en fil. Dette er fantastisk til at oprette enkle rapporter eller udskrive eksportfiler, som brugerne kan bruge videre, såsom CSV-filer. Men hvis dit mål er at serialisere en liste til en fil, som kan indlæses senere, er der ingen grund til at gemme den i et menneskeligt læsbart format.
joblib
modul giver den nemmeste måde at dumpe et Python-objekt (kan virkelig være et hvilket som helst objekt):
import joblib
places = ['Berlin', 'Cape Town', 'Sydney', 'Moscow']
joblib.dump(places, 'places.sav')
places = joblib.load('places.sav')
print(places)
joblib
forbliver den enkleste og reneste måde at serialisere objekter på i et effektivt format og indlæse dem senere. Du kan bruge et hvilket som helst vilkårligt format, som f.eks .sav
, .data
osv. Det er lige meget – begge dele joblib
og alternativer som pickle
vil læse filerne fint.
Brug af lage Moduler
Som et alternativ til joblib
, vi kan bruge pickle
! Dens dump()
metoden gemmer listen effektivt som en binær datastrøm. For det første outputfilen listfile.data
er åbnet for binær skrivning ("wb"
). For det andet gemmes listen i den åbnede fil ved hjælp af dump()
metode:
import pickle
places = ['Berlin', 'Cape Town', 'Sydney', 'Moscow']
with open('listfile.data', 'wb') as filehandle:
pickle.dump(places, filehandle)
Som næste trin læser vi listen fra filen som følger. For det første outputfilen listfile.data
åbnes binært til læsning ("rb"
). For det andet indlæses listen over steder fra filen ved hjælp af load()
metode:
import pickle
with open('listfile.data', 'rb') as filehandle:
placesList = pickle.load(filehandle)
De to eksempler her demonstrerer brugen af strenge. Selvom, pickle
arbejder med alle slags Python-objekter såsom strenge, tal, selvdefinerede strukturer og enhver anden indbygget datastruktur, som Python leverer.
Brug af JSON-formatet
Det binære dataformat pickle
anvendelser er specifik for Python. For at forbedre interoperabiliteten mellem forskellige programmer JavaScript Object Notation (JSON) giver et let-at-bruge og læseligt skema, og blev dermed meget populært til at serialisere filer og dele dem over API'er.
Tjek vores praktiske, praktiske guide til at lære Git, med bedste praksis, brancheaccepterede standarder og inkluderet snydeark. Stop med at google Git-kommandoer og faktisk lærer det!
Følgende eksempel viser, hvordan man skriver en liste over blandede variabeltyper til en outputfil ved hjælp af json modul. Efter at have åbnet outputfilen til skrivning, dump()
metoden gemmer den grundlæggende liste i filen ved hjælp af JSON-notationen:
import json
basic_list = [1, "Cape Town", 4.6]
with open('listfile.txt', 'w') as filehandle:
json.dump(basic_list, filehandle)
At læse indholdet af outputfilen tilbage i hukommelsen er lige så simpelt som at skrive dataene. Den tilsvarende metode til dump()
er navngivet load()
:
import json
with open('listfile.txt', 'r') as filehandle:
basic_list = json.load(filehandle)
Konklusion
Forskellige metoder, vi har vist ovenfor, spænder fra simpel skrivning/læsning af data op til dumping/indlæsning af data via binære streams ved hjælp af pickle og JSON. Dette forenkler lagring af en liste vedvarende og læsning af den tilbage i hukommelsen.