Läsa filer med Python

Beskrivning

För att arbeta med lagrad data blir filhantering kärnkunskapen för varje professionell Python-programmerare. Redan från den tidigaste utgåvan är både läsning och skrivning av data till filer inbyggda Python-funktioner. I jämförelse med andra programmeringsspråk som C eller Java är det ganska enkelt och kräver bara några rader kod. Dessutom behöver ingen extra modul laddas för att göra det korrekt.

I den här artikeln kommer vi att förklara hur man läser filer med Python genom exempel. Några exempel inkluderar att läsa en fil rad för rad, som en bit (ett definierat antal rader åt gången) och att läsa en fil på en gång. Vi kommer också att visa dig ett sätt att bara läsa en specifik rad från filen, utan att söka igenom hela filen.

Grunderna för filer i Python

De vanligaste metoderna för att arbeta med filer är open() för att öppna en fil, seek() för att ställa in filens aktuella position vid den givna offseten, och close() för att stänga filobjektet när du är klar med det. Den inbyggda open() funktion returnerar ett filhandtag som representerar ett filobjekt som ska användas för att komma åt filen för att läsa, skriva eller lägga till.

När du öppnar en fil för läsning behöver Python veta exakt hur filen ska öppnas med systemet. Två åtkomstlägen är tillgängliga – läsning och läsning i binärt läge. De respektive flaggorna som används är 'r'och 'rb', och måste anges när du öppnar en fil med den inbyggda open() fungera. Det första läget inkluderar tolkningen av specialtecken som "CR" (vagnretur) och "LF" (linefeed) för att representera radbrytningar, medan det binära läget låter dig läsa data i råläge - där data lagras som de är. utan ytterligare tolkning.

När du har öppnat en fil, open() funktionen returnerar ett filobjekt till dig. Dessa filobjekt har metoder som read(), readline(), write(), tell()och seek(). Även om vissa filobjekt (eller filliknande objekt) har fler metoder än de som listas här, är dessa de vanligaste. Alla filobjekt behöver inte implementera alla filmetoder.

Läsa en fil rad för rad

Det första exemplet är inspirerat av de två programmeringsspråken – C och C++. Det är förmodligen den mest intuitiva metoden - öppna filen med hjälp av open() fungera, läs filen rad för rad med readline() metod och mata ut raden omedelbart efter läsning.

Här används en while loop som kontinuerligt läser från filen så länge som readline() metoden fortsätter att returnera data. Om filens slut (EOF) nås while loopen stannar och filobjektet stängs, vilket frigör resurserna för andra program att använda:

filename = "test.txt"

filehandle = open(filename, 'r')
while True:
    
    line = filehandle.readline()
    if not line:
        break
    print(line)


filehandle.close()

Som du kanske har noterat har vi explicit öppnat och stängt filen i det här exemplet. Även om Python-tolken stänger de öppnade filerna automatiskt i slutet av körningen av Python-programmet, stänger man explicit filen via close() är en bra programmeringsstil och bör inte glömmas bort.

Som en förbättring är bekvämt iteratorprotokoll introducerades i Python 2.3. Detta gör att du kan förenkla readline slinga:

filename = "test.txt"
for line in open(filename, 'r'):
    print(line)

Här används en for slinga i kombination med in iterator. Den aktuella linjen identifieras med hjälp av in iterator, läses från filen och dess innehåll matas ut till stdout. Python täcker öppning och stängning av filen för dig när den faller utanför räckvidden. Även om det är ineffektivt, gör detta att du inte behöver hantera filhantering längre.

Tyvärr är koden ovan mindre explicit och förlitar sig på Pythons interna sophämtning för att hantera stängning av filen.

Introducerad i Python 2.5, den with kommandot kapslar in hela processen ännu mer, och hanterar också öppnande och stängning av filer bara en gång genom hela det omfångade kodblocket:

filename = "test.txt"
with open(filename, 'r') as filehandle:
    for line in filehandle:
        print(line)

