Comment lire un fichier ligne par ligne dans une liste?

Question

Comment lire chaque ligne d'un fichier en Python et stocker chaque ligne en tant qu'élément d'une liste? 

Je veux lire le fichier ligne par ligne et ajouter chaque ligne à la fin de la liste.

Answer 1

with open(fname) 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] 

Answer 2

Voir Entrée et sortie :

with open('filename') as f:
    lines = f.readlines()

ou en supprimant le caractère de nouvelle ligne:

lines = [line.rstrip('\n') for line in open('filename')]

^{Note de l'éditeur: La commande originale de suppression des espaces, line.strip(), comme le laisse supposer le commentaire de Janus Troelsen, supprime tous les espaces blancs de début et de fin, pas seulement le \n de fin.}

Answer 3

Ceci est plus explicite que nécessaire, mais fait ce que vous voulez.

with open("file.txt", "r") as ins:
    array = []
    for line in ins:
        array.append(line)

Answer 4

Cela donnera un "tableau" de lignes du fichier.

lines = Tuple(open(filename, 'r'))

Answer 5

Si vous voulez que le \n soit inclus:

with open(fname) as f:
    content = f.readlines()

Si vous ne voulez pas que \n soit inclus:

with open(fname) as f:
    content = f.read().splitlines()

Answer 6

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 le traitement de chaque ligne lorsque vous les lisez. Donc, si vous traitez vos lignes après cela, cela n’est pas efficace (nécessite deux passages au lieu d’un).

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()

(L'implémentation de la classe Superman est laissée comme exercice pour vous).

Cela fonctionnera bien pour n’importe quelle taille de fichier et vous parcourerez votre fichier en une seule passe. C'est typiquement comment les analyseurs syntaxiques génériques fonctionneront.

Answer 7

Si vous ne vous souciez pas de la fermeture du fichier, cette ligne unique fonctionne:

lines = open('file.txt').readlines()

La manière traditionnelle:

fp = open('file.txt') # Open file on read mode
lines = fp.read().split("\n") # Create a list containing all lines
fp.close() # Close file

Utilisation de with et readlines() (recommandé) :

with open('file.txt') as fp:
    lines = fp.readlines()

Answer 8

Données en 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

• Ouvrez le cmd dans le même répertoire (cliquez avec le bouton droit de la souris et choisissez cmd ou PowerShell)
• Exécutez python et dans l'interprète écrivez:

Le script Python

>>> with open("myfile.txt", encoding="utf-8") as file:
...     x = [l.strip() for l in file]
>>> x
['line 1','line 2','line 3']

Utiliser 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...

>>> y = [x.rstrip() for x in open("my_file.txt")]
>>> y
['line 1','line 2','line 3']


with open('testodiprova.txt', 'r', encoding='utf-8') as file:
    file = file.read().splitlines()
  print(file)

with open('testodiprova.txt', 'r', encoding='utf-8') as file:
  file = file.readlines()
  print(file)

Answer 9

Cela devrait encapsuler la commande open. 

array = []
with open("file.txt", "r") as f:
  for line in f:
    array.append(line)

Answer 10

Mode propre et pythonique de lecture des 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 personnellement PAS:

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 d’ouverture des fichiers pour la lecture et l’é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 la déclaration ci-dessous, nous ouvrons le fichier .__ pour lecture et l’attribuons à la variable "infile". Une fois que le code dans Cette instruction est terminée, 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’ajout de ces données dans une liste Python car elles sont itératives, efficaces et souples. Dans votre cas, l’objectif souhaité est de regrouper chaque ligne du fichier texte dans un élément distinct. Pour ce faire, nous allons utiliser 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:

• Contenu du fichier texte:

     A fost odatã ca-n povesti,
     A fost ca niciodatã,
     Din rude mãri împãrãtesti,
     O prea frumoasã fatã.

• Imprimer les relevés à des fins de test:

    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]

• Sortie (différente en raison des caractères Unicode):

     ['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ã.

Answer 11

Pour lire un fichier dans une liste, vous devez faire trois choses:

• Ouvrir le fichier
• Lire le dossier
• Stocker le contenu sous forme de liste

Heureusement, Python facilite grandement ces tâches. Le moyen le plus rapide de lire un fichier dans une liste est le suivant:

lst = list(open(filename))

Cependant, je vais ajouter quelques explications supplémentaires.

Ouvrir le fichier

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 semblable à un fichier). La fonction la plus couramment utilisée pour ouvrir un fichier en Python est open , il faut un argument obligatoire et deux en option dans Python 2.7:

• Nom de fichier
• Mode
• Mise en mémoire tampon (je vais ignorer cet argument dans cette réponse)

Le nom de fichier doit être une chaîne représentant le chemin du 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 Windows car les extensions de fichier telles que .txt ou .doc, etc. sont masquées par défaut lors de leur affichage dans l'explorateur.

Le deuxième argument est la 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 la mode ou le transmettre explicitement:

open(filename)
open(filename, 'r')

Les deux ouvriront le fichier en mode lecture seule. Si vous voulez lire un fichier binaire sous Windows, vous devez utiliser le mode rb:

open(filename, 'rb')

Sur les autres plateformes, le 'b' (mode binaire) est simplement ignoré.

---

Maintenant que j'ai montré comment open le fichier, parlons du fait que vous devez toujours le close à nouveau. Sinon, il conservera un descripteur de fichier ouvert jusqu'à ce que le processus se termine (ou Python jongle avec le descripteur de fichier). 

Bien que vous puissiez utiliser:

f = open(filename)
# ... do stuff with f
f.close()

La fermeture du fichier échouera si quelque chose entre open et close lève une exception. Vous pourriez éviter cela en utilisant 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 c'est presque identique à try et finally ci-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!

Lecture du fichier

Ok, vous avez ouvert le fichier, maintenant comment le lire? 

La fonction open renvoie un objet file 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 support universel des nouvelles lignes - sinon vous pourriez aussi avoir \r\n sous Windows ou \r sur Mac comme 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 fin de ligne, vous ne devez donc pas l'utiliser. On pourrait vérifier si elle se termine par une nouvelle ligne et, le cas échéant, la supprimer:

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 (y compris le caractère \n) de la fin de la chaîne, cela supprimera également tous les autres espaces suivis, de sorte que vous devez faire attention s'ils sont importants. :

with open(filename) as f:
    for line in f:
        print(f.rstrip())

Cependant, si les lignes se terminent par \r\n ("nouvelles lignes" Windows), cette fonction prendra également en charge le \r!

Stocker le contenu sous forme de liste

Maintenant que vous savez comment ouvrir et lire le fichier, il est temps de stocker le contenu dans une liste. L'option la plus simple consisterait à utiliser la fonction list :

with open(filename) as f:
    lst = list(f)

Si vous souhaitez supprimer les retours à la ligne, vous pouvez utiliser une liste de compréhension:

with open(filename) as f:
    lst = [line.rstrip() for line in f]

Ou encore plus simple: La méthode .rstrip() de l'objet file 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'approche .readlines() car elle évite de conserver deux listes contenant toutes les lignes en mémoire.

Il existe une option supplémentaire pour obtenir le résultat souhaité, mais il s'agit plutôt d'un paramètre "sous-optimal": read le fichier complet dans une chaîne, puis divisé sur les nouvelles lignes:

with open(filename) as f:
    lst = f.read().split('\n')

ou:

with open(filename) as f:
    lst = f.read().splitlines()

Ceux-ci traitent automatiquement les nouvelles lignes de fin car le caractère split n'est pas inclus. Cependant, ils ne sont pas idéaux car vous gardez le fichier sous forme de chaîne et sous forme de liste de lignes en mémoire!

Résumé

• Utilisez [line.rstrip() for line in f] lorsque vous ouvrez des fichiers car vous n'avez pas besoin de vous en occuper vous-même et le ferme même si une exception se produit.
• Les objets file prennent en charge le protocole d'itération. La lecture d'un fichier ligne par ligne est aussi simple que for line in the_file_object:.Parcourez toujours la documentation pour connaître les fonctions/classes disponibles. La plupart du temps, la tâche est parfaitement adaptée ou au moins une ou deux bonnes. Le choix évident dans ce cas serait with open(...) as f mais si vous voulez traiter les lignes avant de les stocker dans la liste, je vous recommanderais une simple compréhension par liste.
• Always browse the documentation for the available functions/classes. Most of the time there's a perfect match for the task or at least one or two good ones. The obvious choice in this case would be readlines() but if you want to process the lines before storing them in the list I would recommend a simple list-comprehension.

Answer 12

Je le ferais comme ça.

lines = []
with open("myfile.txt") as f:
    for line in f:
        lines.append(line)

Answer 13

Voici une autre option en utilisant la compréhension de liste sur les fichiers;

lines = [line.rstrip() for line in open('file.txt')]

Cela devrait être plus efficace car la plus grande partie du travail est effectuée dans l’interpréteur Python.

Answer 14

Une autre option est numpy.genfromtxt , par exemple:

import numpy as np
data = np.genfromtxt("yourfile.dat",delimiter="\n")

Cela fera de data un tableau NumPy avec autant de lignes que dans votre fichier.

Answer 15

Si vous souhaitez lire un fichier à partir de la ligne de commande ou de stdin, vous pouvez également utiliser le module fileinput:

# reader.py
import fileinput

content = []
for line in fileinput.input():
    content.append(line.strip())

fileinput.close()

Transmettez les fichiers comme ceci:

$ python reader.py textfile.txt 

Lisez plus ici: http://docs.python.org/2/library/fileinput.html

Answer 16

La façon la plus simple de le faire

Un moyen simple est de:

1. Lire le fichier entier comme une chaîne
2. Fractionner la chaîne ligne par ligne

En une ligne, cela donnerait:

lines = open('C:/path/file.txt').read().splitlines()

Answer 17

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)

