Hoe lees ik elke regel van een bestand in Python en sla ik elke regel op als een element in een lijst?
Ik wil het bestand regel voor regel lezen en elke regel aan het einde van de lijst toevoegen.
Antwoord 1, autoriteit 100%
with open(filename) as f:
content = f.readlines()
# you may also want to remove whitespace characters like `\n` at the end of each line
content = [x.strip() for x in content]
Antwoord 2, autoriteit 46%
Zie Invoer en uitvoer:
with open('filename') as f:
lines = f.readlines()
of door het teken van de nieuwe regel te strippen:
with open('filename') as f:
lines = [line.rstrip() for line in f]
Antwoord 3, autoriteit 27%
Dit is explicieter dan nodig, maar doet wat je wilt.
with open("file.txt") as file_in:
lines = []
for line in file_in:
lines.append(line)
Antwoord 4, autoriteit 12%
Dit levert een “array” van regels uit het bestand op.
lines = tuple(open(filename, 'r'))
open
retourneert een bestand dat kan worden herhaald. Wanneer u een bestand herhaalt, krijgt u de regels uit dat bestand. tuple
kan een iterator nemen en een instantie van een tuple voor je instantiëren vanuit de iterator die je eraan geeft. lines
is een tuple die is gemaakt op basis van de regels van het bestand.
Antwoord 5, autoriteit 9%
Als je wilt dat de \n
wordt meegeleverd:
with open(fname) as f:
content = f.readlines()
Als u \n
niet wilt opnemen:
with open(fname) as f:
content = f.read().splitlines()
Antwoord 6, autoriteit 9%
Volgens Python’s Methoden van bestandsobjecten, de eenvoudigste manier om een tekstbestand om te zetten in een list
is:
with open('file.txt') as f:
my_list = list(f)
# my_list = [x.rstrip() for x in f] # remove line breaks
Als u alleen de regels van het tekstbestand moet herhalen, kunt u het volgende gebruiken:
with open('file.txt') as f:
for line in f:
...
Oud antwoord:
Gebruik with
en readlines()
:
with open('file.txt') as f:
lines = f.readlines()
Als je het bestand niet wilt sluiten, werkt deze one-liner:
lines = open('file.txt').readlines()
De traditionele manier:
f = open('file.txt') # Open file on read mode
lines = f.read().splitlines() # List with stripped line-breaks
f.close() # Close file
Antwoord 7, autoriteit 7%
U kunt eenvoudig het volgende doen, zoals is gesuggereerd:
with open('/your/path/file') as f:
my_lines = f.readlines()
Merk op dat deze aanpak 2 nadelen heeft:
1) U slaat alle regels op in het geheugen. In het algemeen is dit een heel slecht idee. Het bestand kan erg groot zijn en het geheugen kan opraken. Zelfs als het niet groot is, is het gewoon een verspilling van geheugen.
2) Hierdoor kan niet elke regel worden verwerkt terwijl u ze leest. Dus als u uw regels hierna verwerkt, is dit niet efficiënt (vereist twee passen in plaats van één).
Een betere benadering voor het algemene geval zou de volgende zijn:
with open('/your/path/file') as f:
for line in f:
process(line)
Waar u uw procesfunctie definieert zoals u dat wilt. Bijvoorbeeld:
def process(line):
if 'save the world' in line.lower():
superman.save_the_world()
(De implementatie van de Superman
-klas wordt overgelaten als een oefening voor jou).
Dit werkt goed voor elke bestandsgrootte en u doorloopt uw bestand in slechts één keer. Dit is typisch hoe generieke parsers zullen werken.
Antwoord 8, autoriteit 4%
Inhoud van een tekstbestand:
line 1
line 2
line 3
We kunnen dit Python-script gebruiken in dezelfde map als de txt hierboven
>>> with open("myfile.txt", encoding="utf-8") as file:
... x = [l.rstrip("\n") for l in file]
>>> x
['line 1','line 2','line 3']
Toevoegen gebruiken:
x = []
with open("myfile.txt") as file:
for l in file:
x.append(l.strip())
Of:
>>> x = open("myfile.txt").read().splitlines()
>>> x
['line 1', 'line 2', 'line 3']
Of:
>>> x = open("myfile.txt").readlines()
>>> x
['linea 1\n', 'line 2\n', 'line 3\n']
Of:
def print_output(lines_in_textfile):
print("lines_in_textfile =", lines_in_textfile)
y = [x.rstrip() for x in open("001.txt")]
print_output(y)
with open('001.txt', 'r', encoding='utf-8') as file:
file = file.read().splitlines()
print_output(file)
with open('001.txt', 'r', encoding='utf-8') as file:
file = [x.rstrip("\n") for x in file]
print_output(file)
uitvoer:
lines_in_textfile = ['line 1', 'line 2', 'line 3']
lines_in_textfile = ['line 1', 'line 2', 'line 3']
lines_in_textfile = ['line 1', 'line 2', 'line 3']
Antwoord 9, autoriteit 2%
Om een bestand in een lijst te lezen, moet je drie dingen doen:
- Open het bestand
- Lees het bestand
- Sla de inhoud op als lijst
Gelukkig maakt Python het heel gemakkelijk om deze dingen te doen, dus de kortste manier om een bestand in een lijst te lezen is:
lst = list(open(filename))
Ik zal echter wat meer uitleg toevoegen.
Het bestand openen
Ik neem aan dat je een specifiek bestand wilt openen en dat je niet direct met een bestandshandle (of een bestandsachtige handgreep) te maken hebt. De meest gebruikte functie om een bestand in Python te openen is open
, er is één verplicht argument en twee optionele argumenten nodig in Python 2.7:
- Bestandsnaam
- Modus
- Buffering (ik negeer dit argument in dit antwoord)
De bestandsnaam moet een tekenreeks zijn die het pad naar het bestand vertegenwoordigt. Bijvoorbeeld:
open('afile') # opens the file named afile in the current working directory
open('adir/afile') # relative path (relative to the current working directory)
open('C:/users/aname/afile') # absolute path (windows)
open('/usr/local/afile') # absolute path (linux)
Houd er rekening mee dat de bestandsextensie moet worden opgegeven. Dit is vooral belangrijk voor Windows-gebruikers omdat bestandsextensies zoals .txt
of .doc
, enz. standaard verborgen zijn wanneer ze in de verkenner worden bekeken.
Het tweede argument is de mode
, het is standaard r
wat “alleen-lezen” betekent. Dat is precies wat je nodig hebt in jouw geval.
Maar als je echt een bestand wilt maken en/of naar een bestand wilt schrijven, heb je hier een ander argument nodig. Er is een uitstekend antwoord als je een overzicht wilt.
Voor het lezen van een bestand kun je de mode
weglaten of expliciet doorgeven:
open(filename)
open(filename, 'r')
Beide openen het bestand in alleen-lezen modus. Als u een binair bestand op Windows wilt inlezen, moet u de modus rb
gebruiken:
open(filename, 'rb')
Op andere platforms wordt de 'b'
(binaire modus) gewoon genegeerd.
Nu ik heb laten zien hoe je het bestand open
, laten we het hebben over het feit dat je het altijd opnieuw moet close
. Anders zal het een open bestandshandle voor het bestand behouden totdat het proces wordt afgesloten (of Python de bestandshandle weggooit).
Terwijl je zou kunnen gebruiken:
f = open(filename)
# ... do stuff with f
f.close()
Dat zal het bestand niet sluiten wanneer iets tussen open
en close
een uitzondering veroorzaakt. Je zou dat kunnen vermijden door een try
en finally
te gebruiken:
f = open(filename)
# nothing in between!
try:
# do stuff with f
finally:
f.close()
Python biedt echter contextmanagers die een mooiere syntaxis hebben (maar voor open
is het bijna identiek aan de try
en finally
hierboven):
with open(filename) as f:
# do stuff with f
# The file is always closed after the with-scope ends.
De laatste benadering is de aanbevolen benadering om een bestand in Python te openen!
Het bestand lezen
Oké, je hebt het bestand geopend, hoe moet je het nu lezen?
De functie open
retourneert een file
object en het ondersteunt Pythons iteratieprotocol. Elke iteratie geeft je een regel:
with open(filename) as f:
for line in f:
print(line)
Hierdoor wordt elke regel van het bestand afgedrukt. Houd er echter rekening mee dat elke regel aan het einde een teken voor een nieuwe regel \n
zal bevatten (je kunt misschien controleren of je Python is gebouwd met universele ondersteuning voor nieuwe regels – anders zou u ook \r\n
op Windows of \r
op Mac als nieuwe regels). Als u dat niet wilt, kunt u eenvoudig het laatste teken verwijderen (of de laatste twee tekens in Windows):
with open(filename) as f:
for line in f:
print(line[:-1])
Maar de laatste regel heeft niet per se een afsluitende nieuwe regel, dus die moet je niet gebruiken. Je zou kunnen controleren of het eindigt met een afsluitende nieuwe regel en zo ja, deze verwijderen:
with open(filename) as f:
for line in f:
if line.endswith('\n'):
line = line[:-1]
print(line)
Maar u kunt eenvoudig alle witruimten (inclusief het \n
-teken) van het einde van de tekenreeks verwijderen, dit verwijdert ook alle andere achterliggende em> spaties dus je moet voorzichtig zijn als deze belangrijk zijn:
with open(filename) as f:
for line in f:
print(f.rstrip())
Als de regels echter eindigen op \r\n
(Windows “newlines”), zal .rstrip()
ook zorgen voor de \r
!
Sla de inhoud op als lijst
Nu je weet hoe je het bestand moet openen en lezen, is het tijd om de inhoud in een lijst op te slaan. De eenvoudigste optie zou zijn om de list
functie:
with open(filename) as f:
lst = list(f)
In het geval dat u de laatste nieuwe regels wilt verwijderen, kunt u in plaats daarvan een lijstbegrip gebruiken:
with open(filename) as f:
lst = [line.rstrip() for line in f]
Of nog eenvoudiger: de .readlines()
methode van het file
object retourneert standaard een list
van de regels:
with open(filename) as f:
lst = f.readlines()
Dit omvat ook de laatste tekens van de nieuwe regel, als u ze niet wilt, zou ik de [line.rstrip() for line in f]
-benadering aanbevelen, omdat hiermee wordt voorkomen dat er twee lijsten met alle de regels in het geheugen.
Er is een extra optie om de gewenste uitvoer te krijgen, maar deze is nogal “suboptimaal”: read
het volledige bestand in een string en splits het op nieuwe regels:
with open(filename) as f:
lst = f.read().split('\n')
of:
with open(filename) as f:
lst = f.read().splitlines()
Deze zorgen automatisch voor de volgende nieuwe regels omdat het teken split
niet is opgenomen. Ze zijn echter niet ideaal omdat je het bestand als string en als een lijst met regels in het geheugen bewaart!
Samenvatting
- Gebruik
with open(...) as f
bij het openen van bestanden, want u hoeft het bestand niet zelf te sluiten en het sluit het bestand zelfs als er een uitzondering optreedt. file
-objecten ondersteunen het iteratieprotocol, dus het regel voor regel lezen van een bestand is net zo eenvoudig alsfor line in the_file_object:
.- Blader altijd door de documentatie voor de beschikbare functies/klassen. Meestal is er een perfecte match voor de taak of minstens een of twee goede. De voor de hand liggende keuze zou in dit geval
readlines()
zijn, maar als je de regels wilt verwerken voordat je ze in de lijst opslaat, zou ik een eenvoudige lijst-begrip aanraden.
li>
Antwoord 10, autoriteit 2%
Schone en Pythonische manier om de regels van een bestand in een lijst te lezen
Eerst en vooral moet u zich concentreren op het openen van uw bestand en het lezen van de inhoud op een efficiënte en pythonische manier. Hier is een voorbeeld van de manier waarop ik persoonlijk NIET de voorkeur geef:
infile = open('my_file.txt', 'r') # Open the file for reading.
data = infile.read() # Read the contents of the file.
infile.close() # Close the file since we're done using it.
In plaats daarvan geef ik de voorkeur aan de onderstaande methode om bestanden te openen voor zowel lezen als schrijven als het
is erg schoon en vereist geen extra stap om het bestand te sluiten
zodra u klaar bent met het gebruik ervan. In de onderstaande verklaring openen we het bestand
om te lezen en toe te wijzen aan de variabele ‘infile.’ Zodra de code binnen
deze verklaring is voltooid, wordt het bestand automatisch gesloten.
# Open the file for reading.
with open('my_file.txt', 'r') as infile:
data = infile.read() # Read the contents of the file into memory.
Nu moeten we ons concentreren op het opnemen van deze gegevens in een Python-lijst omdat ze itereerbaar, efficiënt en flexibel zijn. In jouw geval is het gewenste doel om elke regel van het tekstbestand in een apart element te plaatsen. Om dit te bereiken, gebruiken we de splitlines() methode als volgt:
# Return a list of the lines, breaking at line boundaries.
my_list = data.splitlines()
Het eindproduct:
# Open the file for reading.
with open('my_file.txt', 'r') as infile:
data = infile.read() # Read the contents of the file into memory.
# Return a list of the lines, breaking at line boundaries.
my_list = data.splitlines()
Onze code testen:
- Inhoud van het tekstbestand:
A fost odata ca-n povesti,
A fost ca niciodata,
Din rude mari imparatesti,
O prea frumoasa fata.
- Afdrukken afdrukken voor testdoeleinden:
print my_list # Print the list.
# Print each line in the list.
for line in my_list:
print line
# Print the fourth element in this list.
print my_list[3]
- Uitvoer (ziet er anders uit vanwege unicode-tekens):
['A fost odat\xc3\xa3 ca-n povesti,', 'A fost ca niciodat\xc3\xa3,',
'Din rude m\xc3\xa3ri \xc3\xaemp\xc3\xa3r\xc3\xa3testi,', 'O prea
frumoas\xc3\xa3 fat\xc3\xa3.']
A fost odata ca-n povesti, A fost ca niciodata, Din rude mari
imparatesti, O prea frumoasa fata.
O prea frumoasa fata.
Antwoord 11, autoriteit 2%
Geïntroduceerd in Python 3.4, pathlib
heeft een erg handige methode om tekst uit bestanden in te lezen, als volgt:
from pathlib import Path
p = Path('my_text_file')
lines = p.read_text().splitlines()
(De splitlines
aanroep is wat het verandert van een string die de volledige inhoud van het bestand bevat naar een lijst met regels in het bestand).
pathlib
heeft veel handige gemakken. read_text
is leuk en beknopt, en u hoeft zich geen zorgen te maken over het openen en sluiten van het bestand. Als u het bestand alleen maar in één keer hoeft te lezen, is dit een goede keuze.
Antwoord 12
Hier is nog een optie door lijstbegrippen voor bestanden te gebruiken;
lines = [line.rstrip() for line in open('file.txt')]
Dit zou een efficiëntere manier moeten zijn, aangezien het meeste werk binnen de Python-interpreter wordt gedaan.
Antwoord 13
f = open("your_file.txt",'r')
out = f.readlines() # will append in the list out
Variabele uit is nu een lijst (array) van wat je wilt. Je zou het volgende kunnen doen:
for line in out:
print (line)
Of:
for line in f:
print (line)
Je krijgt dezelfde resultaten.
Antwoord 14
Lees en schrijf tekstbestanden met Python 2 en Python 3; het werkt met Unicode
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Define data
lines = [' A first string ',
'A Unicode sample: €',
'German: aou?']
# Write text file
with open('file.txt', 'w') as fp:
fp.write('\n'.join(lines))
# Read text file
with open('file.txt', 'r') as fp:
read_lines = fp.readlines()
read_lines = [line.rstrip('\n') for line in read_lines]
print(lines == read_lines)
Opmerkingen:
with
is een zogenaamde contextmanager. Het zorgt ervoor dat het geopende bestand weer wordt gesloten.- Alle oplossingen hier die eenvoudig
.strip()
of.rstrip()
maken, zullen delines
niet reproduceren omdat ze ook de witruimte.
Veelgebruikte bestandsuitgangen
.txt
Geavanceerder schrijven/lezen van bestanden
- CSV: supereenvoudige indeling (lezen en schrijven)
- JSON: leuk voor het schrijven van door mensen leesbare gegevens; ZEER vaak gebruikt (lezen en schrijven)
- YAML: YAML is een superset van JSON, maar gemakkelijker te lezen (lezen en schrijven, vergelijking van JSON en YAML)
- augurk: een Python-serialisatie-indeling (lezen en schrijven)
- MessagePack (Python-pakket): compactere weergave (lezen en schrijven)
- HDF5 (Python-pakket): leuk voor matrices (lezen en schrijven)
- XML: bestaat ook *zucht* (lees & schrijf)
Voor uw aanvraag kan het volgende van belang zijn:
- Ondersteuning door andere programmeertalen
- Lees-/schrijfprestaties
- Compactheid (bestandsgrootte)
Zie ook: Vergelijking van gegevensserialisatie-indelingen
Als je liever op zoek bent naar een manier om configuratiebestanden te maken, lees dan misschien mijn korte artikel Configuratiebestanden in Python.
Antwoord 15
Als u een bestand vanaf de opdrachtregel of vanaf stdin wilt lezen, kunt u ook de module fileinput
gebruiken:
# reader.py
import fileinput
content = []
for line in fileinput.input():
content.append(line.strip())
fileinput.close()
Geef er bestanden aan door als volgt:
$ python reader.py textfile.txt
Lees hier meer: http://docs.python.org/2/library/fileinput.html
Antwoord 16
Een andere optie is numpy.genfromtxt
, bijvoorbeeld:
import numpy as np
data = np.genfromtxt("yourfile.dat",delimiter="\n")
Hierdoor wordt data
een NumPy-array met net zoveel rijen als in uw bestand.
Antwoord 17
De eenvoudigste manier om het te doen
Een eenvoudige manier is om:
- Lees het hele bestand als een string
- Spreek de tekenreeks regel voor regel op
In één regel zou dat het volgende opleveren:
lines = open('C:/path/file.txt').read().splitlines()
Dit is echter een vrij inefficiënte manier, omdat hierdoor 2 versies van de inhoud in het geheugen worden opgeslagen (waarschijnlijk geen groot probleem voor kleine bestanden, maar toch). [Bedankt Mark Amery].
Er zijn 2 gemakkelijkere manieren:
- Het bestand gebruiken als een iterator
lines = list(open('C:/path/file.txt'))
# ... or if you want to have a list without EOL characters
lines = [l.rstrip() for l in open('C:/path/file.txt')]
- Als je Python 3.4 of hoger gebruikt, kun je beter
pathlib
gebruiken om een pad voor je bestand te maken dat je zou kunnen gebruiken voor andere bewerkingen in je programma:
from pathlib import Path
file_path = Path("C:/path/file.txt")
lines = file_path.read_text().split_lines()
# ... or ...
lines = [l.rstrip() for l in file_path.open()]
Antwoord 18
Gebruik gewoon de splitlines() functies. Hier is een voorbeeld.
inp = "file.txt"
data = open(inp)
dat = data.read()
lst = dat.splitlines()
print lst
# print(lst) # for python 3
In de uitvoer heb je de lijst met regels.
Antwoord 19
Als je te maken wilt krijgen met een zeer groot / enorm bestand en je wilt sneller lezen (stel je voor dat je in een Topcoder/Hackerrank-coderingswedstrijd zit), lees een aanzienlijk groter stuk regels in één keer in een geheugenbuffer, in plaats van regel voor regel op bestandsniveau te herhalen.
buffersize = 2**16
with open(path) as f:
while True:
lines_buffer = f.readlines(buffersize)
if not lines_buffer:
break
for line in lines_buffer:
process(line)
Antwoord 20
De gemakkelijkste manieren om dat te doen met enkele extra voordelen zijn:
lines = list(open('filename'))
of
lines = tuple(open('filename'))
of
lines = set(open('filename'))
In het geval van set
moeten we er rekening mee houden dat we de regelvolgorde niet behouden en de dubbele regels verwijderen.
Hieronder heb ik een belangrijke aanvulling van @MarkAmery toegevoegd:
Aangezien u
.close
niet aanroept voor het bestandsobject en ook geenwith
-instructie gebruikt, is in sommige Python-implementaties de bestand wordt mogelijk niet gesloten na het lezen en uw proces lekt een open bestandshandvat.In CPython (de normale Python-implementatie die de meeste mensen gebruiken), is dit geen probleem, aangezien het bestandsobject onmiddellijk door de prullenbak wordt verzameld en hierdoor wordt het bestand gesloten, maar het wordt niettemin algemeen als de beste methode beschouwd om iets te doen als:
with open('filename') as f: lines = list(f)
om ervoor te zorgen dat het bestand wordt gesloten, ongeacht welke Python-implementatie u gebruikt.
Antwoord 21
Gebruik dit:
import pandas as pd
data = pd.read_csv(filename) # You can also add parameters such as header, sep, etc.
array = data.values
data
is een dataframetype en gebruikt waarden om ndarray te krijgen. Je kunt ook een lijst krijgen door array.tolist()
te gebruiken.
Antwoord 22
Overzicht en samenvatting
Met een filename
, het verwerken van het bestand vanaf een Path(filename)
-object, of rechtstreeks met open(filename) as f
, doe een van de volgende:
list(fileinput.input(filename))
- gebruik
with path.open() as f
, belf.readlines()
list(f)
path.read_text().splitlines()
path.read_text().splitlines(keepends=True)
- herhaal over
fileinput.input
off
enlist.append
elke regel één voor één - geef
f
door aan een gebondenlist.extend
methode - gebruik
f
in een lijstbegrip
Ik leg de use-case voor elk hieronder uit.
Hoe lees ik in Python een bestand regel voor regel?
Dit is een uitstekende vraag. Laten we eerst wat voorbeeldgegevens maken:
from pathlib import Path
Path('filename').write_text('foo\nbar\nbaz')
Bestandsobjecten zijn luie iterators, dus itereer er gewoon overheen.
filename = 'filename'
with open(filename) as f:
for line in f:
line # do something with the line
Als u meerdere bestanden heeft, kunt u ook fileinput.input
gebruiken, een andere luie iterator. Met slechts één bestand:
import fileinput
for line in fileinput.input(filename):
line # process the line
of geef voor meerdere bestanden een lijst met bestandsnamen door:
for line in fileinput.input([filename]*2):
line # process the line
Nogmaals, f
en fileinput.input
hierboven zijn beide luie iterators.
Je kunt een iterator maar één keer gebruiken, dus om functionele code te bieden en breedsprakigheid te vermijden, zal ik de iets beknoptere fileinput.input(filename)
gebruiken waar dit van toepassing is.
Hoe lees ik in Python een bestand regel voor regel in een lijst?
Ah, maar je wilt het om de een of andere reden in een lijst? Ik zou dat vermijden als dat mogelijk is. Maar als je erop staat… geef gewoon het resultaat van fileinput.input(filename)
door aan list
:
list(fileinput.input(filename))
Een ander direct antwoord is om f.readlines
aan te roepen, die de inhoud van het bestand retourneert (tot een optioneel hint
aantal tekens, zodat u zou kunnen verdeel dit op die manier in meerdere lijsten).
U kunt op twee manieren bij dit bestandsobject komen. Een manier is om de bestandsnaam door te geven aan de ingebouwde open
:
filename = 'filename'
with open(filename) as f:
f.readlines()
of met behulp van het nieuwe Path-object uit de pathlib
-module (waar ik erg dol op ben geworden en vanaf nu zal gebruiken):
from pathlib import Path
path = Path(filename)
with path.open() as f:
f.readlines()
list
gebruikt ook de bestandsiterator en retourneert een lijst – ook een vrij directe methode:
with path.open() as f:
list(f)
Als u het niet erg vindt om de hele tekst in het geheugen te lezen als een enkele string voordat u deze opsplitst, kunt u dit doen als een one-liner met het object Path
en de splitlines()
tekenreeksmethode. Standaard verwijdert splitlines
de nieuwe regels:
path.read_text().splitlines()
Als u de nieuwe regels wilt behouden, geeft u keepends=True
door:
path.read_text().splitlines(keepends=True)
Ik wil het bestand regel voor regel lezen en elke regel aan het einde van de lijst toevoegen.
Dit is een beetje dwaas om te vragen, aangezien we het eindresultaat gemakkelijk hebben aangetoond met verschillende methoden. Maar misschien moet u tijdens het maken van uw lijst filteren of op de lijnen werken, dus laten we dit verzoek met humor beantwoorden.
Als u list.append
gebruikt, kunt u elke regel filteren of bewerken voordat u deze toevoegt:
line_list = []
for line in fileinput.input(filename):
line_list.append(line)
line_list
Het gebruik van list.extend
zou wat directer zijn, en misschien handig als je een reeds bestaande lijst hebt:
line_list = []
line_list.extend(fileinput.input(filename))
line_list
Of meer idiomatisch, we zouden in plaats daarvan een lijstbegrip kunnen gebruiken, en indien gewenst erin toewijzen en filteren:
[line for line in fileinput.input(filename)]
Of nog directer, om de cirkel te sluiten, geef het gewoon door aan de lijst om direct een nieuwe lijst te maken zonder op de regels te werken:
list(fileinput.input(filename))
Conclusie
Je hebt veel manieren gezien om regels uit een bestand in een lijst te krijgen, maar ik raad je aan om geen grote hoeveelheden gegevens in een lijst te materialiseren en in plaats daarvan de luie iteratie van Python te gebruiken om de gegevens indien mogelijk te verwerken.
>
Dat wil zeggen, geef de voorkeur aan fileinput.input
of with path.open() as f
.
Antwoord 23
In het geval dat er ook lege regels in het document staan, lees ik de inhoud graag in en geef ik deze door filter
om lege tekenreekselementen te voorkomen
with open(myFile, "r") as f:
excludeFileContent = list(filter(None, f.read().splitlines()))
Antwoord 24
Ik gebruik graag het volgende. De regels onmiddellijk lezen.
contents = []
for line in open(filepath, 'r').readlines():
contents.append(line.strip())
Of gebruik lijstbegrip:
contents = [line.strip() for line in open(filepath, 'r').readlines()]
Antwoord 25
Je zou ook het loadtxt commando in NumPy kunnen gebruiken. Dit controleert op minder voorwaarden dan genfromtxt, dus het kan sneller zijn.
import numpy
data = numpy.loadtxt(filename, delimiter="\n")
Antwoord 26
Ik zou een van de onderstaande methoden proberen. Het voorbeeldbestand dat ik gebruik heeft de naam dummy.txt
. Je kunt het bestand hier vinden. Ik neem aan dat het bestand zich in dezelfde map bevindt als de code (je kunt fpath
wijzigen om de juiste bestandsnaam en mappad op te nemen.)
In beide onderstaande voorbeelden wordt de gewenste lijst gegeven door lst
.
1.> Eerste methode:
fpath = 'dummy.txt'
with open(fpath, "r") as f: lst = [line.rstrip('\n \t') for line in f]
print lst
>>>['THIS IS LINE1.', 'THIS IS LINE2.', 'THIS IS LINE3.', 'THIS IS LINE4.']
2.> In de tweede methode kan men csv.reader module van Python Standard Library:
import csv
fpath = 'dummy.txt'
with open(fpath) as csv_file:
csv_reader = csv.reader(csv_file, delimiter=' ')
lst = [row[0] for row in csv_reader]
print lst
>>>['THIS IS LINE1.', 'THIS IS LINE2.', 'THIS IS LINE3.', 'THIS IS LINE4.']
U kunt een van de twee methoden gebruiken. De tijd die nodig is voor het maken van lst
is bijna gelijk in de twee methoden.
Antwoord 27
Hier is een Python(3)-helper bibliotheek-klasse die ik gebruik om bestands-I/O te vereenvoudigen:
import os
# handle files using a callback method, prevents repetition
def _FileIO__file_handler(file_path, mode, callback = lambda f: None):
f = open(file_path, mode)
try:
return callback(f)
except Exception as e:
raise IOError("Failed to %s file" % ["write to", "read from"][mode.lower() in "r rb r+".split(" ")])
finally:
f.close()
class FileIO:
# return the contents of a file
def read(file_path, mode = "r"):
return __file_handler(file_path, mode, lambda rf: rf.read())
# get the lines of a file
def lines(file_path, mode = "r", filter_fn = lambda line: len(line) > 0):
return [line for line in FileIO.read(file_path, mode).strip().split("\n") if filter_fn(line)]
# create or update a file (NOTE: can also be used to replace a file's original content)
def write(file_path, new_content, mode = "w"):
return __file_handler(file_path, mode, lambda wf: wf.write(new_content))
# delete a file (if it exists)
def delete(file_path):
return os.remove() if os.path.isfile(file_path) else None
U zou dan de functie FileIO.lines
gebruiken, als volgt:
file_ext_lines = FileIO.lines("./path/to/file.ext"):
for i, line in enumerate(file_ext_lines):
print("Line {}: {}".format(i + 1, line))
Houd er rekening mee dat de parameters mode
(standaard "r"
) en filter_fn
(standaard controleren op lege regels) optioneel zijn.
U kunt zelfs de methoden read
, write
en delete
verwijderen en de FileIO.lines
laten staan, of verander het zelfs in een aparte methode genaamd read_lines
.
Antwoord 28
Opdrachtregelversie
#!/bin/python3
import os
import sys
abspath = os.path.abspath(__file__)
dname = os.path.dirname(abspath)
filename = dname + sys.argv[1]
arr = open(filename).read().split("\n")
print(arr)
Rennen met:
python3 somefile.py input_file_name.txt