Kombinationen av with uttalande och open() kommandot öppnar filen endast en gång. Om det lyckas for loop exekveras och innehållet i raden skrivs ut stdout.

Dessutom kan användningen av with uttalande har en bieffekt. Internt skapar Python-tolken en try-finally-block för att kapsla in läsning från filen. Följande exempel visar vad som i huvudsak händer internt i Python med with kodblock:

try:
    filehandle = open(filename, 'r')
    
finally:
    filehandle.close()

Läsa en fil som bitar av rader

Hittills har vi bearbetat en fil rad för rad. Detta är ganska långsamt för stora filer och kan förbättras genom att läsa flera rader samtidigt. För att uppnå det måste islice() metod från itverktyg modulen kommer in i bilden. Det fungerar också som en iterator och returnerar en bit data som består av n rader. I slutet av filen kan resultatet bli kortare, och slutligen kommer samtalet att returnera en tom lista:

from itertools import islice

filename = "test.txt"

number_of_lines = 5

with open(filename, 'r') as input_file:
    lines_cache = islice(input_file, number_of_lines)
   
    for current_line in lines_cache:
        print (current_line)

Läsa en specifik rad från en fil

Med hjälp av metoderna som visas ovan kan vi också utföra andra användbara åtgärder, som att läsa en specifik rad från en fil. För att göra detta använder vi en räknare och skriver ut lämplig rad när vi kommer till den medan vi itererar genom filen:

filename = "test.txt"

line_number = 3
print (f"line {line_number} of {filename} is: ")

with open(filename, 'r') as filehandle:
current_line = 1
    for line in filehandle:
        if current_line == line_number:
            print(line)
            break
        current_line += 1

Detta borde vara enkelt att förstå, men det är lite längre än de tidigare exemplen. Den kan förkortas med hjälp av linecache modul.

Följande exempel visar hur man förenklar koden med hjälp av getline() metod. Om det begärda radnumret faller utanför intervallet för giltiga rader i filen, då getline() metod returnerar en tom sträng istället:

import linecache

filename = "test.txt"

line_number = 3

line = linecache.getline(filename, line_number)
print (f"line {line_number} of {filename}:")
print (line)

Läser hela filen på en gång

Sist men inte minst kommer vi att titta på ett helt annat fall än det föregående exemplet – att läsa en hel fil på en gång.

Tänk på att du i de flesta fall bör ha tillräckligt med minne för att läsa hela filen, eftersom tecken inte tar upp för mycket utrymme, utan är trötta på stora filer. Följande exempel använder en kombination av with uttalande och read() metod. I det här fallet kommer vi att använda read() för att ladda filinnehållet som en dataström:

filename = "test.txt"

with open(filename, 'r') as filehandle:
    filecontent = filehandle.read()
    print (filecontent)

Python erbjuder också readlines() metod, som liknar readline() metod från det första exemplet. I kontrast till read(), lagras filinnehållet i en lista, där varje rad i innehållet är ett objekt:

filename = "test.txt"

with open(filename, 'r') as filehandle:
    filecontent = filehandle.readlines()
    for line in filecontent:
        print (line)

Medan readlines() läser innehåll från filen tills den träffar EOF, kom ihåg att du också kan begränsa mängden innehåll som läses genom att tillhandahålla sizehint parameter, vilket är antalet byte att läsa.

Slutsats

Som vanligt finns det mer än ett sätt att läsa innehållet i en fil. Hastighetsmässigt är alla mer eller mindre i samma kategori. Vilken lösning som fungerar bäst för dig beror på ditt specifika användningsfall. Vi tycker att det är till stor hjälp att se vad som är möjligt och sedan välja den lösning som passar bäst.

Även om Python avsevärt förenklar processen att läsa filer, kan det fortfarande bli knepigt ibland, i så fall skulle jag rekommendera att du tar en titt på officiell Python-dokumentation för mer info.