Em Python, como posso ler um arquivo linha-a-linha em uma lista?
como é que leio todas as linhas de um ficheiro em Python e guardo cada linha como um elemento numa lista?
quero ler o ficheiro linha por linha e adicionar cada linha ao fim da lista.
30 answers
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]
Ver Entrada e saída:
with open('filename') as f:
lines = f.readlines()
Ou com a remoção do carácter da nova linha:
lines = [line.rstrip('\n') for line in open('filename')]
Nota do Editor: o comando original de remoção de espaços em branco desta resposta, {[[2]}, como implícito pelo Comentário de Janus Troelsen, removeria todos os espaços iniciais e finais , não apenas os espaços finais \n
.
with open("file.txt", "r") as ins:
array = []
for line in ins:
array.append(line)
Isto irá produzir um "array" de linhas do ficheiro.
lines = tuple(open(filename, 'r'))
Se quiser que o \n
seja incluído:
with open(fname) as f:
content = f.readlines()
Se não quiser \n
incluído:
with open(fname) as f:
content = f.read().splitlines()
Você poderia simplesmente fazer o seguinte, como foi sugerido:
with open('/your/path/file') as f:
my_lines = f.readlines()
Note que esta abordagem tem duas desvantagens:
Você guarda todas as linhas na memória. No caso geral, esta é uma péssima ideia. O arquivo pode ser muito grande, e você pode ficar sem memória. Mesmo que não seja grande, é simplesmente um desperdício de memória.
2) isto não permite o processamento de cada linha à medida que os lê. Assim, se você processar suas linhas depois disso, não é eficiente (requer dois = = ligações externas = =
Uma melhor abordagem para o caso geral seria a seguinte:
with open('/your/path/file') as f:
for line in f:
process(line)
Onde define a função do seu processo como quiser. Por exemplo:
def process(line):
if 'save the world' in line.lower():
superman.save_the_world()
(a implementação da classe Superman
é deixada como um exercício para você).
Isto vai funcionar bem para qualquer tamanho de arquivo e você vai ver o seu arquivo em apenas 1 passe. Isto é tipicamente como os parsers genéricos funcionarão.
Se não se importa em fechar o ficheiro, esta linha funciona:
lines = open('file.txt').read().split("\n")
A maneira tradicional:
fp = open('file.txt') # Open file on read mode
lines = fp.read().split("\n") # Create a list containing all lines
fp.close() # Close file
Usando with
(recomendado):
with open('file.txt') as fp:
lines = fp.read().split("\n")
Isto deve encapsular o comando aberto.
array = []
with open("file.txt", "r") as f:
for line in f:
array.append(line)
Dados na lista
Suponha que temos um ficheiro de texto com os nossos dados, como nas seguintes linhas:
Conteúdo do ficheiro de texto:
line 1
line 2
line 3
- abra o cmd na mesma pasta (carregue com o botão direito do rato e escolha cmd ou PowerShell)
- corre
python
e no interpretador escreve:
O programa em Python
>>> with open("myfile.txt", encoding="utf-8") as file:
... x = [l.strip() for l in file]
>>> x
['line 1','line 2','line 3']
Usar o 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']
Limpar e Pythonic maneira de ler as linhas de um arquivo em uma lista
Em primeiro lugar, deve concentrar-se em abrir o seu ficheiro e ler o seu conteúdo de uma forma eficiente e pitónica. Aqui está um exemplo de como eu pessoalmente não Prefiro:
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.
Em vez disso, eu prefiro o método abaixo de abrir arquivos para leitura e escrita como ele é muito limpo, e não requer um passo extra de fechar o arquivo assim que acabares de O usar. Na declaração abaixo, estamos a abrir o ficheiro para ler, e atribuí-lo à variável 'infile."Uma vez que o código dentro esta instrução terminou de executar, o arquivo será fechado automaticamente.
# Open the file for reading.
with open('my_file.txt', 'r') as infile:
data = infile.read() # Read the contents of the file into memory.
Agora precisamos nos concentrar em trazer esses dados para uma listaPython porque eles são iteráveis, eficientes e flexíveis. No seu caso, o objetivo desejado é trazer cada linha do arquivo de texto em um elemento separado. Para isso, usaremos as linhas() método:
# Return a list of the lines, breaking at line boundaries.
my_list = data.splitlines()
O Produto 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()
Testar O Nosso Código:
- conteúdo do ficheiro de texto:
A fost odatã ca-n povesti,
A fost ca niciodatã,
Din rude mãri împãrãtesti,
O prea frumoasã fatã.
- declarações de impressão para efeitos de ensaio:
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]
- resultado (diferente por causa dos caracteres 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ã.
lines = []
with open("myfile.txt") as f:
for line in f:
lines.append(line)
- abra o ficheiro
- lê o ficheiro
- conservar o conteúdo na lista
Felizmente o Python torna muito fácil fazer estas coisas, pelo que a forma mais curta de ler um ficheiro numa lista é:
lst = list(open(filename))
No entanto, vou acrescentar mais uma explicação.
A abrir o ficheiro
Eu presumo que você quer abrir um arquivo específico e você não lida diretamente com um arquivo-manejar (ou um file-like-handle). A função mais usada para abrir um ficheiro em Python éopen
, é preciso um argumento obrigatório e dois opcionais em Python 2.7:
- nome do ficheiro
- modo
- Buffering (vou ignorar este argumento nesta resposta)
O nome do ficheiro deve ser uma cadeia que representa o caminho para o ficheiro . Por exemplo:
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)
Note que a extensão do ficheiro precisa de ser especificada. Isto é especialmente importante para Utilizadores do Windows porque as extensões de ficheiros como .txt
ou .doc
, etc. estão escondidos por padrão quando vistos no explorer.
O segundo argumento é o mode
, é r
por padrão que significa "apenas leitura". É exactamente disso que precisas no teu caso.
Mas no caso de você realmente querer criar um arquivo e / ou escrever para um arquivo você vai precisar de um argumento diferente aqui. há uma excelente resposta se quiser uma visão geral .
Para ler um ficheiro, pode omite omode
ou passe-o explicitamente:
open(filename)
open(filename, 'r')
Ambos irão abrir o ficheiro apenas para leitura. No caso de você querer ler em um arquivo binário no Windows você precisa usar o modo rb
:
open(filename, 'rb')
Noutras plataformas, o 'b'
(modo binário) é simplesmente ignorado.
Agora que mostrei como fazer o arquivo, vamos falar sobre o fato de que você sempre precisa fazer isso de novo. Caso contrário, ele vai manter um arquivo aberto-lidar com o arquivo até que o processo sai (ou Python garbages the file-handle).
Enquanto pode usar:
f = open(filename)
# ... do stuff with f
f.close()
Isso deixará de fechar o ficheiro quando algo entre open
e {25]} abrir uma excepção. Você poderia evitar isso usando um try
e finally
:
f = open(filename)
# nothing in between!
try:
# do stuff with f
finally:
f.close()
No entanto, Python fornece gerentes de contexto que têm uma sintaxe mais bonita (mas para open
é quase idêntico ao try
e finally
acima):
with open(filename) as f:
# do stuff with f
# The file is always closed after the with-scope ends.
A última abordagem é arecomendada para abrir um ficheiro em Python!
A ler o ficheiro
Muito bem, abriste o ficheiro, agora como o ler?A função open
devolve um file
object and it supports Pythons iteration protocol. Cada iteração lhe dará uma linha:
with open(filename) as f:
for line in f:
print(line)
Isto irá imprimir cada linha do ficheiro. Lembre-se, contudo, que cada linha irá conter um carácter newline \n
no final (poderá querer verificar se o seu Python é construído com suporte universal newlines - caso contrário você também pode ter \r\n
no Windows ou \r
no Mac como newlines). Se não quiser que possa simplesmente remover o último carácter (ou os dois últimos caracteres no Windows):
with open(filename) as f:
for line in f:
print(line[:-1])
Mas a última linha não tem necessariamente uma nova linha, por isso não se deve usar isso. Pode-se verificar se termina com uma nova linha e, em caso afirmativo, removê-la:
with open(filename) as f:
for line in f:
if line.endswith('\n'):
line = line[:-1]
print(line)
Mas você poderia simplesmente remover todos os espaços em branco (incluindo o carácter \n
) do fim do texto , isto também irá remover todos os outrosespaços em branco, por isso tem de ter cuidado se estes forem importantes:
with open(filename) as f:
for line in f:
print(f.rstrip())
No entanto, se as linhas terminarem com \r\n
(janelas "linhas novas") que .rstrip()
também tratará do \r
!
Conservar o conteúdo na lista
Agora que você sabe como abrir o arquivo e lê-lo, é hora de armazenar o conteúdo em uma lista. A opção mais simples seria usar olist
função:
with open(filename) as f:
lst = list(f)
No caso de quereres para remover as novas linhas finais, poderá usar uma compreensão da lista em vez disso:
with open(filename) as f:
lst = [line.rstrip() for line in f]
Ou ainda mais simples:.readlines()
o método do objecto file
por omissão devolve um list
das linhas:
with open(filename) as f:
lst = f.readlines()
Isto também irá incluir os caracteres da nova linha que se seguem, se não os quiser, eu recomendaria a abordagem [line.rstrip() for line in f]
porque evita manter duas listas contendo todas as linhas na memória.
read
o ficheiro completo numa cadeia de caracteres e, em seguida, dividido em linhas novas:
with open(filename) as f:
lst = f.read().split('\n')
Ou:
with open(filename) as f:
lst = f.read().splitlines()
Estes tratam das novas linhas que se seguem automaticamente porque o carácter split
não está incluído. No entanto, eles não são ideais porque você mantém o arquivo como string e como uma lista de linhas na memória!
Resumo
- Use
with open(...) as f
ao abrir os ficheiros porque não precisa de se preocupar em fechar o ficheiro e ele fecha a arquivar mesmo se alguma exceção acontecer. -
file
Os objectos suportam o protocolo de iteração, pelo que ler um ficheiro linha-a-linha é tão simples comofor line in the_file_object:
. - procure sempre a documentação para as funções/classes disponíveis. Na maioria das vezes há uma combinação perfeita para a tarefa ou pelo menos uma ou duas boas. A escolha óbvia neste caso seria
readlines()
mas se você quiser processar as linhas antes de armazená-las na lista eu recomendaria um simples compreensão de lista.
Aqui está mais uma opção usando as compreensões de listas em arquivos;
lines = [line.rstrip() for line in open('file.txt')]
Isto deve ser mais eficiente, pois a maior parte do trabalho é feito dentro do interpretador Python.
Outra opção é numpy.genfromtxt
, por exemplo:
import numpy as np
data = np.genfromtxt("yourfile.dat",delimiter="\n")
Isto fará data
um array NumPy com todas as linhas que estão no seu ficheiro.
Se quiser ler um ficheiro da linha de comandos ou do stdin, também pode usar o módulo fileinput
:
# reader.py
import fileinput
content = []
for line in fileinput.input():
content.append(line.strip())
fileinput.close()
Passa ficheiros para ele assim:
$ python reader.py textfile.txt
Leia mais aqui: http://docs.python.org/2/library/fileinput.html
A maneira mais simples de o fazer
Uma maneira simples é:
- Leia o ficheiro inteiro como um texto
- divide a linha de texto por linha
lines = open('C:/path/file.txt').read().splitlines()
f = open("your_file.txt",'r')
out = f.readlines() # will append in the list out
Agora a variável para fora é uma lista (array) do que você quer. Você pode fazer:
for line in out:
print line
Ou
for line in f:
print line
Terás os mesmos resultados.
Ler e escrever ficheiros de texto com Python 2 e Python 3; funciona com o 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)
Coisas para reparar:
-
with
é um assim chamado Gestor de contexto. Ele garante que o arquivo aberto é fechado novamente. - Todas as soluções aqui que simplesmente fazem
.strip()
ou.rstrip()
falharão em reproduzir olines
Pois também tiram o espaço branco.
Terminações de ficheiros comuns
.txt
Escrita de Ficheiros mais avançada / leitura
- CSV: formato Super simples ( ler e escrever)
- JSON: bom para escrever dados legíveis pelo ser humano; muito usado ( ler e escrever)
- YAML: YAML é um super-conjunto de JSON, mas mais fácil de ler ( ler e escrever, comparação entre a JSON e a YAML)
- pickle: um formato de serialização em Python (ler e escrever)
- MessagePack (pacote Python): representação Mais compacta (leia & escrever)
- HDF5 (pacote Python ): bom para matrizes ( ler e escrever)
- XML: existe também * sigh* (leia & escrever)
Para a sua aplicação, pode ser importante o seguinte:
- apoio por outras linguagens de programação
- leitura / escrita
- compacidade (Tamanho do ficheiro)
Ver também: comparação da serialização dos dados formatos
Caso esteja à procura de uma forma de criar ficheiros de configuração, talvez queira ler o meu pequeno artigo ficheiros de configuração em Python.
Usa apenas as funções splitlines (). Aqui está um exemplo.
inp = "file.txt"
data = open(inp)
dat = data.read()
lst = dat.splitlines()
print lst
# print(lst) # for python 3
Na saída você terá a lista de linhas.
Uma maneira muito fácil:
with open(file) as g:
stuff = g.readlines()
Se quiser torná-lo um programa completo, escreva isto em:
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.")
Por alguma razão, ele não lê arquivos .py corretamente.
Pode apenas abrir o seu ficheiro para ler usando:
file1 = open("filename","r")
# And for reading use
lines = file1.readlines()
file1.close()
A lista lines
irá conter todas as suas linhas como elementos individuais, e poderá chamar um elemento específico usando lines["linenumber-1"]
à medida que o Python começa a contar a partir de 0.
Se quiser ser confrontado com um muito grande / enorme ficheiro e quiser Ler mais depressa (imagine que está numa competição de codificação Topcoder/Hackerrank), poderá ler um pedaço consideravelmente maior de linhas num buffer de memória de uma só vez, em vez de apenas iterar linha a linha ao nível dos ficheiros.
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)
array = [] #declaring a list with name '**array**'
with open(PATH,'r') as reader :
for line in reader :
array.append(line)
Usa isto:
import pandas as pd
data = pd.read_csv(filename) # You can also add parameters such as header, sep, etc.
array = data.values
data
é um tipo dataframe, e usa valores para obter ndarray. Você também pode obter uma lista usando array.tolist()
.
Introduzido em Python 3.4, pathlib
tem um método muito conveniente para ler em texto de arquivos, como se segue:
from pathlib import Path
p = Path('my_text_file')
lines = p.read_text().splitlines()
(a chamada splitlines
é o que a transforma de uma cadeia que contém todo o conteúdo do ficheiro para uma lista de linhas no ficheiro).
pathlib
tem muitas conveniências úteis. read_text
é agradável e conciso, e você não tem que se preocupar em Abrir e fechar o arquivo. Se tudo o que você precisa fazer com o arquivo é ler tudo de uma só vez, é um bom escolha.
Você pode facilmente fazê-lo pelo seguinte pedaço de código:
lines = open(filePath).readlines()
Também podes usar o comando do loadtxt em NumPy. Isto verifica menos Condições do que o genfromtxt, por isso pode ser mais rápido.
import numpy
data = numpy.loadtxt(filename, delimiter="\n")
Versão da linha de comandos
#!/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)
Corre com:
python3 somefile.py input_file_name.txt
contents = []
for line in open(filepath, 'r').readlines():
contents.append(line.strip())
Ou usando a compreensão da lista:
contents = [line.strip() for line in open(filepath, 'r').readlines()]
Resumo
Com um filename
, tratando o ficheiro de um objecto Path(filename)
, ou directamente com open(filename) as f
, faça uma das seguintes operações:
list(fileinput.input(filename))
- usando
with path.open() as f
, liguef.readlines()
list(f)
path.read_text().splitlines()
path.read_text().splitlines(keepends=True)
- iterate over
fileinput.input
orf
andlist.append
each line one at a time - passar
f
para um limitelist.extend
método - utilizar
f
numa compreensão de lista
Eu explico o caso de uso para cada abaixo.
Esta é uma excelente pergunta. Primeiro, vamos criar alguns dados de amostra:Em Python, como é que leio um ficheiro linha a linha?
from pathlib import Path
Path('filename').write_text('foo\nbar\nbaz')
Os objectos de ficheiros são iteradores preguiçosos, por isso, apenas interroga-os.
filename = 'filename'
with open(filename) as f:
for line in f:
line # do something with the line
Em alternativa, se tiver vários ficheiros, use fileinput.input
, outro iterador preguiçoso. Com apenas um arquivo:
import fileinput
for line in fileinput.input(filename):
line # process the line
Ou para vários ficheiros, passa-lhe uma lista de nomes de ficheiros:
for line in fileinput.input([filename]*2):
line # process the line
Novamente, f
e fileinput.input
acima de ambos são / return iteradores preguiçosos.
Você só pode usar um iterador uma vez, então para fornecer o código funcional, evitando a verbosidade eu vou usar o um pouco mais terse fileinput.input(filename)
onde apropos daqui.
Mas queres isso numa lista por alguma razão? Evitaria isso, se possível. Mas se insistes... basta passar o resultado deEm Python, como é que leio um ficheiro linha a linha numa lista?
fileinput.input(filename)
paralist
:
list(fileinput.input(filename))
Outra resposta directa é chamar f.readlines
, que devolve o conteúdo do ficheiro (até um número de caracteres opcional hint
, para que possa dividir isto em várias listas dessa forma).
open
builtin:
filename = 'filename'
with open(filename) as f:
f.readlines()
Ou usando o novo objecto Path do módulo pathlib
(do qual me tornei bastante fÃ, e vou usar a partir daqui):
from pathlib import Path
path = Path(filename)
with path.open() as f:
f.readlines()
list
irá também consumir o iterador de ficheiros e devolver uma lista-um bastante directo método também:
with path.open() as f:
list(f)
Se não se importar de ler o texto inteiro na memória como uma única cadeia de caracteres antes de o dividir, poderá fazê-lo como uma linha única com o objecto Path
e o método splitlines()
da cadeia de caracteres. Por omissão, splitlines
remove as linhas novas:
path.read_text().splitlines()
Se quiser manter as linhas novas, passe.keepends=True
:
path.read_text().splitlines(keepends=True)
Isto é um pouco estúpido de se pedir, dado que ... que demonstrámos facilmente o resultado final com vários métodos. Mas você pode precisar filtrar ou operar nas linhas como você faz sua lista, então vamos satisfazer este pedido.Quero ler o ficheiro linha por linha e adicionar cada linha ao fim da lista.
A utilização de list.append
permitir-lhe-ia filtrar ou operar em cada linha antes de a adicionar:
line_list = []
for line in fileinput.input(filename):
line_list.append(line)
line_list
Usar list.extend
seria um pouco mais directo, e talvez útil se tiver uma lista pré-existente:
line_list = []
line_list.extend(fileinput.input(filename))
line_list
Ou mais idiomaticamente, poderíamos usar uma compreensão da lista, e mapear e filtrar para dentro se desejável:
[line for line in fileinput.input(filename)]
Ou ainda mais directamente, para fechar o círculo, basta passá-lo para listar para criar uma nova lista directamente sem operar nas linhas:
list(fileinput.input(filename))
Conclusão
Você já viu muitas maneiras de obter linhas de um arquivo em uma lista, mas eu recomendo que você evite materializar grandes quantidades de dados em uma lista e em vez disso use a iteração preguiçosa do Python para processar os dados, se possível.
Isto é, preferefileinput.input
ou with path.open() as f
.