¿Cómo leer un archivo línea por línea en una lista?

¿Cómo leo cada línea de un archivo en Python y almaceno cada línea como un elemento en una lista?

Quiero leer el archivo línea por línea y agregar cada línea al final de la 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] 

Ver entrada y salida :

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

o quitando el carácter de nueva línea:

with open('filename') as f:
    lines = [line.rstrip() for line in f]

Esto es más explícito de lo necesario, pero hace lo que quiere.

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

Esto producirá una "matriz" de líneas del archivo.

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

opendevuelve un archivo que se puede iterar. Cuando iteras sobre un archivo, obtienes las líneas de ese archivo. tuplepuede tomar un iterador y crear una instancia de tupla para usted desde el iterador que le proporcione. lineses una tupla creada a partir de las líneas del archivo.

Si quieres el \nincluido:

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

Si no quiere \nincluirse:

with open(fname) as f:
    content = f.read().splitlines()

Según los métodos de objetos de archivo de Python , la forma más sencilla de convertir un archivo de texto en un listes:

with open('file.txt') as f:
    my_list = list(f)

Si solo necesita iterar sobre las líneas del archivo de texto, puede usar:

with open('file.txt') as f:
    for line in f:
       ...

Respuesta anterior:

Usando withy readlines():

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

Si no le importa cerrar el archivo, este resumen funciona:

lines = open('file.txt').readlines()

La forma 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

Simplemente puede hacer lo siguiente, como se ha sugerido:

with open('/your/path/file') as f:
    my_lines = f.readlines()

Tenga en cuenta que este enfoque tiene 2 desventajas:

1) Almacena todas las líneas en la memoria. En el caso general, esta es una muy mala idea. El archivo podría ser muy grande y podría quedarse sin memoria. Incluso si no es grande, es simplemente una pérdida de memoria.

2) Esto no permite el procesamiento de cada línea a medida que las lee. Entonces, si procesa sus líneas después de esto, no es eficiente (requiere dos pasadas en lugar de una).

Un mejor enfoque para el caso general sería el siguiente:

with open('/your/path/file') as f:
    for line in f:
        process(line)

Donde define la función de su proceso de la forma que desee. Por ejemplo:

def process(line):
    if 'save the world' in line.lower():
         superman.save_the_world()

(La implementación de la Supermanclase se deja como ejercicio para usted).

Esto funcionará muy bien para cualquier tamaño de archivo y lo revisará en solo 1 paso. Normalmente, así es como funcionan los analizadores genéricos.

Datos en lista

Supongamos que tenemos un archivo de texto con nuestros datos como en las siguientes líneas,

Contenido del archivo de texto:

line 1
line 2
line 3

• Abra el cmd en el mismo directorio (haga clic con el botón derecho del mouse y elija cmd o PowerShell)
• Corre pythony en el intérprete escribe:

El script de 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 agregar:

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

O:

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

O:

>>> x = open("myfile.txt").readlines()
>>> x
['linea 1\n', 'line 2\n', 'line 3\n']

O:

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)

producción:

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 leer un archivo en una lista, debe hacer tres cosas:

• Abre el archivo
• Leer el archivo
• Almacene el contenido como lista

Afortunadamente, Python hace que sea muy fácil hacer estas cosas, por lo que la forma más corta de leer un archivo en una lista es:

lst = list(open(filename))

Sin embargo, agregaré una explicación más.

Abriendo el archivo

Supongo que desea abrir un archivo específico y no trata directamente con un identificador de archivo (o un identificador de archivo). La función más comúnmente utilizada para abrir un archivo en Python es open, toma un argumento obligatorio y dos opcionales en Python 2.7:

• Nombre del archivo
• Modo
• Almacenamiento en búfer (ignoraré este argumento en esta respuesta)

El nombre del archivo debe ser una cadena que represente la ruta al archivo . Por ejemplo:

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)

Tenga en cuenta que es necesario especificar la extensión del archivo. Esto es especialmente importante para los usuarios de Windows porque las extensiones de archivo como .txto .doc, etc. están ocultas de forma predeterminada cuando se ven en el explorador.

El segundo argumento es el mode, es rpor defecto lo que significa "sólo lectura". Eso es exactamente lo que necesita en su caso.

Pero en caso de que realmente desee crear un archivo y / o escribir en un archivo, necesitará un argumento diferente aquí. Existe una excelente respuesta si desea una descripción general .

Para leer un archivo, puede omitir modeo pasarlo explícitamente:

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

Ambos abrirán el archivo en modo de solo lectura. En caso de que desee leer un archivo binario en Windows, debe usar el modo rb:

open(filename, 'rb')

En otras plataformas, el 'b'(modo binario) simplemente se ignora.

Ahora que le he mostrado cómo hacer openel archivo, hablemos del hecho de que siempre lo necesita de closenuevo. De lo contrario, mantendrá un identificador de archivo abierto para el archivo hasta que el proceso salga (o Python elimine el identificador de archivo).

Si bien podrías usar:

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

Eso no cerrará el archivo cuando algo entre openy closearroje una excepción. Puede evitar eso usando un tryy finally:

f = open(filename)
# nothing in between!
try:
    # do stuff with f
finally:
    f.close()

Sin embargo Python proporciona gestores de contexto que tienen una sintaxis más bonita (pero para los openque es casi idéntico al tryy finallyarriba):

with open(filename) as f:
    # do stuff with f
# The file is always closed after the with-scope ends.

¡El último enfoque es el enfoque recomendado para abrir un archivo en Python!

Leyendo el archivo

Bien, has abierto el archivo, ¿cómo leerlo?

La openfunción devuelve un fileobjeto y es compatible con el protocolo de iteración de Pythons. Cada iteración le dará una línea:

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

Esto imprimirá cada línea del archivo. Sin embargo, tenga en cuenta que cada línea contendrá un carácter de nueva línea \nal final (es posible que desee verificar si su Python está construido con soporte universal para nuevas líneas ; de lo contrario, también podría tener \r\nen Windows o \rMac como nuevas líneas). Si no lo desea, puede simplemente eliminar el último carácter (o los dos últimos caracteres en Windows):

with open(filename) as f:
    for line in f:
        print(line[:-1])

Pero la última línea no tiene necesariamente una nueva línea al final, por lo que no se debe usar eso. Se podría comprobar si termina con una nueva línea al final y, de ser así, eliminarlo:

with open(filename) as f:
    for line in f:
        if line.endswith('\n'):
            line = line[:-1]
        print(line)

Pero simplemente puede eliminar todos los espacios en blanco (incluido el \ncarácter) del final de la cadena , esto también eliminará todos los demás espacios en blanco finales, por lo que debe tener cuidado si estos son importantes:

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

Sin embargo, si las líneas terminan con \r\n(Windows "newlines") eso .rstrip()también se encargará del \r!

Almacene el contenido como lista

Ahora que sabe cómo abrir el archivo y leerlo, es hora de almacenar el contenido en una lista. La opción más sencilla sería utilizar la listfunción:

with open(filename) as f:
    lst = list(f)

En caso de que desee eliminar las nuevas líneas finales, puede usar una lista de comprensión en su lugar:

with open(filename) as f:
    lst = [line.rstrip() for line in f]

O incluso más simple: el .readlines()método del fileobjeto por defecto devuelve una listde las líneas:

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

Esto también incluirá los caracteres de nueva línea finales, si no los desea, recomendaría el [line.rstrip() for line in f]enfoque porque evita mantener dos listas que contienen todas las líneas en la memoria.

Hay una opción adicional para obtener el resultado deseado, sin embargo, es bastante "subóptimo": readel archivo completo en una cadena y luego dividir en líneas nuevas:

with open(filename) as f:
    lst = f.read().split('\n')

o:

with open(filename) as f:
    lst = f.read().splitlines()

Estos se encargan de las nuevas líneas finales automáticamente porque el splitpersonaje no está incluido. Sin embargo, no son ideales porque mantiene el archivo como una cadena y como una lista de líneas en la memoria.

Resumen

• Úselo with open(...) as fal abrir archivos porque no necesita encargarse de cerrar el archivo usted mismo y cierra el archivo incluso si ocurre alguna excepción.
• fileLos objetos admiten el protocolo de iteración, por lo que leer un archivo línea por línea es tan simple como for line in the_file_object:.
• Siempre busque en la documentación las funciones / clases disponibles. La mayoría de las veces hay una combinación perfecta para la tarea o al menos una o dos buenas. La elección obvia en este caso sería, readlines()pero si desea procesar las líneas antes de almacenarlas en la lista, le recomendaría una simple lista de comprensión.

Manera limpia y pitónica de leer las líneas de un archivo en una lista

En primer lugar, debe concentrarse en abrir su archivo y leer su contenido de una manera eficiente y pitónica. Aquí hay un ejemplo de la forma en que personalmente NO prefiero:

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.

En cambio, prefiero el método siguiente para abrir archivos tanto para leer como para escribir, ya que es muy limpio y no requiere un paso adicional para cerrar el archivo una vez que haya terminado de usarlo. En la siguiente declaración, abrimos el archivo para leerlo y lo asignamos a la variable 'infile'. Una vez que el código dentro de esta declaración haya terminado de ejecutarse, el archivo se cerrará automáticamente.

# Open the file for reading.
with open('my_file.txt', 'r') as infile:

    data = infile.read()  # Read the contents of the file into memory.

Ahora debemos centrarnos en llevar estos datos a una lista de Python porque son iterables, eficientes y flexibles. En su caso, el objetivo deseado es convertir cada línea del archivo de texto en un elemento separado. Para lograr esto, usaremos el método splitlines () de la siguiente manera:

# Return a list of the lines, breaking at line boundaries.
my_list = data.splitlines()

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

Probando nuestro código:

• Contenido del archivo de texto:

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

• Imprima declaraciones con fines de prueba:

    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]

• Salida (aspecto diferente debido 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ã.

Introducido en Python 3.4, pathlibtiene un método realmente conveniente para leer texto desde archivos, de la siguiente manera:

from pathlib import Path
p = Path('my_text_file')
lines = p.read_text().splitlines()

(La splitlinesllamada es lo que la convierte de una cadena que contiene todo el contenido del archivo a una lista de líneas en el archivo).

pathlibtiene muchas comodidades útiles. read_textes agradable y conciso, y no tiene que preocuparse por abrir y cerrar el archivo. Si todo lo que necesita hacer con el archivo es leerlo todo de una vez, es una buena opción.

Aquí hay una opción más mediante el uso de listas de comprensión en archivos;

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

Esta debería ser una forma más eficiente ya que la mayor parte del trabajo se realiza dentro del intérprete de Python.

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

Ahora, la variable out es una lista (matriz) de lo que desea. Puedes hacer:

for line in out:
    print (line)

O:

for line in f:
    print (line)

Obtendrá los mismos resultados.

Leer y escribir archivos de texto con Python 2 y Python 3; funciona con 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)

Cosas a notar:

• withes un llamado administrador de contexto . Se asegura de que el archivo abierto se vuelva a cerrar.
• Todas las soluciones aquí que simplemente hacen .strip()o .rstrip()no reproducirán el, linesya que también eliminan el espacio en blanco.

Terminaciones de archivos comunes

.txt

Escritura / lectura de archivos más avanzada

• CSV: formato súper simple ( lectura y escritura )
• JSON: bueno para escribir datos legibles por humanos; MUY comúnmente utilizado ( lectura y escritura )
• YAML: YAML es un superconjunto de JSON, pero más fácil de leer ( lectura y escritura , comparación de JSON y YAML )
• pickle: un formato de serialización de Python ( lectura y escritura )
• MessagePack ( paquete Python ): representación más compacta ( lectura y escritura )
• HDF5 ( paquete Python ): bueno para matrices ( lectura y escritura )
• XML: también existe * suspiro * ( leer y escribir )

Para su aplicación, lo siguiente puede ser importante:

• Soporte de otros lenguajes de programación
• Rendimiento de lectura / escritura
• Compacidad (tamaño de archivo)

Ver también: Comparación de formatos de serialización de datos

En caso de que esté buscando una forma de crear archivos de configuración, es posible que desee leer mi artículo corto Archivos de configuración en Python .

Otra opción es numpy.genfromtxt, por ejemplo:

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

Esto creará datauna matriz NumPy con tantas filas como haya en su archivo.

Si desea leer un archivo desde la línea de comandos o desde stdin, también puede usar el fileinputmódulo:

# reader.py
import fileinput

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

fileinput.close()

Pasarle archivos así:

$ python reader.py textfile.txt 

Leer más aquí: http://docs.python.org/2/library/fileinput.html

La forma más sencilla de hacerlo

Una forma sencilla es:

1. Leer el archivo completo como una cadena
2. Dividir la cuerda línea por línea

En una línea, eso daría:

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

Sin embargo, esta es una forma bastante ineficiente ya que almacenará 2 versiones del contenido en la memoria (probablemente no sea un gran problema para archivos pequeños, pero aún así). [Gracias Mark Amery].

Hay 2 formas más sencillas:

1. Usando el archivo como 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')]

1. Si está utilizando Python 3.4 o superior, es mejor utilizarlo pathlibpara crear una ruta para su archivo que pueda usar para otras operaciones en su 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()]

Simplemente use las funciones splitlines (). Aquí hay un ejemplo.

inp = "file.txt"
data = open(inp)
dat = data.read()
lst = dat.splitlines()
print lst
# print(lst) # for python 3

En la salida tendrás la lista de líneas.

Si desea enfrentarse a un archivo muy grande / enorme y desea leer más rápido (imagínese que está en una competencia de codificación Topcoder / Hackerrank), puede leer una porción considerablemente mayor de líneas en un búfer de memoria a la vez, en lugar de simplemente iterar línea por línea a nivel de archivo.

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)

Las formas más fáciles de hacerlo con algunos beneficios adicionales son:

lines = list(open('filename'))

o

lines = tuple(open('filename'))

o

lines = set(open('filename'))

En el caso de set, debemos recordar que no conservamos el orden de las líneas y nos deshacemos de las líneas duplicadas.

A continuación, agregué un suplemento importante de @MarkAmery :

Dado que no está llamando .closeal objeto de archivo ni está usando una withdeclaración, en algunas implementaciones de Python , es posible que el archivo no se cierre después de leerlo y su proceso perderá un identificador de archivo abierto .

En CPython (la implementación normal de Python que la mayoría de la gente usa), esto no es un problema ya que el objeto del archivo se recolectará inmediatamente y esto cerrará el archivo, pero no obstante, generalmente se considera una mejor práctica hacer algo como :

with open('filename') as f: lines = list(f) 

para asegurarse de que el archivo se cierre independientemente de la implementación de Python que esté utilizando.

Utilizar esta:

import pandas as pd
data = pd.read_csv(filename) # You can also add parameters such as header, sep, etc.
array = data.values

dataes un tipo de marco de datos y usa valores para obtener ndarray. También puede obtener una lista utilizando array.tolist().

Esquema y resumen

Con a filename, manejando el archivo desde un Path(filename)objeto, o directamente con open(filename) as f, realice una de las siguientes acciones:

• list(fileinput.input(filename))
• usando with path.open() as f, llamarf.readlines()
• list(f)
• path.read_text().splitlines()
• path.read_text().splitlines(keepends=True)
• iterar sobre fileinput.inputo fy list.appendcada línea una a la vez
• pasar fa un list.extendmétodo enlazado
• usar fen una lista de comprensión

Explico el caso de uso de cada uno a continuación.

En Python, ¿cómo leo un archivo línea por línea?

Esta es una excelente pregunta. Primero, creemos algunos datos de muestra:

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

Los objetos de archivo son iteradores perezosos, así que repita la iteración.

filename = 'filename'
with open(filename) as f:
    for line in f:
        line # do something with the line

Alternativamente, si tiene varios archivos, utilice fileinput.inputotro iterador perezoso. Con solo un archivo:

import fileinput

for line in fileinput.input(filename): 
    line # process the line

o para varios archivos, pásele una lista de nombres de archivo:

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

Nuevamente, fy fileinput.inputarriba, ambos son iteradores perezosos / return. Solo puede usar un iterador una vez, por lo que para proporcionar un código funcional y evitar la verbosidad, usaré un poco más conciso fileinput.input(filename)cuando sea apropiado desde aquí.

En Python, ¿cómo leo un archivo línea por línea en una lista?

Ah, pero ¿lo quieres en una lista por alguna razón? Evitaría eso si fuera posible. Pero si insistes ... pasa el resultado de fileinput.input(filename)a list:

list(fileinput.input(filename))

Otra respuesta directa es llamar f.readlines, que devuelve el contenido del archivo (hasta un hintnúmero opcional de caracteres, por lo que podría dividirlo en varias listas de esa manera).

Puede acceder a este objeto de archivo de dos formas. Una forma es pasar el nombre del archivo a la función openincorporada:

filename = 'filename'

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

o usando el nuevo objeto Path del pathlibmódulo (que me ha gustado bastante y lo usaré a partir de ahora):

from pathlib import Path

path = Path(filename)

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

list también consumirá el iterador de archivos y devolverá una lista, un método bastante directo también:

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

Si no le importa leer todo el texto en la memoria como una sola cadena antes de dividirlo, puede hacerlo como una línea con el Pathobjeto y el splitlines()método de cadena. De forma predeterminada, splitlineselimina las nuevas líneas:

path.read_text().splitlines()

Si desea mantener las nuevas líneas, pase keepends=True:

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

Quiero leer el archivo línea por línea y agregar cada línea al final de la lista.

Ahora bien, esto es un poco tonto de pedir, dado que hemos demostrado el resultado final fácilmente con varios métodos. Pero es posible que deba filtrar u operar en las líneas a medida que hace su lista, así que aceptemos esta solicitud.

El uso list.appendle permitiría filtrar u operar en cada línea antes de agregarla:

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

line_list

El uso list.extendsería un poco más directo y quizás útil si tiene una lista preexistente:

line_list = []
line_list.extend(fileinput.input(filename))
line_list

O más idiomáticamente, podríamos usar una lista de comprensión, y mapear y filtrar dentro de ella si es deseable:

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

O incluso más directamente, para cerrar el círculo, simplemente páselo a la lista para crear una nueva lista directamente sin operar en las líneas:

list(fileinput.input(filename))

Conclusión

Ha visto muchas formas de obtener líneas de un archivo en una lista, pero le recomiendo que evite materializar grandes cantidades de datos en una lista y en su lugar use la iteración perezosa de Python para procesar los datos si es posible.

Es decir, prefiera fileinput.inputo with path.open() as f.

En caso de que también haya líneas vacías en el documento, me gusta leer el contenido y pasarlo filterpara evitar elementos de cadena vacíos

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

También puede usar el comando loadtxt en NumPy. Esto busca menos condiciones que genfromtxt, por lo que puede ser más rápido.

import numpy
data = numpy.loadtxt(filename, delimiter="\n")

Me gusta usar lo siguiente. Leer las líneas de inmediato.

contents = []
for line in open(filepath, 'r').readlines():
    contents.append(line.strip())

O usando la comprensión de listas:

contents = [line.strip() for line in open(filepath, 'r').readlines()]

Probaría uno de los métodos mencionados a continuación. El archivo de ejemplo que utilizo tiene el nombre dummy.txt. Puedes encontrar el archivo aquí . Supongo que el archivo está en el mismo directorio que el código (puede cambiar fpathpara incluir el nombre de archivo y la ruta de la carpeta adecuados).

En los dos ejemplos que se mencionan a continuación, la lista que desea está dada por lst.

1.> Primer 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.> En el segundo método , se puede usar el módulo csv.reader de la biblioteca estándar de Python :

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

Puede utilizar cualquiera de los dos métodos. El tiempo necesario para la creación de lstes casi igual en los dos métodos.

Aquí hay una clase de biblioteca auxiliar de Python (3) que utilizo para simplificar la E / S de archivos:

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

Luego usaría la FileIO.linesfunción, así:

file_ext_lines = FileIO.lines("./path/to/file.ext"):
for i, line in enumerate(file_ext_lines):
  print("Line {}: {}".format(i + 1, line))

Recuerde que los parámetros mode( "r"por defecto) y filter_fn(busca líneas vacías por defecto) son opcionales.

Incluso podría eliminar los métodos read, writey deletey simplemente dejar el FileIO.lines, o incluso convertirlo en un método separado llamado read_lines.

Versión de la línea 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 con:

python3 somefile.py input_file_name.txt