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




manipular generar (25)

Si quieres enfrentarte a un archivo muy grande / grande y quieres leer más rápido (imagina que estás en una competencia de codificación Topcoder / Hackerrank), puedes leer un trozo de líneas considerablemente mayor en un búfer de memoria al mismo tiempo, en lugar de solo 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)

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


Que yo sepa, Python no tiene una estructura de datos de matriz nativa. Pero sí admite la estructura de datos de la lista, que es mucho más simple de usar que una matriz.

array = [] #declaring a list with name '**array**'
with open(PATH,'r') as reader :
    for line in reader :
        array.append(line)

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

En primer lugar, debe centrarse en abrir su archivo y leer su contenido de una manera eficiente y pitónica. Aquí hay un ejemplo de la forma en que yo 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 su lugar, prefiero el siguiente método de abrir archivos para leer y escribir, ya que está 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 su lectura 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 reunir 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ã.
  • Imprimir declaraciones para 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 los 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ã.

Para leer un archivo en una lista necesitas hacer tres cosas:

  • Abre el archivo
  • Lee el archivo
  • Almacenar los contenidos 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 voy a añadir alguna 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 similar). La función más utilizada para abrir un archivo en Python es open , toma un argumento obligatorio y dos opcionales en Python 2.7:

  • Nombre del archivo
  • Modo
  • Buffering (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 la extensión del archivo debe ser especificada. Esto es especialmente importante para los usuarios de Windows porque las extensiones de archivo como .txt o .doc , etc. están ocultas por defecto cuando se ven en el explorador.

El segundo argumento es el mode , es r por defecto que significa "solo lectura". Eso es exactamente lo que necesitas en tu caso.

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

Para leer un archivo, puede omitir el mode o pasarlo explícitamente:

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

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

open(filename, 'rb')

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

Ahora que he mostrado cómo open el archivo, hablemos sobre el hecho de que siempre debe close nuevamente. De lo contrario, mantendrá un identificador de archivo abierto en el archivo hasta que el proceso finalice (o Python almacene el identificador de archivo).

Mientras puedas usar:

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

Eso no podrá cerrar el archivo cuando algo entre open y close lanza una excepción. Podrías evitar eso usando un try y finally :

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

Sin embargo, Python proporciona administradores de contexto que tienen una sintaxis más bonita (pero para open es casi idéntico al try y finally arriba):

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, ¿ahora cómo leerlo?

La función open devuelve un objeto de file y admite 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 \n al final (es posible que desee comprobar si su Python está construido con soporte universal para nuevas líneas ; de lo contrario, también podría tener \r\n en Windows o en Mac como nuevas líneas) . Si no quieres, puedes simplemente eliminar el último carácter (o los dos últimos caracteres de Windows):

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

Pero la última línea no necesariamente tiene una nueva línea final, por lo que no se debe usar eso. Uno podría verificar si termina con una nueva línea final y, si es 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 carácter \n ) del final de la cadena , esto también eliminará todos los demás espacios en blanco al final, por lo que debe tener cuidado si 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"), .rstrip() también se encargará de \r !

Almacenar los contenidos 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 simple sería usar la función de list :

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

En caso de que desee eliminar las nuevas líneas finales, podría utilizar 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 método .readlines() del objeto de file de forma predeterminada devuelve una list de las líneas:

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

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

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

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 no se incluye el carácter de split . Sin embargo, no son ideales porque mantienes el archivo como una cadena y como una lista de líneas en la memoria.

Resumen

  • Úselo with open(...) as f al abrir archivos porque no necesita encargarse de cerrar el archivo por sí mismo y lo cierra incluso si ocurre alguna excepción.
  • file objetos de file 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 navegue por la documentación para 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 opción obvia en este caso sería readlines() pero si desea procesar las líneas antes de guardarlas en la lista, le recomendaría una simple lista de comprensión.

Utilizar esta:

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

data es un tipo de marco de data y usa valores para obtener ndarray. También puede obtener una lista usando array.tolist() .


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

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

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

pathlib tiene muchas conveniencias prácticas en él. read_text es 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.


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

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

O usando la lista de comprensión:

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

Versión de línea 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)

Corre con:

python3 somefile.py input_file_name.txt

La forma más sencilla de hacerlo.

Una forma simple es:

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

En una línea, eso daría:

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

Esquema y resumen

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

  • list(fileinput.input(filename))
  • utilizando with path.open() as f , llame a f.readlines()
  • list(f)
  • path.read_text().splitlines()
  • path.read_text().splitlines(keepends=True)
  • iterar sobre fileinput.input o f y list.append cada línea una a la vez
  • pasar f a un método list.extend
  • Usa f en una lista de comprensión

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

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

Esta es una excelente pregunta. Primero, vamos a crear algunos datos de muestra:

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

Los objetos de archivo son iteradores perezosos, así que simplemente iterar sobre ellos.

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

Alternativamente, si tiene varios archivos, use fileinput.input , otro iterador perezoso. Con un solo archivo:

import fileinput

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

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

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

Nuevamente, f y fileinput.input encima de ambos son / devuelven iteradores perezosos. Solo puede usar un iterador una vez, por lo tanto, para proporcionar código funcional y evitar la verbosidad, fileinput.input(filename) poco más conciso de 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? Yo evitaría eso si es posible. Pero si insiste ... simplemente pase el resultado de fileinput.input(filename) a la list :

list(fileinput.input(filename))

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

Puedes llegar a este objeto de archivo de dos maneras. Una forma es pasar el nombre del archivo a la construcción open :

filename = 'filename'

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

o usando el nuevo objeto Path del módulo pathlib (que me ha pathlib bastante, y pathlib de aquí en adelante):

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 hacer esto como una sola línea con el objeto Path y el método de cadena splitlines() . Por defecto, las splitlines eliminan 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 es un poco tonto pedirlo, ya que hemos demostrado el resultado final fácilmente con varios métodos. Pero es posible que necesite filtrar u operar en las líneas a medida que realiza su lista, así que hagamos caso de esta solicitud.

El uso de list.append le 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

Usar list.extend serí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 conveniente:

[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 convertir las 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 utilice la iteración perezosa de Python para procesar los datos, si es posible.

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


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

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

Esto hará que los data una matriz NumPy con tantas filas como estén en su archivo.


Puedes hacerlo fácilmente por el siguiente código:

lines = open(filePath).readlines()

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) Almacenas 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 un desperdicio de memoria.

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

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 definas tu función de proceso como quieras. Por ejemplo:

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

(La implementación de la clase Superman se deja como un ejercicio para usted).

Esto funcionará bien para cualquier tamaño de archivo y usted revisará su archivo en solo 1 paso. Esto es típicamente cómo funcionarán los analizadores genéricos.


Lee y escribe 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 para notar:

  • with es un llamado gestor de contexto . Se asegura de que el archivo abierto se cierre de nuevo.
  • Todas las soluciones aquí que simplemente hacen .strip() o .rstrip() no reproducirán las lines ya que también eliminan el espacio en blanco.

Finales de archivos comunes

.txt

Más archivos avanzados de escritura / lectura

  • CSV: formato super simple ( lectura y escritura )
  • JSON: Agradable para escribir datos legibles por humanos; Muy de uso común ( 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 Python ( lectura y escritura )
  • MessagePack ( paquete de Python ): Representación más compacta ( lectura y escritura )
  • HDF5 ( paquete Python ): agradable para matrices ( lectura y escritura )
  • XML: existe también * suspiro * ( read y write )

Para su aplicación, lo siguiente podría ser importante:

  • Soporte por otros lenguajes de programación.
  • Rendimiento de lectura / escritura
  • Compacidad (tamaño del 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, le recomendamos que lea mi breve artículo Archivos de configuración en Python .


Solo usa las funciones de líneas divididas (). 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.


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

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

Aquí hay una opción más utilizando 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.


Datos en la 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)
  • Ejecutar python y en el intérprete escribir:

El script de Python

>>> with open("myfile.txt", encoding="utf-8") as file:
...     x = [l.strip() for l in file]
>>> x
['line 1','line 2','line 3']

Usando añadir

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

>>> y = [x.rstrip() for x in open("my_file.txt")]
>>> y
['line 1','line 2','line 3']


with open('testodiprova.txt', 'r', encoding='utf-8') as file:
    file = file.read().splitlines()
  print(file)

with open('testodiprova.txt', 'r', encoding='utf-8') as file:
  file = file.readlines()
  print(file)

Ver entrada y salida :

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

o con quitar el carácter de nueva línea:

lines = [line.rstrip('\n') for line in open('filename')]

Nota del editor: el comando original de eliminación de espacios en blanco de esta respuesta, line.strip() , como lo indica el comentario de Janus Troelsen, eliminaría todos los espacios en blanco iniciales y finales , no solo los \n .


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] 

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

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

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

Ahora variable hacia fuera es una lista (matriz) de lo que quieres. Usted podría hacer:

for line in out:
    print line

o

for line in f:
    print line

Obtendrás los mismos resultados.


Una manera realmente fácil:

with open(file) as g:
    stuff = g.readlines()

Si desea convertirlo en un programa completo, escriba esto en:

file = raw_input ("Enter EXACT file name: ")
with open(file) as g:
    stuff = g.readlines()
print (stuff)
exit = raw_input("Press enter when you are done.")

Por alguna razón, no lee los archivos .py correctamente.


Esto debería encapsular el comando de abrir.

array = []
with open("file.txt", "r") as f:
  for line in f:
    array.append(line)

lst1 = [1,2]

lst2 = [3,4]

def list_combinationer(Bushisms, are_funny):

    for item in lst1:
        lst2.append(item)
        lst1n2 = sorted(lst2)
        print lst1n2

list_combinationer(lst1, lst2)

[1,2,3,4]




python string file readlines