Les choses à noter:

• with est un soi-disant gestionnaire de contexte _. Il s'assure que le fichier ouvert est à nouveau fermé.
• Toutes les solutions ici qui ne font que .strip() ou .rstrip() échouent à reproduire la variable lines car elles suppriment également l'espace blanc.

Terminaisons de fichier communes

.txt

Écriture/lecture de fichier plus avancée

• CSV: format super simple ( lecture et écriture _)
• JSON: Idéal pour écrire des données lisibles par l'homme. TRÈS couramment utilisé ( lire et écrire _)
• YAML: YAML est un sur-ensemble de JSON, mais plus facile à lire ( lire et écrire _, comparaison de JSON et YAML )
• pickle: format de sérialisation Python ( lecture et écriture _)
• MessagePack _ ( package Python ): représentation plus compacte ( en lecture et en écriture )
• HDF5 ( package Python ): sympa pour les matrices ( lecture et écriture )
• XML: existe aussi * soupir * ( lire & écrire )

Pour votre application, les éléments suivants peuvent être importants:

• Prise en charge par d'autres langages de programmation
• Lecture/écriture
• Compacité (taille de fichier)

Voir aussi: COMPARAISON DES FORMATS DE SÉRIALISATION DES DONNÉES

Si vous cherchez plutôt un moyen de créer des fichiers de configuration, vous pouvez lire mon court article FICHIERS DE CONFIGURATION EN PYTHON.

