string écrire - En Python, comment lire un fichier ligne par ligne dans une liste?





d'un données (25)


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

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.




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



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.




Vous pouvez simplement ouvrir votre fichier pour le lire en utilisant

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

Les lignes de liste contiendront toutes vos lignes en tant qu'éléments individuels et vous pouvez appeler un élément spécifique en utilisant les lines["linenumber-1"] comme python commence son compte à partir de 0.




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.




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

Passe les fichiers comme ça:

$ python reader.py textfile.txt 

Lire la suite ici: http://docs.python.org/2/library/fileinput.html




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.




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



Je le ferais comme ça.

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



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.




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




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)



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
  1. Ouvrez le cmd dans le même répertoire (faites un clic droit sur la souris et choisissez cmd ou powershell)
  2. exécutez python et dans l'interpréteur é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...

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

Obtenir un texte à partir d'une page Web avec python 3

Voici un exemple pratique d'un texte saisi sur le net. La page contient du texte brut, que nous devons nettoyer des caractères \ n \ r et b 'prêts pour l'impression.

  • Convertir les données de l'octet en chaîne
  • Créer une liste de chaînes en séparant chaque nouvelle ligne
  • Nettoyez chaque élément de la liste \ n \ r et b 'caractères, ainsi que toute autre chose qui réduit la lisibilité du texte.

code:

from urllib.request import urlopen
# I grab the text into this variable with urlopen and the read() method
testo = urlopen("https://www.gutenberg.org/files/11/11.txt").read()
# then I split the text at each newline, transforming the strin in a list
testo = str(testo).split("\\n")
# now I show some lines, from 30 to 48, replacing some stuffs
for l in testo[30:48]:
    print(l.replace("\\r","").replace("\\'","\'").replace("b'",""))

SORTIE:

LES AVENTURES D'ALICE AU PAYS DES MERVEILLES

Lewis Carroll

LE MILLENIUM FULCRUM EDITION 3.0

CHAPITRE PREMIER Le bas du lapin

Alice commençait à en avoir assez de s'asseoir auprès de sa sœur sur la berge et de n'avoir rien à faire: une ou deux fois elle avait jeté un coup d'œil dans le livre que sa sœur lisait, mais il n'y avait ni images ni conversations. est l'utilisation d'un livre, pensa Alice sans images ni conversations?




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)



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] 

Je devine que vous vouliez dire list et non tableau.




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.



lines = list(open("dict.lst", "r"))
linesSanitized = map(lambda each:each.strip("\n"), lines)
print linesSanitized



Version de 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



Vous pouvez facilement le faire avec le morceau de code suivant:

lines = open(filePath).readlines()



Si vous voulez le \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()



Voici une option de plus en utilisant la compréhension de la 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 faite à l'intérieur de l'interpréteur Python.




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

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



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 .




Ceci est une réponse adaptée du org.apache.commons.io.IOUtils code source , pour ceux qui veulent avoir l'implémentation d'Apache mais ne veulent pas de la bibliothèque entière.

private static final int BUFFER_SIZE = 4 * 1024;

public static String inputStreamToString(InputStream inputStream, String charsetName)
        throws IOException {
    StringBuilder builder = new StringBuilder();
    InputStreamReader reader = new InputStreamReader(inputStream, charsetName);
    char[] buffer = new char[BUFFER_SIZE];
    int length;
    while ((length = reader.read(buffer)) != -1) {
        builder.append(buffer, 0, length);
    }
    return builder.toString();
}




python string file readlines