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] 

voir entrée et sortie :

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

ou avec le décapage de la caractère de saut de ligne:

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

^{note de L'Éditeur: la commande originale de suppression d'espace de cette réponse, line.strip() , comme le laisse entendre le commentaire de Janus Troelsen, supprimerait all leading and trailing whitespace, pas seulement la suite \n .}

C'est plus explicite que nécessaire, mais est-ce que vous voulez.

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

Cela donnera un" tableau " de lignes du fichier.

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

si vous voulez que le \n soit 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()

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 comporte 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 pourrait être très gros, et vous pourriez manquer de mémoire. Même s'il n'est pas grand, il est tout simplement une perte de mémoire.

2) cela ne permet pas le traitement de chaque ligne comme vous les lisez. Donc, si vous traitez vos lignes après cela, il n'est pas efficace (nécessite deux fois 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 classe Superman est un exercice pour vous).

cela fonctionnera bien pour n'importe quelle taille de fichier et vous passez par votre fichier en seulement 1 passe. C'est généralement ainsi que les analyseurs génériques fonctionneront.

si vous ne vous souciez pas de fermer le fichier, celui-ci fonctionne:

lines = open('file.txt').read().split("\n")

Le traditionnel :

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

par with (recommandé):

with open('file.txt') as fp:
    lines = fp.read().split("\n")

cela devrait encapsuler la commande Ouvrir.

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

données dans la liste

Supposons que nous avons un fichier texte avec nos données, comme dans les lignes suivantes:

fichier Texte contenu:

   line 1
   line 2
   line 3

• ouvrir le cmd dans le même répertoire (clic droit sur la souris et choisir cmd ou PowerShell)
• Exécuter python et l'interprète de l'écriture:

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']

en utilisant l'annexe

x = []
with open("myfile.txt") as file:
    for l in file:
        x.append(l.strip())

Or...

>>> x = open("myfile.txt").read().splitlines()
>>> x
['line 1', 'line 2', 'line 3']

Or...

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

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

tout d'abord, vous devez vous concentrer sur l'ouverture de votre fichier et la lecture de son contenu d'une 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.

à la place, je préfère la méthode ci-dessous d'ouvrir des fichiers pour la lecture et l'écriture car il est très propre, et ne pas besoin d'une étape supplémentaire pour fermer le fichier une fois que vous avez terminé de l'utiliser. Dans la déclaration ci-dessous, nous ouvrons le fichier pour la lecture, et de l'affecter à la variable " infile."Une fois le code à l'intérieur cette déclaration 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.

maintenant nous devons nous concentrer sur l'intégration de ces données dans une liste Python parce qu'elles sont itérables, efficaces et flexibles. Dans votre cas, le but recherché est d'amener les chaque ligne du fichier texte dans un élément séparé. 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:

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

• Impression des déclarations 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]

"1519360920 de Sortie" (différent en raison de 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ã.

je le ferais comme ça.

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

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

• ouvrir le fichier
• lire le dossier
• stocker le contenu sous forme de liste

heureusement Python rend très facile de faire ces choses donc la façon la plus courte de lire un fichier dans une liste est:

lst = list(open(filename))

cependant, je vais ajouter quelques explications.

ouverture le dossier

je suppose que vous voulez ouvrir un fichier spécifique et vous ne traitent pas directement avec un descripteur de fichier (ou un fichier-comme-la poignée). La fonction la plus couramment utilisée pour ouvrir un fichier en Python est open , il prend un argument obligatoire et deux optionnels en python 2.7:

• nom de fichier
• Mode
• mise en mémoire Tampon (je vais ignorer cet argument dans cette réponse)

le nom du fichier doit être une chaîne de caractères qui représente le chemin vers le 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 du fichier doit être spécifié. Ceci est particulièrement important pour les utilisateurs de Windows car les extensions de fichiers comme .txt ou .doc , etc. sont cachés par défaut 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 passer explicitement:

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

les deux ouvrir le fichier en mode lecture seule. Dans le cas où vous voulez lire dans un fichier binaire sur Windows vous devez utiliser le mode rb :

open(filename, 'rb')

sur d'autres plateformes le 'b' (mode binaire) est tout simplement ignoré.

maintenant que j'ai montré comment open le fichier, parlons du fait que vous avez toujours besoin de close il à nouveau. Dans le cas contraire, il gardera un dossier ouvert-handle au dossier jusqu'à ce que le processus de sortie (ou garbages de Python Le file-handle).

pendant que vous pouvez utiliser:

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

qui ne fermera pas le fichier quand quelque chose entre open et close jette 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 open c'est presque identique au 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 la recommandée approche pour ouvrir un fichier en Python!

lire le dossier

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

la fonction open renvoie un objet file et elle supporte le protocole d'itération Pythons. Chaque itération sera vous donner une ligne:

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

Cela permettra d'imprimer chaque ligne du fichier. Notez cependant que chaque ligne contiendra un caractère newline \n à la fin (vous pourriez vouloir vérifier si votre Python est construit avec universal newlines support - sinon vous pourriez aussi avoir \r\n sur Windows ou \r sur Mac comme newlines). Si vous ne voulez pas que vous pouvez peut 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'est pas nécessairement suivie d'une nouvelle ligne, il ne faut donc pas l'utiliser. On pourrait vérifier si elle se termine avec une nouvelle ligne de traînée et si oui l'enlever:

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 caractère \n ) de la fin de la chaîne de caractères , cela va également supprimer tous les autres traînant espaces blancs donc vous devez être 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 (fenêtres" newlines") que .rstrip() prendra également soin du \r !