Answer 18

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'appel splitlines est ce qui le fait passer d'une chaîne contenant tout le contenu du fichier à une liste de lignes dans le fichier).

pathlib a beaucoup de commodités utiles. 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 lu en une seule fois, c'est un bon choix.

Answer 19

f = open("your_file.txt",'r')
out = f.readlines() # will append in the list out

Maintenant variable en sortie est une liste (tableau) de ce que vous voulez. Vous pouvez soit faire:

for line in out:
    print line

ou

for line in f:
    print line

vous obtiendrez les mêmes résultats.

Answer 20

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.

Answer 21

Un vrai moyen facile:

with open(file) as g:
    stuff = g.readlines()

Si vous voulez en faire un programme à part entière, tapez ceci dans:

file = raw_input ("Enter EXACT file name: ")
with open(file) as g:
    stuff = g.readlines()
print (stuff)
exit = raw_input("Press enter when you are done.")

Pour une raison quelconque, il ne lit pas les fichiers .py correctement.

Answer 22

Vous pouvez simplement ouvrir votre fichier en lecture en utilisant:

file1 = open("filename","r")
# And for reading use
lines = file1.readlines()
file1.close()

La liste lines contiendra toutes vos lignes en tant qu'éléments individuels. Vous pouvez appeler un élément spécifique à l'aide de lines["linenumber-1"], car Python commence à compter à partir de 0.

Answer 23

Si vous voulez faire face à un fichier très volumineux/énorme et vouloir lire plus vite (imaginez que vous êtes dans une compétition de codage Topcoder/Hackerrank), vous pouvez lire un bloc beaucoup plus gros des lignes dans une mémoire tampon à la fois, plutôt que de simplement 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)

Answer 24

À ma connaissance, Python n'a pas de structure de données de tableau natif. Mais il supporte la structure de données liste qui est beaucoup plus simple à utiliser qu'un tableau.

array = [] #declaring a list with name '**array**'
with open(PATH,'r') as reader :
    for line in reader :
        array.append(line)

Answer 25

La façon la plus simple de le faire avec quelques avantages supplémentaires est:

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 et que nous nous débarrassons des lignes dupliquées.

Answer 26

Vous pouvez facilement le faire avec le code suivant:

lines = open(filePath).readlines()

Answer 27

Voici un assistant Python (3) bibliothèque classe que j'utilise pour simplifier les entrées/sorties 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 ensuite la fonction FileIO.lines, 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 les paramètres mode ("r" par défaut) et filter_fn (recherche les lignes vides par défaut) sont facultatifs.

Vous pouvez même supprimer les méthodes read, write et delete et simplement laisser le FileIO.lines ou même le transformer en une méthode séparée appelée read_lines.

Answer 28

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 structure de données et utilise des valeurs pour obtenir ndarray. Vous pouvez également obtenir une liste en utilisant array.tolist().

Answer 29

Découvrez ce court extrait

fileOb=open("filename.txt","r")
data=fileOb.readlines() #returns a array of lines.

ou 

fileOb=open("filename.txt","r")
data=list(fileOb) #returns a array of lines.

se référer docs pour référence

Answer 30

Vous pouvez également utiliser la commande loadtxt dans NumPy. Cela vérifie moins de conditions que genfromtxt, de sorte qu'il peut être plus rapide.

import numpy
data = numpy.loadtxt(filename, delimiter="\n")

Answer 31

Je voudrais essayer 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 présume 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 du 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 méthode second, vous pouvez utiliser csv.reader module 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 pris pour la création de lst est presque égal dans les deux méthodes.

Answer 32

J'aime utiliser ce qui suit. Lire les lignes immédiatement.

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()]

Answer 33

Version en ligne de commande

#!/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)

Courir avec:

python3 somefile.py input_file_name.txt

Answer 34

Dans le cas où il y aurait aussi des lignes vides dans le document, j'aime lire le contenu et le transmettre à travers filter pour éviter les éléments de chaîne vides

with open(myFile, "r") as f:
    excludeFileContent = list(filter(None, f.read().splitlines()))