Comment lire chaque ligne d'un fichier en Python et stocker chaque ligne en tant qu'élément dans une liste?
Je veux lire le fichier ligne par ligne et ajouter chaque ligne à la fin de la liste.
Comment lire chaque ligne d'un fichier en Python et stocker chaque ligne en tant qu'élément dans une liste?
Je veux lire le fichier ligne par ligne et ajouter chaque ligne à la fin de la liste.
Réponses:
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]
readlines()
n'est pas très efficace car elle peut entraîner MemoryError . Dans ce cas, il est préférable de parcourir le fichier en utilisant for line in f:
et en travaillant avec chaque line
variable.
.rstrip()
cela fonctionnera un peu plus rapidement si vous supprimez les espaces des extrémités des lignes.
with open(filename) as f: content = [i.strip() for i in f.readlines()]
Voir Entrée et sortie :
with open('filename') as f:
lines = f.readlines()
ou en supprimant le caractère de nouvelle ligne:
with open('filename') as f:
lines = [line.rstrip() for line in f]
f.read().splitlines()
, qui supprime les sauts de ligne
for line in open(filename)
sécurisée? Autrement dit, le dossier sera-t-il fermé automatiquement?
lines = [x.rstrip('\n') for x in open('data\hsf.txt','r')]
Si j'écris de cette façon, comment puis-je fermer le fichier après la lecture?
open
sans le gestionnaire de contexte (ou une autre manière garantie de le fermer), ce n'est pas vraiment un de ces cas - lorsque l'objet n'a plus de références il sera récupéré et le fichier fermé, ce qui devrait se produire immédiatement en cas d'erreur ou non, lorsque la compréhension de la liste sera terminée.
C'est plus explicite que nécessaire, mais fait ce que vous voulez.
with open("file.txt") as file_in:
lines = []
for line in file_in:
lines.append(line)
array
, mais il peut y avoir d'autres circonstances). Pour les gros fichiers, cette approche pourrait certainement atténuer les problèmes.
Cela produira un "tableau" de lignes à partir du fichier.
lines = tuple(open(filename, 'r'))
open
renvoie un fichier qui peut être itéré. Lorsque vous parcourez un fichier, vous obtenez les lignes de ce fichier. tuple
peut prendre un itérateur et instancier une instance de tuple pour vous à partir de l'itérateur que vous lui donnez. lines
est un tuple créé à partir des lignes du fichier.
lines = open(filename).read().split('\n')
plutôt.
lines = open(filename).read().splitlines()
un peu plus propre, et je crois qu'il gère également mieux les fins de ligne DOS.
list
occupe environ 13,22% plus d'espace qu'un a tuple
. Les résultats viennent de from sys import getsizeof as g; i = [None] * 1000; round((g(list(i)) / g(tuple(i)) - 1) * 100, 2)
. La création d'un tuple
prend environ 4,17% plus de temps que la création d'un list
(avec un écart type de 0,16%). Les résultats proviennent de from timeit import timeit as t; round((t('tuple(i)', 'i = [None] * 1000') / t('list(i)', 'i = [None] * 1000') - 1) * 100, 2)
30 exécutions . Ma solution privilégie l'espace à la vitesse lorsque le besoin de mutabilité est inconnu.
Si vous voulez l' \n
inclus:
with open(fname) as f:
content = f.readlines()
Si vous ne voulez pas \n
inclus:
with open(fname) as f:
content = f.read().splitlines()
Selon les méthodes d'objets de fichier de Python , la façon la plus simple de convertir un fichier texte en un list
est:
with open('file.txt') as f:
my_list = list(f)
Si vous avez juste besoin d'itérer sur les lignes du fichier texte, vous pouvez utiliser:
with open('file.txt') as f:
for line in f:
...
Ancienne réponse:
Utilisation de with
et readlines()
:
with open('file.txt') as f:
lines = f.readlines()
Si vous ne vous souciez pas de fermer le fichier, ce one-liner fonctionne:
lines = open('file.txt').readlines()
La manière traditionnelle :
f = open('file.txt') # Open file on read mode
lines = f.read().split("\n") # Create a list containing all lines
f.close() # Close file
Vous pouvez simplement faire ce qui suit, comme cela a été suggéré:
with open('/your/path/file') as f:
my_lines = f.readlines()
Notez que cette approche a 2 inconvénients:
1) Vous stockez toutes les lignes en mémoire. Dans le cas général, c'est une très mauvaise idée. Le fichier peut être très volumineux et vous risquez de manquer de mémoire. Même si ce n'est pas grand, c'est simplement un gaspillage de mémoire.
2) Cela ne permet pas de traiter chaque ligne pendant que vous les lisez. Donc, si vous traitez vos lignes après cela, ce n'est pas efficace (nécessite deux passes plutôt qu'une).
Une meilleure approche pour le cas général serait la suivante:
with open('/your/path/file') as f:
for line in f:
process(line)
Où vous définissez votre fonction de processus comme vous le souhaitez. Par exemple:
def process(line):
if 'save the world' in line.lower():
superman.save_the_world()
(La mise en œuvre de la Superman
classe est laissée comme un exercice pour vous).
Cela fonctionnera parfaitement pour n'importe quelle taille de fichier et vous parcourez votre fichier en un seul passage. C'est généralement ainsi que fonctionneront les analyseurs génériques.
open('file_path', 'r+')
Données dans la liste
Supposons que nous ayons un fichier texte avec nos données comme dans les lignes suivantes,
Contenu du fichier texte:
line 1
line 2
line 3
python
et dans l'interpréteur écrivez:Le script Python:
>>> with open("myfile.txt", encoding="utf-8") as file:
... x = [l.rstrip("\n") for l in file]
>>> x
['line 1','line 2','line 3']
En utilisant append:
x = []
with open("myfile.txt") as file:
for l in file:
x.append(l.strip())
Ou:
>>> x = open("myfile.txt").read().splitlines()
>>> x
['line 1', 'line 2', 'line 3']
Ou:
>>> x = open("myfile.txt").readlines()
>>> x
['linea 1\n', 'line 2\n', 'line 3\n']
Ou:
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)
production:
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']
read().splitlines()
est fourni par Python: c'est tout simplement readlines()
(ce qui est probablement plus rapide, car c'est moins de gaspillage).
read().splitlines()
et readlines()
ne produit pas la même sortie. Êtes-vous sûr qu'ils sont équivalents?
strip()
doit être rstrip("\n")
ou les espaces autour d'une ligne sont supprimés. De plus, cela ne sert à rien de readlines()
comprendre une liste: il est préférable d'itérer simplement sur le fichier, car cela ne perd pas de temps et de mémoire en créant une liste intermédiaire des lignes.
Pour lire un fichier dans une liste, vous devez faire trois choses:
Heureusement, Python permet de faire ces choses très facilement, donc le moyen le plus court de lire un fichier dans une liste est:
lst = list(open(filename))
Cependant, je vais ajouter quelques explications supplémentaires.
Je suppose que vous voulez ouvrir un fichier spécifique et que vous ne traitez pas directement avec un descripteur de fichier (ou un descripteur de type fichier). La fonction la plus utilisée pour ouvrir un fichier en Python est open
, elle prend un argument obligatoire et deux optionnels en Python 2.7:
Le nom de fichier doit être une chaîne qui représente le chemin d'accès au fichier . Par exemple:
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)
Notez que l'extension de fichier doit être spécifiée. Ceci est particulièrement important pour les utilisateurs de Windows car les extensions de fichiers comme .txt
ou .doc
, etc. sont masquées par défaut lorsqu'elles sont affichées dans l'explorateur.
Le deuxième argument est le mode
, c'est r
par défaut ce qui signifie "lecture seule". C'est exactement ce dont vous avez besoin dans votre cas.
Mais si vous voulez réellement créer un fichier et / ou écrire dans un fichier, vous aurez besoin d'un argument différent ici. Il y a une excellente réponse si vous voulez un aperçu .
Pour lire un fichier, vous pouvez omettre le mode
ou le transmettre explicitement:
open(filename)
open(filename, 'r')
Les deux ouvriront le fichier en mode lecture seule. Si vous souhaitez lire un fichier binaire sous Windows, vous devez utiliser le mode rb
:
open(filename, 'rb')
Sur d'autres plateformes, le 'b'
(mode binaire) est simplement ignoré.
Maintenant que j'ai montré comment archiver open
le fichier, parlons du fait que vous en aurez toujours besoin close
. Sinon, il conservera un descripteur de fichier ouvert jusqu'à ce que le processus se termine (ou que Python récupère le descripteur de fichier).
Bien que vous puissiez utiliser:
f = open(filename)
# ... do stuff with f
f.close()
Cela ne fermera pas le fichier lorsque quelque chose entre open
et close
lève une exception. Vous pouvez éviter cela en utilisant un try
et finally
:
f = open(filename)
# nothing in between!
try:
# do stuff with f
finally:
f.close()
Cependant, Python fournit des gestionnaires de contexte qui ont une syntaxe plus jolie (mais pour open
elle, elle est presque identique à celle ci try
- finally
dessus):
with open(filename) as f:
# do stuff with f
# The file is always closed after the with-scope ends.
La dernière approche est l' approche recommandée pour ouvrir un fichier en Python!
D'accord, vous avez ouvert le fichier, maintenant comment le lire?
La open
fonction renvoie un file
objet et prend en charge le protocole d'itération Pythons. Chaque itération vous donnera une ligne:
with open(filename) as f:
for line in f:
print(line)
Cela imprimera chaque ligne du fichier. Notez cependant que chaque ligne contiendra un caractère de nouvelle ligne \n
à la fin (vous voudrez peut-être vérifier si votre Python est construit avec la prise en charge universelle des nouvelles lignes - sinon vous pourriez également avoir \r\n
sur Windows ou \r
Mac en tant que nouvelles lignes). Si vous ne le souhaitez pas, vous pouvez simplement supprimer le dernier caractère (ou les deux derniers caractères sous Windows):
with open(filename) as f:
for line in f:
print(line[:-1])
Mais la dernière ligne n'a pas nécessairement de retour à la ligne, donc il ne faut pas l'utiliser. On pourrait vérifier s'il se termine par un retour à la ligne de fin et si oui, supprimez-le:
with open(filename) as f:
for line in f:
if line.endswith('\n'):
line = line[:-1]
print(line)
Mais vous pouvez simplement supprimer tous les espaces blancs (y compris le \n
caractère) de la fin de la chaîne , cela supprimera également tous les autres espaces blancs de fin , vous devez donc faire attention si ceux-ci sont importants:
with open(filename) as f:
for line in f:
print(f.rstrip())
Cependant si les lignes se terminent par \r\n
("newlines" Windows) cela .rstrip()
prendra également soin de \r
!
Maintenant que vous savez comment ouvrir le fichier et le lire, il est temps de stocker le contenu dans une liste. L'option la plus simple serait d'utiliser la list
fonction:
with open(filename) as f:
lst = list(f)
Si vous souhaitez supprimer les sauts de ligne de fin, vous pouvez utiliser une compréhension de liste à la place:
with open(filename) as f:
lst = [line.rstrip() for line in f]
Ou encore plus simple: la .readlines()
méthode de l' file
objet renvoie par défaut une list
des lignes:
with open(filename) as f:
lst = f.readlines()
Cela inclura également les caractères de fin de ligne, si vous ne les voulez pas, je recommanderais l' [line.rstrip() for line in f]
approche car cela évite de garder deux listes contenant toutes les lignes en mémoire.
Il existe une option supplémentaire pour obtenir la sortie souhaitée, mais elle est plutôt "sous-optimale": read
le fichier complet dans une chaîne, puis divisé sur les retours à la ligne:
with open(filename) as f:
lst = f.read().split('\n')
ou:
with open(filename) as f:
lst = f.read().splitlines()
Ceux-ci prennent automatiquement en charge les sauts de ligne de fin car le split
personnage n'est pas inclus. Cependant, elles ne sont pas idéales car vous conservez le fichier sous forme de chaîne et de liste de lignes en mémoire!
with open(...) as f
lors de l'ouverture de fichiers car vous n'avez pas besoin de vous occuper de la fermeture du fichier vous-même et il ferme le fichier même si une exception se produit.file
les objets prennent en charge le protocole d'itération, la lecture d'un fichier ligne par ligne est donc aussi simple que for line in the_file_object:
.readlines()
mais si vous voulez traiter les lignes avant de les stocker dans la liste, je recommanderais une simple compréhension de la liste.Manière claire et pythonique de lire les lignes d'un fichier dans une liste
Avant tout, vous devez vous concentrer sur l'ouverture de votre fichier et la lecture de son contenu de manière efficace et pythonique. Voici un exemple de la façon dont je ne préfère pas personnellement:
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.
Au lieu de cela, je préfère la méthode ci-dessous pour ouvrir des fichiers à la fois en lecture et en écriture car elle est très propre et ne nécessite pas d'étape supplémentaire de fermeture du fichier une fois que vous avez fini de l'utiliser. Dans l'instruction ci-dessous, nous ouvrons le fichier en lecture et l'assignons à la variable «infile». Une fois le code de cette instruction terminé, le fichier sera automatiquement fermé.
# Open the file for reading.
with open('my_file.txt', 'r') as infile:
data = infile.read() # Read the contents of the file into memory.
Nous devons maintenant nous concentrer sur l'intégration de ces données dans une liste Python car elles sont itérables, efficaces et flexibles. Dans votre cas, l'objectif souhaité est de placer chaque ligne du fichier texte dans un élément distinct. Pour ce faire, nous utiliserons la méthode splitlines () comme suit:
# Return a list of the lines, breaking at line boundaries.
my_list = data.splitlines()
Le produit final:
# 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()
Test de notre code:
A fost odatã ca-n povesti,
A fost ca niciodatã,
Din rude mãri împãrãtesti,
O prea frumoasã fatã.
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]
['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 odatã ca-n povesti, A fost ca niciodatã, Din rude mãri
împãrãtesti, O prea frumoasã fatã.
O prea frumoasã fatã.
Introduit dans Python 3.4, pathlib
a une méthode très pratique pour lire du texte à partir de fichiers, comme suit:
from pathlib import Path
p = Path('my_text_file')
lines = p.read_text().splitlines()
(L' splitlines
appel est ce qui le transforme d'une chaîne contenant tout le contenu du fichier en une liste de lignes dans le fichier).
pathlib
a beaucoup de commodités pratiques en elle. read_text
est agréable et concis, et vous n'avez pas à vous soucier de l'ouverture et de la fermeture du fichier. Si tout ce que vous avez à faire avec le fichier est de le lire en une seule fois, c'est un bon choix.
Voici une autre option en utilisant des compréhensions de liste sur les fichiers;
lines = [line.rstrip() for line in open('file.txt')]
Cela devrait être plus efficace car la plupart du travail se fait à l'intérieur de l'interpréteur Python.
rstrip()
supprime potentiellement tous les espaces de fin, pas seulement le \n
; utiliser .rstrip('\n')
.
Lire et écrire des fichiers texte avec Python 2 et Python 3; cela fonctionne avec Unicode
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Define data
lines = [' A first string ',
'A Unicode sample: €',
'German: äöüß']
# 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)
A noter:
with
est un soi-disant gestionnaire de contexte . Il s'assure que le fichier ouvert est refermé..strip()
ou .rstrip()
ne reproduiront pas le lines
car elles dépouillent également l'espace blanc.Terminaisons de fichiers communes
.txt
Écriture / lecture de fichiers plus avancées
Pour votre application, les éléments suivants peuvent être importants:
Voir aussi: Comparaison des formats de sérialisation des données
Dans le cas où vous cherchez plutôt un moyen de créer des fichiers de configuration, vous voudrez peut-être lire mon court article Fichiers de configuration en Python .
Une autre option est numpy.genfromtxt
, par exemple:
import numpy as np
data = np.genfromtxt("yourfile.dat",delimiter="\n")
Cela fera data
un tableau NumPy avec autant de lignes qu'il y a dans votre fichier.
Si vous souhaitez lire un fichier depuis la ligne de commande ou depuis stdin, vous pouvez également utiliser le fileinput
module:
# reader.py
import fileinput
content = []
for line in fileinput.input():
content.append(line.strip())
fileinput.close()
Passez-y des fichiers comme ceci:
$ python reader.py textfile.txt
En savoir plus ici: http://docs.python.org/2/library/fileinput.html
La façon la plus simple de le faire
Un moyen simple consiste à:
En une ligne, cela donnerait:
lines = open('C:/path/file.txt').read().splitlines()
Cependant, c'est assez inefficace car cela stockera 2 versions du contenu en mémoire (probablement pas un gros problème pour les petits fichiers, mais quand même). [Merci Mark Amery].
Il existe 2 façons plus simples:
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')]
pathlib
créer un chemin d'accès à votre fichier que vous pourriez utiliser pour d'autres opérations dans votre programme: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()]
.read().splitlines()
n'est en aucun cas "plus simple" que d'appeler.readlines()
. Pour un autre, il est inefficace en mémoire; vous stockez inutilement deux versions du contenu du fichier (la chaîne unique renvoyée par .read()
et la liste des chaînes renvoyées par splitlines()
) en mémoire à la fois.
Utilisez simplement les fonctions splitlines (). Voici un exemple.
inp = "file.txt"
data = open(inp)
dat = data.read()
lst = dat.splitlines()
print lst
# print(lst) # for python 3
Dans la sortie, vous aurez la liste des lignes.
.readlines()
. Cela met deux copies du contenu du fichier en mémoire à la fois (une sous forme de chaîne énorme unique, une sous forme de liste de lignes).
Si vous voulez être confronté à un fichier très volumineux / volumineux et que vous souhaitez lire plus rapidement (imaginez que vous êtes dans un concours de codage Topcoder / Hackerrank), vous pouvez lire un bloc de lignes considérablement plus grand dans un tampon mémoire à la fois, plutôt que il suffit d'itérer ligne par ligne au niveau du fichier.
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)
process(line)
est une fonction que vous devez implémenter pour traiter les données. par exemple, au lieu de cette ligne, si vous utilisez print(line)
, il imprimera chaque ligne à partir du lines_buffer.
lines = list(open('filename'))
ou
lines = tuple(open('filename'))
ou
lines = set(open('filename'))
Dans le cas de set
, nous devons nous rappeler que nous n'avons pas l'ordre des lignes préservé et nous débarrasser des lignes dupliquées.
Étant donné que vous n'appelez pas
.close
l'objet fichier ni n'utilisez unewith
instruction, dans certaines implémentations Python, le fichier peut ne pas être fermé après la lecture et votre processus perdra un descripteur de fichier ouvert .En CPython (l' implémentation Python normale que la plupart des gens utilisent), ce n'est pas un problème car l'objet fichier sera immédiatement récupéré et cela fermera le fichier, mais il est néanmoins généralement considéré comme la meilleure pratique de faire quelque chose comme :
with open('filename') as f: lines = list(f)
pour vous assurer que le fichier est fermé quelle que soit l' implémentation Python que vous utilisez.
.close
l'objet fichier ni n'utilisez une with
instruction, dans certaines implémentations Python, le fichier peut ne pas être fermé après la lecture et votre processus perdra un descripteur de fichier ouvert. En CPython (l'implémentation Python normale que la plupart des gens utilisent), ce n'est pas un problème car l'objet fichier sera immédiatement récupéré et cela fermera le fichier, mais il est néanmoins généralement considéré comme la meilleure pratique de faire quelque chose comme with open('filename') as f: lines = list(f)
pour s'assurer que le fichier est fermé quelle que soit l'implémentation Python que vous utilisez.
Utilisez ceci:
import pandas as pd
data = pd.read_csv(filename) # You can also add parameters such as header, sep, etc.
array = data.values
data
est un type de trame de données et utilise des valeurs pour obtenir ndarray. Vous pouvez également obtenir une liste en utilisant array.tolist()
.
pandas.read_csv()
est pour la lecture des données CSV , comment est-il approprié ici?
Avec un filename
, en manipulant le fichier à partir d'un Path(filename)
objet, ou directement avec open(filename) as f
, effectuez l'une des opérations suivantes:
list(fileinput.input(filename))
with path.open() as f
, appelerf.readlines()
list(f)
path.read_text().splitlines()
path.read_text().splitlines(keepends=True)
fileinput.input
ou f
etlist.append
chaque ligne une à la foisf
à une limitelist.extend
méthodef
dans une liste de compréhensionJ'explique le cas d'utilisation pour chacun ci-dessous.
En Python, comment lire un fichier ligne par ligne?
Ceci est une excellente question. Commençons par créer des exemples de données:
from pathlib import Path
Path('filename').write_text('foo\nbar\nbaz')
Les objets fichier sont des itérateurs paresseux, il suffit donc d'itérer dessus.
filename = 'filename'
with open(filename) as f:
for line in f:
line # do something with the line
Alternativement, si vous avez plusieurs fichiers, utilisez fileinput.input
un autre itérateur paresseux. Avec un seul fichier:
import fileinput
for line in fileinput.input(filename):
line # process the line
ou pour plusieurs fichiers, passez-lui une liste de noms de fichiers:
for line in fileinput.input([filename]*2):
line # process the line
Encore f
et fileinput.input
surtout, les deux sont / retournent des itérateurs paresseux. Vous ne pouvez utiliser un itérateur qu'une seule fois, donc pour fournir du code fonctionnel tout en évitant la verbosité, j'utiliserai le légèrement plus concis fileinput.input(filename)
où il est proposé d'ici.
En Python, comment lire un fichier ligne par ligne dans une liste?
Ah mais vous le voulez dans une liste pour une raison quelconque? J'éviterais cela si possible. Mais si vous insistez ... passez simplement le résultat de fileinput.input(filename)
à list
:
list(fileinput.input(filename))
Une autre réponse directe consiste à appeler f.readlines
, qui renvoie le contenu du fichier (jusqu'à un hint
nombre facultatif de caractères, vous pouvez donc décomposer en plusieurs listes de cette façon).
Vous pouvez accéder à cet objet fichier de deux manières. Une façon consiste à passer le nom de fichier au open
module intégré:
filename = 'filename'
with open(filename) as f:
f.readlines()
ou en utilisant le nouvel objet Path du pathlib
module (que j'aime beaucoup et que j'utiliserai à partir de maintenant):
from pathlib import Path
path = Path(filename)
with path.open() as f:
f.readlines()
list
consommera également l'itérateur de fichier et renverra une liste - une méthode assez directe également:
with path.open() as f:
list(f)
Si cela ne vous dérange pas de lire le texte entier en mémoire comme une seule chaîne avant de le fractionner, vous pouvez le faire en une ligne avec l' Path
objet et la splitlines()
méthode de chaîne. Par défaut, splitlines
supprime les sauts de ligne:
path.read_text().splitlines()
Si vous souhaitez conserver les nouvelles lignes, passez keepends=True
:
path.read_text().splitlines(keepends=True)
Je veux lire le fichier ligne par ligne et ajouter chaque ligne à la fin de la liste.
Maintenant, c'est un peu idiot de demander, étant donné que nous avons facilement démontré le résultat final avec plusieurs méthodes. Mais vous devrez peut-être filtrer ou opérer sur les lignes lors de la création de votre liste, alors humorisons cette demande.
L'utilisation list.append
vous permettrait de filtrer ou d'opérer sur chaque ligne avant de l'ajouter:
line_list = []
for line in fileinput.input(filename):
line_list.append(line)
line_list
L'utilisation list.extend
serait un peu plus directe, et peut-être utile si vous avez une liste préexistante:
line_list = []
line_list.extend(fileinput.input(filename))
line_list
Ou plus idiomatiquement, nous pourrions plutôt utiliser une liste de compréhension, et mapper et filtrer à l'intérieur si cela est souhaitable:
[line for line in fileinput.input(filename)]
Ou encore plus directement, pour fermer le cercle, il suffit de le passer à list pour créer directement une nouvelle liste sans opérer sur les lignes:
list(fileinput.input(filename))
Vous avez vu de nombreuses façons d'obtenir des lignes d'un fichier dans une liste, mais je vous recommande d'éviter de matérialiser de grandes quantités de données dans une liste et d'utiliser à la place l'itération paresseuse de Python pour traiter les données si possible.
Autrement dit, préférez fileinput.input
ou with path.open() as f
.
Vous pouvez également utiliser la commande loadtxt dans NumPy. Cela vérifie moins de conditions que genfromtxt, il peut donc être plus rapide.
import numpy
data = numpy.loadtxt(filename, delimiter="\n")
J'aime utiliser ce qui suit. Lecture immédiate des lignes.
contents = []
for line in open(filepath, 'r').readlines():
contents.append(line.strip())
Ou en utilisant la compréhension de liste:
contents = [line.strip() for line in open(filepath, 'r').readlines()]
readlines()
, ce qui entraîne même une pénalité de mémoire. Vous pouvez simplement le supprimer, car l'itération sur un fichier (texte) donne chaque ligne tour à tour.
with
instruction pour ouvrir (et fermer implicitement) le fichier.
J'essaierais l'une des méthodes mentionnées ci-dessous. Le fichier d'exemple que j'utilise porte le nom dummy.txt
. Vous pouvez trouver le fichier ici . Je suppose que le fichier se trouve dans le même répertoire que le code (vous pouvez modifier fpath
pour inclure le nom de fichier et le chemin de dossier appropriés.)
Dans les deux exemples mentionnés ci-dessous, la liste que vous souhaitez est donnée par lst
.
1.> Première méthode :
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.> Dans la deuxième méthode , on peut utiliser le module csv.reader de la bibliothèque standard Python :
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.']
Vous pouvez utiliser l'une des deux méthodes. Le temps nécessaire à la création de lst
est presque égal dans les deux méthodes.
delimiter=' '
argument?
Voici une classe de bibliothèque d' assistance Python (3) que j'utilise pour simplifier les E / S de fichiers:
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
Vous utiliseriez alors la FileIO.lines
fonction, comme ceci:
file_ext_lines = FileIO.lines("./path/to/file.ext"):
for i, line in enumerate(file_ext_lines):
print("Line {}: {}".format(i + 1, line))
N'oubliez pas que mode
( "r"
par défaut) etfilter_fn
paramètres (vérifie les lignes vides par défaut) sont facultatifs.
Vous pouvez même retirer les read
, write
et les delete
méthodes et juste laisser le FileIO.lines
, ou même en faire une méthode distincte appelée read_lines
.
lines = FileIO.lines(path)
vraiment assez simple with open(path) as f: lines = f.readlines()
pour justifier l'existence de cet assistant? Vous économisez, par exemple, 17 caractères par appel. (Et la plupart du temps, pour des raisons de performances et de mémoire, vous voudrez boucler directement sur un objet fichier au lieu de lire ses lignes dans une liste de toute façon, donc vous ne voudrez même pas l'utiliser souvent!) souvent fan de créer de petites fonctions utilitaires, mais celui-ci me semble comme créer simplement inutilement une nouvelle façon d'écrire quelque chose qui est déjà court et facile avec la bibliothèque standard.
#!/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)
python3 somefile.py input_file_name.txt
file.readlines()
dans unfor
-loop, un objet fichier lui-même suffit:lines = [line.rstrip('\n') for line in file]