stocker le contenu comme la 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)

dans le cas où vous voulez enlever les nouvelles traînantes, vous pouvez utiliser une liste de compréhension à 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 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 recommande l'approche [line.rstrip() for line in f] parce qu'il évite de conserver deux listes contenant toutes les lignes en mémoire.

Il ya une option supplémentaire pour obtenir la sortie désirée, mais il est plutôt "suboptimal": read le fichier complet dans une chaîne de caractères, 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 prennent soin de la suite de nouvelles lignes automatiquement parce que le caractère split n'est pas inclus. Cependant, ils ne sont pas idéales parce que vous gardez le fichier comme chaîne et comme une liste de lignes en mémoire!

résumé

• utilisez with open(...) as f lors de l'ouverture des fichiers parce que 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 les objets supportent 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 recommande une simple liste-compréhension.

Voici une autre option en utilisant des listes d'interprétation sur les fichiers;

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

cela devrait être plus efficace car la plupart du travail est fait à l'intérieur de L'interpréteur Python.

une autre option est numpy.genfromtxt , par exemple:

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

cela fera de data un NumPy array avec autant de lignes que sont dans votre fichier.

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

# reader.py
import fileinput

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

fileinput.close()

passer des fichiers comme ceci:

$ python reader.py textfile.txt 

pour en savoir plus: http://docs.python.org/2/library/fileinput.html

la manière la plus simple de le faire

une façon simple est de:

1. Lire la suite
2. Fractionner la chaîne ligne par ligne

en une ligne, qui donnerait:

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

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

maintenant variable out est une Liste (Tableau) de ce que vous voulez. Vous pouvez faire:

for line in out:
    print line

ou

for line in f:
    print line

, vous obtiendrez les mêmes résultats.

lire et écrire des fichiers texte avec Python 2 et Python 3; Il 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 veille à ce que le dossier ouvert soit à nouveau clos.
• toutes les solutions ici qui font simplement .strip() ou .rstrip() ne reproduiront pas le lines car elles rayent aussi l'espace blanc.

fin du fichier commun

.txt

plus avancé l'écriture / la lecture de fichiers

• CSV: super simple format ( read & write )
• JSON: Nice pour l'écriture lisible des données; TRÈS couramment utilisés ( lecture et écriture )
• YAML: YAML est un sur-ensemble de JSON, mais plus facile à lire ( lecture et écriture , comparaison de JSON et YAML )
• pickle: Un Python format de sérialisation ( lecture et écriture )
• MessagePack ( paquet Python ): représentation Plus compacte ( lecture et écriture )
• HDF5 ( Python package ): Sympa pour les matrices ( lecture et écriture )
• XML: il 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 de la performance
• compacité (Taille du fichier)

Voir aussi: comparaison des formats de sérialisation des données

dans le cas où vous êtes plutôt à la recherche d'un moyen de créer des fichiers de configuration, vous pourriez vouloir lire mon court article fichiers de Configuration en Python .

utilisez simplement les fonctions splitlines (). Ici est 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.

Un vrai en toute simplicité:

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

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

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, ça ne se lit pas .dossiers py correctement.

vous pouvez simplement ouvrir votre fichier pour la 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, et vous pouvez appeler un élément spécifique en utilisant lines["linenumber-1"] comme Python commence son comptage à partir de 0.

