HOWTO · Python
Leer un archivo de texto en una lista en Python
Este tutorial muestra cómo leer un archivo de texto en una lista de Python.
En esta página
Para leer un archivo de texto en una lista de Python, primero decide qué debe representar cada elemento: una línea física, un campo delimitado, una fila o un valor numérico. Para texto común, readlines() lee el archivo y va acumulando una cadena por línea en la lista resultante; si existen, conserva los finales de línea. En cambio, read() seguido de splitlines() mantiene en memoria el texto completo del archivo y después crea una lista de cadenas, sin sus finales de línea. Si solo necesitas procesar un archivo grande, recórrelo en lugar de recopilar todas sus líneas.
Los ejemplos siguientes crean sus propios archivos de entrada pequeños, así que puedes adaptarlos sustituyendo la ruta temporal por la de tu archivo. Son ejemplos ilustrativos y no se ejecutaron durante esta etapa de redacción.
Leer líneas con readlines()
readlines() devuelve una lista cuyos elementos son las líneas del archivo. Si hay un final de línea, normalmente se incluye en cada cadena; al mostrar la lista, puede aparecer como \n. El administrador de contexto cierra el archivo después de leer la lista.
Ejecuta este ejemplo:
El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.
from pathlib import Path
from tempfile import TemporaryDirectory
with TemporaryDirectory() as directory:
path = Path(directory) / "notes.txt"
path.write_text("First line\nSecond line\nThird line\n", encoding="utf-8")
with path.open(encoding="utf-8") as file:
lines = file.readlines()
print(lines)
La lista resultante mantiene todas las líneas en memoria, incluidos sus finales de línea. Es práctico para archivos pequeños cuando necesitas conservar cada cadena de línea original. Si solo necesitas procesar un archivo grande, usa el bucle de la sección sobre archivos grandes en lugar de almacenar todas las líneas.
Leer y limpiar líneas con una comprensión de listas
Al recorrer un archivo de texto, se lee una línea cada vez. Una comprensión de listas puede convertir esas líneas en una lista, mientras que rstrip("\r\n") elimina los caracteres de final de línea sin quitar los espacios que formen parte del texto.
El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.
from pathlib import Path
from tempfile import TemporaryDirectory
with TemporaryDirectory() as directory:
path = Path(directory) / "names.txt"
path.write_text(" Ada \nLin\n", encoding="utf-8")
with path.open(encoding="utf-8") as file:
names = [line.rstrip("\r\n") for line in file]
print(names)
strip() es otra opción, pero elimina los espacios en blanco de ambos extremos, incluidos los que sean significativos en una línea. Aunque la comprensión lee la entrada de forma incremental, la lista final sigue guardando todas las cadenas limpias en memoria. Elige este método cuando necesites una lista y el archivo quepa en la memoria disponible.
Leer el archivo completo y dividirlo en líneas
Usa read() seguido de splitlines() cuando necesites el texto completo antes de dividirlo en líneas. splitlines() reconoce los separadores de línea comunes y no conserva esos separadores en las cadenas resultantes.
El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.
from pathlib import Path
from tempfile import TemporaryDirectory
with TemporaryDirectory() as directory:
path = Path(directory) / "poem.txt"
path.write_text("Red\nBlue\nGold\n", encoding="utf-8")
with path.open(encoding="utf-8") as file:
content = file.read()
lines = content.splitlines()
print(lines)
Tanto la cadena completa como la lista resultante ocupan memoria, por lo que este método no es adecuado para entradas muy grandes. Para procesar líneas, una comprensión o un bucle evita crear primero una segunda copia del archivo entero en forma de cadena.
Procesar archivos grandes línea por línea
Cuando cada registro se pueda tratar de forma independiente, procésalo dentro del bucle del archivo y conserva solo el estado que necesite la tarea. Este ejemplo cuenta las líneas que no están en blanco sin guardar el contenido del archivo en una lista.
El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.
from pathlib import Path
from tempfile import TemporaryDirectory
with TemporaryDirectory() as directory:
path = Path(directory) / "events.txt"
path.write_text("login\nview\nlogout\n", encoding="utf-8")
count = 0
with path.open(encoding="utf-8") as file:
for line in file:
if line.strip():
count += 1
print(count)
Así, el uso de memoria se limita a la línea actual y al pequeño contador. Si la tarea requiere específicamente una lista, añade al bucle las cadenas procesadas, pero ten en cuenta que la lista crecerá con el archivo; el bucle por sí solo no hace que recopilar elementos en una lista ahorre memoria. Abrir una ruta inexistente genera FileNotFoundError; indica una ruta correcta o gestiona ese error si la aplicación puede recuperarse de él.
Dividir texto separado por delimitadores con split()
Para un formato sencillo con un delimitador conocido, lee el texto y llama a split() con ese delimitador. El resultado es una lista de cadenas, no de números, y el delimitador se elimina. Este método sirve para texto predecible, como valores separados por dos puntos, pero no procesa el entrecomillado de CSV ni los delimitadores incluidos dentro de campos entrecomillados.
El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.
from pathlib import Path
from tempfile import TemporaryDirectory
with TemporaryDirectory() as directory:
path = Path(directory) / "colors.txt"
path.write_text("red|green|blue", encoding="utf-8")
with path.open(encoding="utf-8") as file:
colors = file.read().split("|")
print(colors)
Los espacios en blanco se conservan, a menos que recortes cada campo explícitamente. Por ejemplo, puedes usar una comprensión de listas con field.strip() si los espacios alrededor de los valores son formato y no datos.
Leer filas delimitadas con csv.reader()
Para datos CSV u otros datos delimitados similares, usa el módulo csv de Python para que los delimitadores entrecomillados y las comillas escapadas se procesen según el formato. csv.reader() produce una lista de cadenas por cada fila. Convierte el iterador en una lista solo si necesitas mantener todas las filas en memoria; también puedes recorrerlo directamente para procesar archivos grandes.
El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.
import csv
from pathlib import Path
from tempfile import TemporaryDirectory
with TemporaryDirectory() as directory:
path = Path(directory) / "people.csv"
path.write_text('name,city\n"Doe, Jane",Paris\nAlex,Rome\n', encoding="utf-8")
with path.open(newline="", encoding="utf-8") as file:
rows = list(csv.reader(file))
print(rows)
Cada fila se mantiene por separado, incluida la cabecera si el archivo tiene una. Si solo necesitas los registros de datos, omite o procesa la cabecera de forma explícita; acceder a la primera fila mediante un índice no permite leer un archivo con varias filas. Al abrir un archivo de texto CSV, usa newline="", como recomienda el módulo CSV.
Cargar datos numéricos con NumPy
Para datos de texto numéricos y rectangulares, loadtxt() de NumPy puede analizar los valores y devolver un array. NumPy es una dependencia adicional. El resultado es un array, no una lista de Python; llama a tolist() si necesitas listas anidadas normales. Este ejemplo supone que el archivo numérico usa delimitadores uniformes y no tiene cabecera.
El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.
from pathlib import Path
from tempfile import TemporaryDirectory
try:
import numpy as np
except ImportError:
print("Install NumPy to run this example.")
else:
with TemporaryDirectory() as directory:
path = Path(directory) / "measurements.csv"
path.write_text("1.5,2.0\n3.5,4.0\n", encoding="utf-8")
values = np.loadtxt(path, delimiter=",")
print(values.tolist())
Usa csv.reader() si las filas pueden tener longitudes distintas, contienen texto o requieren las reglas de entrecomillado de CSV. Elige NumPy cuando los datos sean numéricos y resulten útiles las operaciones con arrays; su analizador y la representación del array son distintos de una lista de cadenas con líneas.