Beskrivning
Python-programmerare använder intensivt arrayer, listor och ordböcker som serialiserade datastrukturer. Att lagra dessa datastrukturer konstant kräver antingen en fil eller en databas för att fungera korrekt.
I den här artikeln tar vi en titt på hur man skriver en lista till fil, och hur man läser den listan tillbaka i minnet.
Till skriva data i en fil, Samt till läsa data från en fil, erbjuder programmeringsspråket Python standardmetoderna write()
och read()
för att hantera en enda rad, samt writelines()
och readlines()
för att hantera flera rader. Dessutom har både pickle
och json
moduler tillåter smarta sätt att hantera serialiserade datamängder också.
Använda läsa() och skriva() Metoder
För att hantera tecken (strängar) det grundläggande read()
och write()
metoder fungerar utmärkt. Spara en sådan lista rad för rad i filen listfile.txt
kan göras enligt följande:
places = ['Berlin', 'Cape Town', 'Sydney', 'Moscow']
with open('listfile.txt', 'w') as filehandle:
for listitem in places:
filehandle.write(f'{listitem}n')
Smakämnen listitem
förlängs med en radbrytning "n"
, först och sedan lagras i utdatafilen. Nu kan vi ta en titt på hur man läser hela listan från filen listfile.txt
tillbaka till minnet:
places = []
with open('listfile.txt', 'r') as filehandle:
for line in filehandle:
curr_place = line[:-1]
places.append(curr_place)
Tänk på att du måste ta bort radbrytningen från slutet av strängen. I det här fallet hjälper det oss att Python tillåter listoperationer på strängar också. Denna borttagning görs helt enkelt som en listoperation på själva strängen, som behåller allt utom det sista elementet. Detta element innehåller tecknet "n"
som representerar radbrytningen på UNIX/Linux-system.
Använda skrivlinjer() och readlines() Metoder
Som nämndes i början av denna artikel innehåller Python också de två metoderna – writelines()
och readlines()
– att skriva och läsa flera rader i ett steg. Låt oss skriva hela listan till 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")
För att läsa hela listan från en fil på disk behöver vi:
places = []
with open('listfile.txt', 'r') as filehandle:
filecontents = filehandle.readlines()
for line in filecontents:
curr_place = line[:-1]
places.append(curr_place)
Koden ovan följer ett mer traditionellt tillvägagångssätt lånat från andra programmeringsspråk. Låt oss skriva det i en mer Pythonisk sätt:
places = []
with open('listfile.txt', 'r') as filehandle:
places = [current_place.rstrip() for current_place in filehandle.readlines()]
Först läses filinnehållet via readlines()
. För det andra, i en for
loop från varje rad radbrytningstecknet tas bort med hjälp av rstrip()
metod. För det tredje läggs strängen till i listan över platser som ett nytt listobjekt.
I jämförelse med listan innan är koden mycket mer kompakt, men kan vara svårare att läsa för nybörjare Python-programmerare.
Använda Joblib-modulen
De inledande metoderna som hittills förklarats lagrar listan på ett sätt så att människor fortfarande kan läsa den – bokstavligen en sekventiell lista i en fil. Detta är bra för att skapa enkla rapporter eller mata ut exportfiler för användare att använda vidare, till exempel CSV-filer. Men om ditt mål är att bara serialisera en lista till en fil, som kan laddas senare, finns det ingen anledning att lagra den i ett läsbart format.
Smakämnen joblib
modulen ger det enklaste sättet att dumpa ett Python-objekt (kan verkligen vara vilket objekt som helst):
import joblib
places = ['Berlin', 'Cape Town', 'Sydney', 'Moscow']
joblib.dump(places, 'places.sav')
places = joblib.load('places.sav')
print(places)
joblib
är fortfarande det enklaste och renaste sättet att serialisera objekt i ett effektivt format och ladda dem senare. Du kan använda vilket godtyckligt format som helst, som t.ex .sav
, .data
etc. Det spelar egentligen ingen roll – både och joblib
och alternativ som pickle
kommer att läsa filerna bra.
Använda ättikslag Modulerna
Som ett alternativ till joblib
, vi kan använda pickle
! Dess dump()
metod lagrar listan effektivt som en binär dataström. Först utdatafilen listfile.data
öppnas för binär skrivning ("wb"
). För det andra lagras listan i den öppnade filen med hjälp av dump()
metod:
import pickle
places = ['Berlin', 'Cape Town', 'Sydney', 'Moscow']
with open('listfile.data', 'wb') as filehandle:
pickle.dump(places, filehandle)
Som nästa steg läser vi listan från filen enligt följande. Först utdatafilen listfile.data
öppnas binärt för läsning ("rb"
). För det andra laddas listan över platser från filen med hjälp av load()
metod:
import pickle
with open('listfile.data', 'rb') as filehandle:
placesList = pickle.load(filehandle)
De två exemplen här visar användningen av strängar. Fastän, pickle
fungerar med alla typer av Python-objekt som strängar, siffror, självdefinierade strukturer och alla andra inbyggda datastrukturer som Python tillhandahåller.
Använder JSON-formatet
Det binära dataformatet pickle
användningsområden är specifik för Python. För att förbättra interoperabiliteten mellan olika program JavaScript Object Notation (JSON) ger ett lättanvänt och läsbart schema och blev därför mycket populärt för att serialisera filer och dela dem över API:er.
Kolla in vår praktiska, praktiska guide för att lära dig Git, med bästa praxis, branschaccepterade standarder och medföljande fuskblad. Sluta googla Git-kommandon och faktiskt lära Det!
Följande exempel visar hur man skriver en lista med blandade variabeltyper till en utdatafil med hjälp av json modul. Efter att ha öppnat utdatafilen för skrivning, dump()
metod lagrar den grundläggande listan i filen med JSON-notationen:
import json
basic_list = [1, "Cape Town", 4.6]
with open('listfile.txt', 'w') as filehandle:
json.dump(basic_list, filehandle)
Att läsa innehållet i utdatafilen tillbaka till minnet är lika enkelt som att skriva data. Motsvarande metod för att dump()
heter load()
:
import json
with open('listfile.txt', 'r') as filehandle:
basic_list = json.load(filehandle)
Slutsats
Olika metoder som vi har visat ovan sträcker sig från att enkelt skriva/läsa data till att dumpa/ladda data via binära strömmar med pickle och JSON. Detta förenklar lagring av en lista permanent och läsning av den tillbaka i minnet.