si vous voulez être confronté à un très grand / énorme fichier et que vous voulez lire plus vite (imaginez que vous êtes dans un concours de codage Topcoder/Hackerrank), vous pourriez lire un morceau beaucoup plus grand de lignes dans un tampon mémoire à la fois, plutôt que juste 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)

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

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

introduit en Python 3.4, pathlib a une méthode très pratique pour lire dans le 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 pratiques en elle. read_text est agréable et concise, et vous n'avez pas à vous soucier de l'ouverture et de la fermeture fichier. Si tout ce que vous avez à faire avec le fichier est de le lire en une seule fois, c'est un bon choix.

vous pouvez facilement le faire par le morceau de code suivant:

lines = open(filePath).readlines()

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

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)

Exécuter avec:

python3 somefile.py input_file_name.txt

j'aime utiliser ce qui suit. Lisant 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()]

plan et résumé

avec un filename , en manipulant le fichier à partir d'un Path(filename) objet, ou directement avec open(filename) as f , faire l'un des suivants:

• list(fileinput.input(filename))
• utilisant with path.open() as f , appelez f.readlines()
• list(f)
• path.read_text().splitlines()
• path.read_text().splitlines(keepends=True)
• itérer sur fileinput.input ou f et list.append chaque ligne une à la fois
• pass f à une borne list.extend méthode
• utiliser f dans une liste de compréhension

j'explique le cas d'utilisation pour chaque ci-dessous.

En Python, comment lire un fichier ligne par ligne?

C'est une excellente question. Tout d'abord, créons quelques exemples de données:

from pathlib import Path
Path('filename').write_text('foo\nbar\nbaz')

les objets de fichier sont des itérateurs paresseux, donc il suffit 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, passer une liste de noms de fichiers:

for line in fileinput.input([filename]*2): 
    line # process the line

de nouveau, f et fileinput.input au-dessus de tous les deux sont/retour paresseux itérateurs. Vous pouvez n'utilisez qu'un itérateur une seule fois, donc pour fournir le code fonctionnel tout en évitant la verbosité je vais utiliser le fileinput.input(filename) légèrement plus courte où apropos d'ici.

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

Ah mais vous voulez dans une liste pour une raison quelconque? J'aimerais éviter si possible. Mais si vous insistez... il suffit de passer le résultat de fileinput.input(filename) à list :

list(fileinput.input(filename))

une autre réponse directe est d'appeler f.readlines , qui renvoie le contenu du fichier (jusqu'à un hint nombre facultatif de caractères, de sorte que vous pourrait décomposer en plusieurs listes de cette façon).

vous pouvez accéder à cet objet fichier de deux façons. Une façon est de passer le nom du fichier au open builtin:

filename = 'filename'

with open(filename) as f:
    f.readlines()

ou en utilisant le nouvel objet Path pathlib module (que j'ai beaucoup aimé, 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 retournera une liste - une méthode tout à fait directe ainsi:

with path.open() as f:
    list(f)

si cela ne vous dérange pas de lire le texte entier en mémoire sous la forme d'une seule chaîne de caractères avant de le diviser, vous pouvez le faire sous la forme d'une doublure unique avec l'objet Path et la méthode de chaîne de caractères splitlines() . Par défaut, splitlines supprime les nouvelles lignes:

path.read_text().splitlines()

si vous voulez garder les nouvelles lignes, passer keepends=True :

path.read_text().splitlines(keepends=True)

je veux lire le fichier ligne par ligne et ajoutez chaque ligne à la fin de la liste.

maintenant, c'est un peu stupide à demander, étant donné que nous avons démontré le résultat final facilement avec plusieurs méthodes. Mais vous pourriez avoir besoin de filtrer ou d'opérer sur les lignes que vous faites votre liste, alors faisons plaisir à cette requête.

L'utilisation de list.append vous permettrait de filtrer ou de fonctionner sur chaque ligne avant de l'ajouter:

line_list = []
for line in fileinput.input(filename):
    line_list.append(line)

line_list

utiliser list.extend serait un peu plus direct, 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 la carte et le filtre à l'intérieur si souhaitable:

[line for line in fileinput.input(filename)]

ou plus directement encore, pour fermer le cercle, il suffit de passer à la liste pour créer une nouvelle liste directement, sans exploitation sur les lignes:

list(fileinput.input(filename))

Conclusion

vous avez vu de nombreuses façons d'obtenir des lignes à partir 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 à la place d'utiliser l'itération paresseuse de Python pour traiter les données si possible.

, c'est-à-dire préférer fileinput.input ou with path.open() as f .