Lese filer med Python

Introduksjon

For å jobbe med lagrede data blir filhåndtering kjernekunnskapen til enhver profesjonell Python-programmerer. Helt fra den tidligste utgivelsen er både lesing og skriving av data til filer innebygde Python-funksjoner. Sammenlignet med andre programmeringsspråk som C eller Java, er det ganske enkelt og krever bare noen få linjer med kode. Videre må ingen ekstra modul lastes inn for å gjøre det riktig.

I denne artikkelen vil vi forklare hvordan du leser filer med Python gjennom eksempler. Noen eksempler inkluderer å lese en fil linje for linje, som en del (et definert antall linjer om gangen), og å lese en fil på en gang. Vi vil også vise deg en måte å lese en bestemt linje fra filen, bare, uten å søke i hele filen.

Grunnleggende om filer i Python

De vanlige metodene for å operere med filer er open() for å åpne en fil, seek() for å angi filens gjeldende posisjon ved den gitte forskyvningen, og close() for å lukke filobjektet når du er ferdig med å bruke det. Den innebygde open() funksjonen returnerer et filhåndtak som representerer et filobjekt som skal brukes for å få tilgang til filen for lesing, skriving eller vedlegg.

Når du åpner en fil for lesing, må Python vite nøyaktig hvordan filen skal åpnes med systemet. To tilgangsmoduser er tilgjengelige – lesing og lesing i binær modus. De respektive flaggene som brukes er 'r'og 'rb', og må spesifiseres når du åpner en fil med den innebygde open() funksjon. Den første modusen inkluderer tolkning av spesialtegn som "CR" (vognretur) og "LF" (linjemating) for å representere linjeskift, mens den binære modusen lar deg lese dataene i råmodus - hvor dataene lagres som de er. uten videre tolkning.

Når du har åpnet en fil, vil open() funksjon vil returnere et filobjekt til deg. Disse filobjektene har metoder som read(), readline(), write(), tell()og seek(). Mens noen filobjekter (eller fillignende objekter) har flere metoder enn de som er oppført her, er disse de vanligste. Ikke alle filobjekter trenger å implementere alle filmetodene.

Lese en fil linje for linje

Det første eksemplet er inspirert av de to programmeringsspråkene – C og C++. Det er sannsynligvis den mest intuitive tilnærmingen - åpne filen ved å bruke open() funksjon, les filen linje for linje bruker readline() metoden, og skriv ut linjen umiddelbart etter lesing.

I bruk her er en while loop som kontinuerlig leser fra filen så lenge readline() metoden fortsetter å returnere data. I tilfelle slutten av filen (EOF) nås while loop stopper og filobjektet lukkes, og frigjør ressursene for andre programmer å bruke:

filename = "test.txt"

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


filehandle.close()

Som du kanskje har lagt merke til, har vi eksplisitt åpnet og lukket filen i dette eksemplet. Selv om Python-tolken lukker de åpnede filene automatisk på slutten av kjøringen av Python-programmet, lukker man eksplisitt filen via close() er en god programmeringsstil, og bør ikke glemmes.

Som en forbedring er praktisk iteratorprotokoll ble introdusert i Python 2.3. Dette lar deg forenkle readline Løkke:

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

I bruk her er en for løkke i kombinasjon med in iterator. Den nåværende linjen identifiseres ved hjelp av in iterator, leses fra filen, og innholdet sendes ut til stdout. Python dekker åpning og lukking av filen for deg når den faller utenfor rekkevidden. Selv om det er ineffektivt, lar dette deg slippe å håndtere filhåndtak lenger.

Dessverre er koden ovenfor mindre eksplisitt og er avhengig av Pythons interne søppelsamling for å håndtere lukking av filen.

Introdusert i Python 2.5, den with kommandoen innkapsler hele prosessen enda mer, og håndterer også åpning og lukking av filer bare én gang gjennom hele kodeblokken:

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

Kombinasjonen av with uttalelse og open() kommandoen åpner filen bare én gang. Hvis vellykket for loop utføres, og innholdet i linjen skrives ut stdout.

Videre er bruken av with uttalelse har en bivirkning. Internt lager Python-tolken en try-finally-blokk for å kapsle inn lesing fra filen. Følgende eksempel viser hva som egentlig skjer internt i Python med with kodeblokker:

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

Lese en fil som biter av linjer

Til nå har vi behandlet en fil linje for linje. Dette er ganske tregt for store filer og kan forbedres ved å lese flere linjer samtidig. For å oppnå det, må islice() metoden fra verktøy modul kommer inn i bildet. Den fungerer også som en iterator og returnerer en mengde data som består av n linjer. På slutten av filen kan resultatet bli kortere, og til slutt vil samtalen returnere en tom liste:

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)

Lese en spesifikk linje fra en fil

Ved å bruke metodene vist ovenfor kan vi også utføre andre nyttige handlinger, som å lese en spesifikk linje fra en fil. For å gjøre dette bruker vi en teller og skriver ut riktig linje når vi kommer til den mens vi gjentar 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

Dette skal være enkelt å forstå, men det er litt lengre enn de tidligere eksemplene. Den kan forkortes ved hjelp av linecache modul.

Følgende eksempel viser hvordan du forenkler koden ved å bruke getline() metode. Hvis det forespurte linjenummeret faller utenfor rekkevidden av gyldige linjer i filen, vil getline() metoden returnerer en tom streng i stedet:

import linecache

filename = "test.txt"

line_number = 3

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

Leser hele filen på en gang

Sist, men ikke minst, skal vi se på en helt annen sak enn det forrige eksemplet – å lese en hel fil på én gang.

Husk at du i de fleste tilfeller bør ha nok minne til å lese hele filen, siden tegn ikke tar for mye plass, men blir lei av store filer. Følgende eksempel bruker en kombinasjon av with uttalelse, og read() metode. I dette tilfellet bruker vi read() for å laste inn filinnholdet som en datastrøm:

filename = "test.txt"

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

Python tilbyr også readlines() metode, som ligner på readline() metode fra det første eksemplet. I motsetning til read(), er filinnholdet lagret i en liste, der hver linje i innholdet er et element:

filename = "test.txt"

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

Samtidig som readlines() vil lese innhold fra filen til den treffer EOF, husk at du også kan begrense mengden innhold som leses ved å gi sizehint parameter, som er antall byte som skal leses.

konklusjonen

Som vanlig er det mer enn én måte å lese innholdet i en fil på. Hastighetsmessig er alle mer eller mindre i samme kategori. Hvilken løsning som fungerer best for deg avhenger av din spesifikke brukssituasjon. Vi tror det er ganske nyttig å se hva som er mulig og deretter velge den løsningen som passer best.

Selv om Python i stor grad forenkler prosessen med å lese filer, kan det fortsatt bli vanskelig til tider, i så fall vil jeg anbefale deg å ta en titt på offisiell Python-dokumentasjon for mer info.