Läsa och skriva listor till en fil i Python

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, .dataetc. 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.

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.