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

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

A abrir o ficheiro

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

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.

Enquanto pode usar:

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

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

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

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

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.

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 como for 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 é:

1. Leia o ficheiro inteiro como um texto
2. 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

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 o lines 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.")

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, ligue f.readlines()
• list(f)
• path.read_text().splitlines()
• path.read_text().splitlines(keepends=True)
• iterate over fileinput.input or f and list.append each line one at a time
• passar f para um limite list.extend método
• utilizar f numa compreensão de lista

Eu explico o caso de uso para cada abaixo.

Em Python, como é que leio um ficheiro linha a linha?

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

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.

Em Python, como é que leio um ficheiro linha a linha numa lista?

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

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

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

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.