Como leio todas as linhas de um arquivo no Python e armazeno cada linha como um elemento em uma lista?
Quero ler o arquivo linha por linha e anexar cada linha ao final da lista.
Como leio todas as linhas de um arquivo no Python e armazeno cada linha como um elemento em uma lista?
Quero ler o arquivo linha por linha e anexar cada linha ao final da lista.
Respostas:
with open(filename) 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]
readlines()
não é muito eficiente, pois pode resultar em MemoryError . Nesse caso, é melhor iterar sobre o arquivo usando for line in f:
e trabalhando com cada line
variável.
.rstrip()
funcionará um pouco mais rápido se você estiver removendo os espaços em branco do final das linhas.
with open(filename) as f: content = [i.strip() for i in f.readlines()]
Consulte Entrada e Saída :
with open('filename') as f:
lines = f.readlines()
ou com a remoção do caractere de nova linha:
with open('filename') as f:
lines = [line.rstrip() for line in f]
f.read().splitlines()
, que faz novas linhas remove
for line in open(filename)
segura? Ou seja, o arquivo será fechado automaticamente?
lines = [x.rstrip('\n') for x in open('data\hsf.txt','r')]
Se eu escrever dessa maneira, como posso fechar o arquivo após a leitura?
open
sem o gerenciador de contexto (ou alguma outra maneira garantida de fechá-lo), esse não é realmente um desses casos - quando o objeto não tem mais referências para ele será coletado o lixo e o arquivo será fechado, o que deve ocorrer imediatamente com erro ou não, quando a compreensão da lista for concluída.
Isso é mais explícito do que o necessário, mas faz o que você deseja.
with open("file.txt") as file_in:
lines = []
for line in file_in:
lines.append(line)
array
, mas pode haver outras circunstâncias). Certamente para arquivos grandes, essa abordagem pode atenuar problemas.
Isso produzirá uma "matriz" de linhas do arquivo.
lines = tuple(open(filename, 'r'))
open
retorna um arquivo que pode ser iterado. Quando você itera sobre um arquivo, obtém as linhas desse arquivo. tuple
pode usar um iterador e instanciar uma instância de tupla para você a partir do iterador fornecido. lines
é uma tupla criada a partir das linhas do arquivo.
lines = open(filename).read().split('\n')
vez disso.
lines = open(filename).read().splitlines()
um pouco mais limpo e acredito que ele também lida melhor com as terminações de linha do DOS.
list
ocupa cerca de 13,22% mais espaço que um tuple
. Os resultados vêm from sys import getsizeof as g; i = [None] * 1000; round((g(list(i)) / g(tuple(i)) - 1) * 100, 2)
. Criar um tuple
leva cerca de 4,17% mais tempo do que criar um list
(com um desvio padrão de 0,16%). Os resultados vêm da execução from timeit import timeit as t; round((t('tuple(i)', 'i = [None] * 1000') / t('list(i)', 'i = [None] * 1000') - 1) * 100, 2)
30 vezes. Minha solução favorece o espaço sobre a velocidade quando a necessidade de mutabilidade é desconhecida.
Se você deseja \n
incluir:
with open(fname) as f:
content = f.readlines()
Se você não deseja \n
incluir:
with open(fname) as f:
content = f.read().splitlines()
De acordo com os Métodos de objetos de arquivo do Python , a maneira mais simples de converter um arquivo de texto em um list
é:
with open('file.txt') as f:
my_list = list(f)
Se você apenas precisar percorrer as linhas do arquivo de texto, poderá usar:
with open('file.txt') as f:
for line in f:
...
Resposta antiga:
Usando with
e readlines()
:
with open('file.txt') as f:
lines = f.readlines()
Se você não se importa em fechar o arquivo, esta linha única funciona:
lines = open('file.txt').readlines()
A maneira tradicional :
f = open('file.txt') # Open file on read mode
lines = f.read().split("\n") # Create a list containing all lines
f.close() # Close file
Você pode simplesmente fazer o seguinte, como foi sugerido:
with open('/your/path/file') as f:
my_lines = f.readlines()
Observe que essa abordagem tem duas desvantagens:
1) Você armazena todas as linhas na memória. No caso geral, essa é uma péssima idéia. 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) Isso não permite o processamento de cada linha enquanto você as lê. Portanto, se você processar suas linhas depois disso, não será eficiente (requer duas passagens em vez de uma).
Uma abordagem melhor para o caso geral seria a seguinte:
with open('/your/path/file') as f:
for line in f:
process(line)
Onde você define sua função do processo da maneira que desejar. Por exemplo:
def process(line):
if 'save the world' in line.lower():
superman.save_the_world()
(A implementação da Superman
classe é deixada como um exercício para você).
Isso funcionará bem para qualquer tamanho de arquivo e você o analisará em apenas 1 passagem. Normalmente, é assim que os analisadores genéricos funcionam.
open('file_path', 'r+')
Dados na lista
Suponha que tenhamos um arquivo de texto com nossos dados, como nas linhas a seguir,
Conteúdo do arquivo de texto:
line 1
line 2
line 3
python
e, no intérprete, escreva:O script Python:
>>> with open("myfile.txt", encoding="utf-8") as file:
... x = [l.rstrip("\n") for l in file]
>>> x
['line 1','line 2','line 3']
Usando anexar:
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:
def print_output(lines_in_textfile):
print("lines_in_textfile =", lines_in_textfile)
y = [x.rstrip() for x in open("001.txt")]
print_output(y)
with open('001.txt', 'r', encoding='utf-8') as file:
file = file.read().splitlines()
print_output(file)
with open('001.txt', 'r', encoding='utf-8') as file:
file = [x.rstrip("\n") for x in file]
print_output(file)
resultado:
lines_in_textfile = ['line 1', 'line 2', 'line 3']
lines_in_textfile = ['line 1', 'line 2', 'line 3']
lines_in_textfile = ['line 1', 'line 2', 'line 3']
read().splitlines()
é fornecido pelo Python: é simples readlines()
(o que provavelmente é mais rápido, pois é menos dispendioso).
read().splitlines()
e readlines()
não produz a mesma saída. Tem certeza de que eles são equivalentes?
strip()
deve ser rstrip("\n")
ou espaços em torno de uma linha são excluídos. Além disso, não há sentido em fazer readlines()
uma compreensão de lista: simplesmente iterar sobre o arquivo é melhor, pois não desperdiça tempo e memória criando uma lista intermediária das linhas.
Para ler um arquivo em uma lista, você precisa fazer três coisas:
Felizmente, o Python torna muito fácil fazer essas coisas; portanto, a maneira mais curta de ler um arquivo em uma lista é:
lst = list(open(filename))
No entanto, vou adicionar mais algumas explicações.
Presumo que você deseja abrir um arquivo específico e não lida diretamente com um identificador de arquivo (ou um identificador de arquivo). A função mais usada para abrir um arquivo no Python é o seguinte open
: é necessário um argumento obrigatório e dois opcionais no Python 2.7:
O nome do arquivo deve ser uma sequência que representa o caminho para o arquivo . 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)
Observe que a extensão do arquivo precisa ser especificada. Isso é especialmente importante para usuários do Windows, porque extensões de arquivo como .txt
ou .doc
etc. estão ocultas por padrão. quando exibidas no explorer.
O segundo argumento é o mode
, é r
por padrão o que significa "somente leitura". É exatamente isso que você precisa no seu caso.
Mas caso você realmente queira criar um arquivo e / ou gravar em um arquivo, precisará de um argumento diferente aqui. Existe uma excelente resposta se você quiser uma visão geral .
Para ler um arquivo, você pode omitir mode
ou passá-lo explicitamente:
open(filename)
open(filename, 'r')
Ambos abrirão o arquivo no modo somente leitura. Caso você queira ler um arquivo binário no Windows, use o modo rb
:
open(filename, 'rb')
Em outras plataformas, o 'b'
(modo binário) é simplesmente ignorado.
Agora que mostrei como open
o arquivo, vamos falar sobre o fato de que você sempre precisa close
novamente. Caso contrário, ele manterá um identificador de arquivo aberto até que o processo termine (ou o Python retarda o identificador de arquivo).
Enquanto você pode usar:
f = open(filename)
# ... do stuff with f
f.close()
Isso falhará ao fechar o arquivo quando algo entre open
e close
lança uma exceção. Você pode evitar isso usando um try
e finally
:
f = open(filename)
# nothing in between!
try:
# do stuff with f
finally:
f.close()
No entanto, o Python fornece gerenciadores de contexto com uma sintaxe mais bonita (mas open
é quase idêntica à 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 é a abordagem recomendada para abrir um arquivo no Python!
Ok, você abriu o arquivo, agora como lê-lo?
A open
função retorna um file
objeto e suporta o protocolo de iteração Pythons. Cada iteração fornecerá uma linha:
with open(filename) as f:
for line in f:
print(line)
Isso imprimirá cada linha do arquivo. Observe, no entanto, que cada linha conterá um caractere de nova linha \n
no final (você pode verificar se o seu Python é construído com suporte universal a novas linhas - caso contrário, você também pode ter \r\n
no Windows ou \r
no Mac como novas linhas). Se você não quiser, pode simplesmente remover o último caractere (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 à direita, portanto, não se deve usá-la. Pode-se verificar se termina com uma nova linha à direita 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ê pode simplesmente remover todos os espaços em branco (incluindo o \n
caractere) do final da string , isso também removerá todos os outros espaços em branco à direita, para que você tenha 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
(Windows "newlines"), isso .rstrip()
também cuidará do \r
!
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 a list
função:
with open(filename) as f:
lst = list(f)
Caso deseje remover as novas linhas à direita, use uma compreensão da lista:
with open(filename) as f:
lst = [line.rstrip() for line in f]
Ou ainda mais simples: o .readlines()
método do file
objeto, por padrão, retorna uma list
das linhas:
with open(filename) as f:
lst = f.readlines()
Isso também inclui os caracteres de nova linha à direita. Se você não os quiser, eu recomendaria o [line.rstrip() for line in f]
abordagem, pois evita manter duas listas contendo todas as linhas na memória.
Há uma opção adicional para obter a saída desejada, porém é "subótima": read
o arquivo completo em uma string e depois dividido em novas linhas:
with open(filename) as f:
lst = f.read().split('\n')
ou:
with open(filename) as f:
lst = f.read().splitlines()
Eles cuidam das novas linhas à direita automaticamente porque o split
personagem 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!
with open(...) as f
ao abrir arquivos porque você não precisa fechar o arquivo sozinho e ele fecha o arquivo mesmo que ocorra alguma exceção.file
objetos suportam o protocolo de iteração, portanto, ler um arquivo linha por linha é tão simples quanto for line in the_file_object:
.readlines()
mas se você quiser processar as linhas antes de armazená-las na lista, eu recomendaria uma compreensão simples da lista.Maneira limpa e pitônica de ler as linhas de um arquivo em uma lista
Em primeiro lugar, você deve se concentrar em abrir seu arquivo e ler seu conteúdo de maneira eficiente e pitônica. Aqui está um exemplo da maneira que 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, prefiro o método abaixo de abrir arquivos para leitura e gravação, pois é muito limpo e não requer uma etapa extra para fechar o arquivo quando você terminar de usá-lo. Na declaração abaixo, estamos abrindo o arquivo para leitura e atribuindo-o à variável 'infile'. Depois que o código nesta instrução terminar a execução, 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 lista Python, porque eles são iteráveis, eficientes e flexíveis. No seu caso, o objetivo desejado é trazer cada linha do arquivo de texto para um elemento separado. Para fazer isso, usaremos o método splitlines () da seguinte maneira:
# 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()
Testando nosso código:
A fost odatã ca-n povesti,
A fost ca niciodatã,
Din rude mãri împãrãtesti,
O prea frumoasã fatã.
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]
['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ã.
Introduzido no Python 3.4, pathlib
possui um método realmente conveniente para ler texto de arquivos, da seguinte maneira:
from pathlib import Path
p = Path('my_text_file')
lines = p.read_text().splitlines()
(A splitlines
chamada é o que a transforma de uma sequência que contém todo o conteúdo do arquivo para uma lista de linhas no arquivo).
pathlib
tem muitas conveniências úteis nele. read_text
é agradável e conciso, e você não precisa se preocupar em abrir e fechar o arquivo. Se tudo o que você precisa fazer com o arquivo é ler tudo de uma só vez, é uma boa escolha.
Aqui está mais uma opção usando a compreensão da lista em arquivos;
lines = [line.rstrip() for line in open('file.txt')]
Essa deve ser a maneira mais eficiente, pois a maior parte do trabalho é feita dentro do interpretador Python.
rstrip()
potencialmente retira todo o espaço em branco à direita, não apenas o \n
; use .rstrip('\n')
.
Leia e grave arquivos de texto com Python 2 e Python 3; trabalha com 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 a serem observadas:
with
é o chamado gerenciador de contexto . Ele garante que o arquivo aberto seja fechado novamente..strip()
ou .rstrip()
deixarão de reproduzir, lines
como também retiram o espaço em branco.Finais de arquivos comuns
.txt
Gravação / leitura de arquivos mais avançadas
Para seu aplicativo, o seguinte pode ser importante:
Consulte também: Comparação de formatos de serialização de dados
Caso você esteja procurando uma maneira de criar arquivos de configuração, leia meu pequeno artigo Arquivos de configuração em Python .
Outra opção é numpy.genfromtxt
, por exemplo:
import numpy as np
data = np.genfromtxt("yourfile.dat",delimiter="\n")
Isso criará data
uma matriz NumPy com tantas linhas quanto o seu arquivo.
Se você deseja ler um arquivo na linha de comando ou no stdin, também pode usar o fileinput
módulo:
# reader.py
import fileinput
content = []
for line in fileinput.input():
content.append(line.strip())
fileinput.close()
Passe os arquivos para ele da seguinte maneira:
$ python reader.py textfile.txt
Leia mais aqui: http://docs.python.org/2/library/fileinput.html
A maneira mais simples de fazer isso
Uma maneira simples é:
Em uma linha, isso daria:
lines = open('C:/path/file.txt').read().splitlines()
No entanto, essa é uma maneira bastante ineficiente, pois armazenará 2 versões do conteúdo na memória (provavelmente não é um grande problema para arquivos pequenos, mas ainda assim). [Obrigado Mark Amery].
Existem 2 maneiras mais fáceis:
lines = list(open('C:/path/file.txt'))
# ... or if you want to have a list without EOL characters
lines = [l.rstrip() for l in open('C:/path/file.txt')]
pathlib
para criar um caminho para o seu arquivo que você poderia usar para outras operações no seu programa:from pathlib import Path
file_path = Path("C:/path/file.txt")
lines = file_path.read_text().split_lines()
# ... or ...
lines = [l.rstrip() for l in file_path.open()]
.read().splitlines()
não é "mais simples" do que apenas ligar .readlines()
. Por outro, é ineficiente em memória; você está desnecessariamente armazenando duas versões do conteúdo do arquivo (a única string retornada por .read()
e a lista de strings retornadas por splitlines()
) na memória de uma só vez.
Basta usar 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.
.readlines()
. Isso coloca duas cópias do conteúdo do arquivo na memória de uma só vez (uma como uma única cadeia enorme, uma como uma lista de linhas).
Se você deseja encontrar um arquivo muito grande / grande e deseja ler mais rapidamente (imagine que você esteja em uma competição de codificação Topcoder / Hackerrank), pode ler um pedaço consideravelmente maior de linhas em um buffer de memória ao mesmo tempo, em vez de apenas itere linha por linha no nível do arquivo.
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)
process(line)
é uma função que você precisa implementar para processar os dados. por exemplo, em vez dessa linha, se você usar print(line)
, ela imprimirá cada linha do lines_buffer.
lines = list(open('filename'))
ou
lines = tuple(open('filename'))
ou
lines = set(open('filename'))
No caso de set
, devemos lembrar que não temos a ordem das linhas preservada e nos livramos das linhas duplicadas.
Como você não está chamando
.close
o objeto de arquivo nem está usando umawith
instrução, em algumas implementações do Python, o arquivo pode não ser fechado após a leitura e seu processo vazará um identificador de arquivo aberto .No CPython (a implementação normal do Python usada pela maioria das pessoas), isso não é um problema, já que o objeto do arquivo é imediatamente coletado pelo lixo e isso fecha o arquivo, mas, no entanto, geralmente é considerado uma boa prática fazer algo como :
with open('filename') as f: lines = list(f)
para garantir que o arquivo seja fechado, independentemente da implementação do Python que você está usando.
.close
o objeto de arquivo nem está usando uma with
instrução, em algumas implementações do Python o arquivo pode não ser fechado após a leitura e seu processo vazará um identificador de arquivo aberto. No CPython (a implementação normal do Python usada pela maioria das pessoas), isso não é um problema, já que o objeto do arquivo é imediatamente coletado pelo lixo e isso fecha o arquivo, mas, no entanto, geralmente é considerado uma boa prática fazer algo como with open('filename') as f: lines = list(f)
garantir que o arquivo é fechado independentemente da implementação do Python que você está usando.
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 de quadro de dados e usa valores para obter ndarray. Você também pode obter uma lista usando array.tolist()
.
pandas.read_csv()
é para ler dados CSV , como é apropriado aqui?
Com a filename
, manipulando o arquivo de um Path(filename)
objeto ou diretamente com open(filename) as f
, execute um dos seguintes procedimentos:
list(fileinput.input(filename))
with path.open() as f
, liguef.readlines()
list(f)
path.read_text().splitlines()
path.read_text().splitlines(keepends=True)
fileinput.input
ou f
elist.append
cada uma linha de cada vezf
para um limitelist.extend
métodof
em uma compreensão de listaEu explico o caso de uso de cada um abaixo.
No Python, como leio um arquivo linha por linha?
Esta é uma excelente pergunta. Primeiro, vamos criar alguns dados de exemplo:
from pathlib import Path
Path('filename').write_text('foo\nbar\nbaz')
Os objetos de arquivo são iteradores preguiçosos; portanto, apenas itere sobre ele.
filename = 'filename'
with open(filename) as f:
for line in f:
line # do something with the line
Como alternativa, se você tiver vários arquivos, use fileinput.input
outro iterador lento. Com apenas um arquivo:
import fileinput
for line in fileinput.input(filename):
line # process the line
ou para vários arquivos, passe uma lista de nomes de arquivos:
for line in fileinput.input([filename]*2):
line # process the line
Novamente, f
e fileinput.input
acima, ambos são / retornam iteradores preguiçosos. Você só pode usar um iterador uma vez; portanto, para fornecer código funcional e evitar a verbosidade, usarei o que é um pouco mais conciso fileinput.input(filename)
a partir daqui.
No Python, como leio um arquivo linha por linha em uma lista?
Ah, mas você quer isso em uma lista por algum motivo? Eu evitaria isso, se possível. Mas se você insistir ... basta passar o resultado de fileinput.input(filename)
para list
:
list(fileinput.input(filename))
Outra resposta direta é a chamada f.readlines
, que retorna o conteúdo do arquivo (até um hint
número opcional de caracteres, para que você possa dividi-lo em várias listas dessa maneira).
Você pode acessar esse objeto de arquivo de duas maneiras. Uma maneira é passar o nome do arquivo para o open
built-in:
filename = 'filename'
with open(filename) as f:
f.readlines()
ou usando o novo objeto Path do pathlib
módulo (do qual me apaixonei e utilizarei daqui em diante):
from pathlib import Path
path = Path(filename)
with path.open() as f:
f.readlines()
list
também consumirá o iterador de arquivos e retornará uma lista - um método bastante direto:
with path.open() as f:
list(f)
Se você não se importa de ler o texto inteiro na memória como uma única string antes de dividi-la, faça isso como uma linha com o Path
objeto e o splitlines()
método string. Por padrão, splitlines
remove as novas linhas:
path.read_text().splitlines()
Se você deseja manter as novas linhas, passe keepends=True
:
path.read_text().splitlines(keepends=True)
Quero ler o arquivo linha por linha e anexar cada linha ao final da lista.
Agora, isso é um pouco tolo de pedir, já que demonstramos o resultado final facilmente com vários métodos. Mas pode ser necessário filtrar ou operar nas linhas à medida que você faz sua lista, portanto, vamos aceitar essa solicitação.
O uso list.append
permitiria filtrar ou operar em cada linha antes de anexá-la:
line_list = []
for line in fileinput.input(filename):
line_list.append(line)
line_list
Usar list.extend
seria um pouco mais direto e talvez útil se você tiver uma lista preexistente:
line_list = []
line_list.extend(fileinput.input(filename))
line_list
Ou, mais lingüisticamente, poderíamos usar uma compreensão de lista e mapear e filtrar dentro dela, se desejável:
[line for line in fileinput.input(filename)]
Ou ainda mais diretamente, para fechar o círculo, basta passar para a lista para criar uma nova lista diretamente sem operar nas linhas:
list(fileinput.input(filename))
Você já viu várias maneiras de inserir 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 lenta do Python para processar os dados, se possível.
Ou seja, prefira fileinput.input
ou with path.open() as f
.
Você também pode usar o comando loadtxt no NumPy. Isso verifica menos condições que o genfromtxt, portanto, pode ser mais rápido.
import numpy
data = numpy.loadtxt(filename, delimiter="\n")
Eu gosto de usar o seguinte. Lendo as linhas imediatamente.
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()]
readlines()
, o que gera uma penalidade de memória. Você pode simplesmente removê-lo, pois a iteração sobre um arquivo (texto) fornece cada linha por vez.
with
instrução para abrir (e fechar implicitamente) o arquivo.
Eu tentaria um dos métodos abaixo mencionados. O arquivo de exemplo que eu uso tem o nome dummy.txt
. Você pode encontrar o arquivo aqui . Presumo que o arquivo esteja no mesmo diretório que o código (você pode alterar fpath
para incluir o nome do arquivo e o caminho da pasta adequados).
Nos exemplos abaixo mencionados, a lista que você deseja é fornecida por lst
.
1.> Primeiro método :
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.> No segundo método , pode-se usar o módulo csv.reader da Python Standard Library :
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.']
Você pode usar um dos dois métodos. O tempo necessário para a criação de lst
é quase igual nos dois métodos.
delimiter=' '
argumento?
Aqui está uma classe de biblioteca auxiliar Python (3) que eu uso para simplificar a E / S do arquivo:
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
Você usaria a FileIO.lines
função, assim:
file_ext_lines = FileIO.lines("./path/to/file.ext"):
for i, line in enumerate(file_ext_lines):
print("Line {}: {}".format(i + 1, line))
Lembre-se de que os parâmetros mode
( "r"
por padrão) e filter_fn
(verifica se há linhas vazias por padrão) são opcionais.
Você pode até mesmo remover as read
, write
e delete
métodos e apenas deixar o FileIO.lines
, ou mesmo transformá-lo em um método separado chamado read_lines
.
lines = FileIO.lines(path)
realmente mais simples do with open(path) as f: lines = f.readlines()
que justificar a existência desse ajudante? Você economiza 17 caracteres por chamada. (E na maioria das vezes, por motivos de desempenho e memória, você desejará repetir um objeto de arquivo diretamente, em vez de ler suas linhas em uma lista de qualquer maneira, para que você nem queira usá-lo com frequência!) muitas vezes é fã de criar poucas funções utilitárias, mas essa me parece que está criando desnecessariamente uma nova maneira de escrever algo que já é curto e fácil com a biblioteca padrão.
#!/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)
python3 somefile.py input_file_name.txt
file.readlines()
em umfor
loop, um objeto de arquivo em si é suficiente:lines = [line.rstrip('\n') for line in file]