Hoe lees je een bestand regel voor regel in een lijst?

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.
  • li>

  • file-objecten ondersteunen het iteratieprotocol, dus het regel voor regel lezen van een bestand is net zo eenvoudig als for 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.

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 de lines niet reproduceren omdat ze ook de witruimte.

Veelgebruikte bestandsuitgangen

.txt

Geavanceerder schrijven/lezen van bestanden

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:

  1. Lees het hele bestand als een string
  2. 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:

  1. 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')]
  1. 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 geen with-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, bel f.readlines()
  • list(f)
  • path.read_text().splitlines()
  • path.read_text().splitlines(keepends=True)
  • herhaal over fileinput.input of f en list.append elke regel één voor één
  • geef f door aan een gebonden list.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

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes