En Python, comment lire un fichier ligne par ligne dans une liste?



Answers

Voir Entrée et Sortie :

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

ou avec l'effacement du caractère de nouvelle ligne:

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

Note de l'éditeur: La commande whitespace-stripping originale de cette réponse, line.strip() , comme implicite par le commentaire de Janus Troelsen, supprimerait tous les espaces de début et de fin , pas seulement le \n .

Question

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.




Lire et écrire des fichiers texte avec Python 2 + 3; 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)

Choses à remarquer:

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

Terminaisons de fichier communes

.txt

Écriture / lecture de fichiers plus avancés

  • CSV: format super simple ( lecture et écriture )
  • JSON: Nice 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 ( lecture et écriture , comparaison de JSON et YAML )
  • pickle: un format de sérialisation Python ( lecture et écriture )
  • MessagePack ( paquet Python ): représentation plus compacte ( lecture et écriture )
  • HDF5 ( paquet Python ): Nice pour les matrices ( lire et écrire )
  • XML: existe aussi * soupir * ( read et write )

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

  • Prise en charge par d'autres langages de programmation
  • Lecture / écriture
  • Compacité (taille du 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 petit article Fichiers de configuration en Python




Si vous voulez faire face à un fichier très grand / énorme et que vous voulez lire plus vite (imaginez que vous êtes dans un concours de codage Topcoder / Hackerrank), vous pourriez lire un morceau de lignes considérablement plus grand dans un tampon mémoire à la fois. il suffit de parcourir 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)



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.




with open(fname) as fo:
        data=fo.read().replace('\n', ' ').replace (',', ' ')

Ceci devrait répondre à votre question. La fonction de remplacement servira de délimiteur pour supprimer le fichier.




À ma connaissance, Python n'a pas de structure de données native. Mais il supporte la structure de données de 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)



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

  • Ouvrez le fichier
  • Lire le fichier
  • Stocker le contenu sous forme de liste

Heureusement, Python rend très facile de faire ces choses, 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.

Ouverture du fichier

Je suppose que vous voulez ouvrir un fichier spécifique et que vous ne traitez pas directement avec un handle de fichier (ou un handle de type fichier). La fonction la plus couramment utilisée pour ouvrir un fichier en Python est open , il faut un argument obligatoire et deux optionnels dans Python 2.7:

  • Nom de fichier
  • Mode
  • Buffering (je vais ignorer cet argument dans cette réponse)

Le nom de fichier doit être une chaîne représentant 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 fichier telles que .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 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. Dans le cas où vous voulez lire dans 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 . Sinon, il gardera un fichier-handle ouvert vers le fichier jusqu'à ce que le processus se termine (ou Python garbages le handle de fichier).

Alors que vous pourriez utiliser:

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

Cela échouera à fermer le fichier lorsque quelque chose entre open et close déclenche une exception. Vous pourriez é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 l' open c'est presque identique à l' try et finally au-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!

Lire le 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 fin de ligne \n à la fin (vous pouvez vérifier si votre Python est construit avec le support des nouvelles lignes universelles - sinon vous pouvez aussi avoir \r\n sous Windows ou sur Mac comme des sauts) . Si vous ne voulez pas que vous puissiez simplement supprimer le dernier caractère (ou les deux derniers caractères sur Windows):

with open(filename) as f:
    for line in f:
        print(line[:-1])

Mais la dernière ligne n'a pas nécessairement un retour à la ligne, donc on ne devrait pas l'utiliser. On pourrait vérifier si elle se termine par un retour chariot et si c'est le cas, retirez-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 (y compris le caractère \n ) à la fin de la chaîne , cela supprimera également tous les autres espaces de fin, donc vous devez faire attention si elles sont importantes:

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

Cependant, si les lignes se terminent par \r\n (Windows "newlines"), .rstrip() prendra également soin de la \r !

Stocker le contenu sous forme de liste

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 fonction list :

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

Si vous voulez supprimer les nouvelles lignes, vous pouvez utiliser une liste de lecture à la place:

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

Ou encore plus simple: La méthode .readlines() de l'objet file renvoie par défaut une list de 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] car cela évite de garder deux listes contenant toutes les lignes en mémoire.

Il existe une option supplémentaire pour obtenir la sortie désirée, mais elle est plutôt "sous-optimale": read le fichier complet dans une chaîne, puis diviser 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 compte les retours à la ligne, car le caractère de split n'est pas inclus. Cependant ils ne sont pas idéaux car vous conservez le fichier sous forme de chaîne et sous forme de liste de lignes en mémoire!

Résumé

  • Utilisez with open(...) as f lors de l'ouverture des fichiers car vous n'avez pas besoin de prendre soin de fermer le fichier vous-même et il ferme le fichier même si une exception se produit.
  • file objets file prennent en charge le protocole d'itération, donc lire un fichier ligne par ligne est aussi simple que for line in the_file_object:
  • Toujours parcourir la documentation pour les fonctions / classes disponibles. La plupart du temps, il y a un match parfait pour la tâche ou au moins un ou deux bons. Le choix évident dans ce cas serait readlines() mais si vous voulez traiter les lignes avant de les stocker dans la liste, je vous recommande une simple compréhension de liste.



Une autre option est numpy.genfromtxt , par exemple:

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

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




Cela donnera un "tableau" de lignes à partir du fichier.

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



Cela devrait encapsuler la commande ouverte.

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



Une manière propre et pythonique de lire les lignes d'un fichier dans une liste

Tout d'abord, vous devriez 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:

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 à la fois pour la lecture et l'écriture car il est très propre, et ne nécessite pas une é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 à lire et l'affectons à la variable 'infile'. Une fois que le code dans cette instruction a fini d'être exécuté, 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.

Maintenant, nous devons nous concentrer sur l'introduction de ces données dans une liste Python car elles sont itératives, 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 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 instructions à 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ã.



Vous pourriez 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 deux 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 pourriez manquer de mémoire. Même si ce n'est pas grand, c'est simplement un gaspillage de mémoire.

2) Cela n'autorise pas le traitement de chaque ligne lorsque 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()

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

Cela fonctionnera bien pour n'importe quelle taille de fichier et vous parcourez votre fichier en seulement 1 passe. C'est typiquement comment les parseurs génériques fonctionneront.




Le moyen le plus simple de le faire

Un moyen simple est de:

  1. Lire le fichier entier sous forme de chaîne
  2. Séparer la chaîne de caractères par ligne

En une ligne, cela donnerait:

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



Peut également utiliser la commande loadtxt en numpy. Cela vérifie moins de conditions que genfromtxt, donc il peut être plus rapide.

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



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



Links