Como ler um arquivo linha por linha em uma 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.

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] 

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]

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)

Isso produzirá uma "matriz" de linhas do arquivo.

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

openretorna um arquivo que pode ser iterado. Quando você itera sobre um arquivo, obtém as linhas desse arquivo. tuplepode 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.

Se você deseja \nincluir:

with open(fname) as f:
    content = f.readlines()

Se você não deseja \nincluir:

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 withe 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 Supermanclasse é 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.

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

• Abra o cmd no mesmo diretório (clique com o botão direito do mouse e escolha cmd ou PowerShell)
• Execute pythone, 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']

Para ler um arquivo em uma lista, você precisa fazer três coisas:

• Abra o arquivo
• Leia o arquivo
• Armazene o conteúdo como lista

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.

Abrindo o arquivo

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:

• Nome do arquivo
• Modo
• Buffer (ignorarei esse argumento nesta resposta)

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 .txtou .docetc. estão ocultas por padrão. quando exibidas no explorer.

O segundo argumento é o mode, é rpor 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 modeou 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 openo arquivo, vamos falar sobre o fato de que você sempre precisa closenovamente. 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 opene closelança uma exceção. Você pode evitar isso usando um trye 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 à trye finallyacima):

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!

Lendo o arquivo

Ok, você abriu o arquivo, agora como lê-lo?

A openfunção retorna um fileobjeto 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 \nno 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\nno Windows ou \rno 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 \ncaractere) 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!

Armazene o conteúdo como 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 a listfunçã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 fileobjeto, por padrão, retorna uma listdas 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": reado 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!

Sumário

• Use with open(...) as fao 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: .
• Sempre procure na documentação 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 nesse caso seria, 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:

• Conteúdo do arquivo de texto:

     A fost odatã ca-n povesti,
     A fost ca niciodatã,
     Din rude mãri împãrãtesti,
     O prea frumoasã fatã.

• Imprima instruções para fins de teste:

    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]

• Saída (aparência diferente devido a 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ã.

Introduzido no Python 3.4, pathlibpossui 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 splitlineschamada é o que a transforma de uma sequência que contém todo o conteúdo do arquivo para uma lista de linhas no arquivo).

pathlibtem 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.

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

Agora a variável out é uma lista (matriz) do que você deseja. Você pode fazer:

for line in out:
    print (line)

Ou:

for line in f:
    print (line)

Você obterá os mesmos resultados.

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.
• Todas as soluções aqui que simplesmente produzem .strip()ou .rstrip()deixarão de reproduzir, linescomo também retiram o espaço em branco.

Finais de arquivos comuns

.txt

Gravação / leitura de arquivos mais avançadas

• CSV: formato super simples ( leitura e gravação )
• JSON: Bom para escrever dados legíveis por humanos; MUITO comumente usado ( leitura e gravação )
• YAML: YAML é um superconjunto de JSON, mas mais fácil de ler ( leitura e gravação , comparação de JSON e YAML )
• pickle: um formato de serialização Python ( leitura e gravação )
• MessagePack ( pacote Python ): representação mais compacta ( leitura e gravação )
• HDF5 ( pacote Python ): Agradável para matrizes ( leitura e gravação )
• XML: existe também * suspiro * ( leitura e gravação )

Para seu aplicativo, o seguinte pode ser importante:

• Suporte por outras linguagens de programação
• Desempenho de leitura / escrita
• Compacidade (tamanho do arquivo)

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á datauma 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 fileinputmó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 é:

1. Leia o arquivo inteiro como uma string
2. Divida a linha linha por linha

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:

1. Usando o arquivo como um iterador

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

2. Se você estiver usando o Python 3.4 ou superior, use melhor pathlibpara 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()]

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.

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)

As maneiras mais fáceis de fazer isso com alguns benefícios adicionais são:

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.

Abaixo, adicionei um importante complemento do @MarkAmery :

Como você não está chamando .closeo objeto de arquivo nem está usando uma withinstruçã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.

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

Esboço e Resumo

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))
• usando with path.open() as f, liguef.readlines()
• list(f)
• path.read_text().splitlines()
• path.read_text().splitlines(keepends=True)
• iterar sobre fileinput.inputou felist.append cada uma linha de cada vez
• passar fpara um limitelist.extend método
• usar fem uma compreensão de lista

Eu 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.inputoutro 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, fe fileinput.inputacima, 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 hintnú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 openbuilt-in:

filename = 'filename'

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

ou usando o novo objeto Path do pathlibmó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 Pathobjeto e o splitlines()método string. Por padrão, splitlinesremove 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.appendpermitiria 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.extendseria 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))

Conclusão

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.inputou with path.open() as f.

Caso também existam linhas vazias no documento, gosto de ler o conteúdo e passá-lo filterpara evitar elementos de string vazios

with open(myFile, "r") as f:
    excludeFileContent = list(filter(None, f.read().splitlines()))

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

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 fpathpara 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.

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.linesfunçã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, writee deletemétodos e apenas deixar o FileIO.lines, ou mesmo transformá-lo em um método separado chamado read_lines.

Versão da linha de comando

#!/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)

Correr com:

python3 somefile.py input_file_name.txt