Eliminar línea del archivo en Python

Python no incluye una operación integrada para quitar una línea arbitraria de un archivo de texto. Lee las líneas, omite las que quieras eliminar y vuelve a escribir el texto restante. Los ejemplos siguientes usan archivos temporales y son autónomos.

Eliminar líneas por número en un archivo de Python

enumerate() asigna a cada línea un índice que empieza en cero: la primera línea tiene el índice 0. Lee el archivo antes de abrirlo para escritura, ya que el modo w borra su contenido inmediatamente. Si vas a seleccionar varios índices, usa un conjunto; se omite cada línea cuyo índice esté incluido en él.

Ejecuta este ejemplo:

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as directory:
    path = Path(directory) / "notes.txt"
    path.write_text("red\ngreen\nblue\nyellow\n")
    indexes_to_remove = {1, 3}
    lines = path.read_text().splitlines(keepends=True)
    path.write_text("".join(
        line for index, line in enumerate(lines)
        if index not in indexes_to_remove
    ))
    print(path.read_text(), end="")

red
blue

Este ejemplo, que solo usa finales de línea LF, escribe las líneas conservadas con finales LF. Path.read_text() aplica el tratamiento universal de saltos de línea, por lo que convierte la entrada CRLF a \n antes de escribirla. Si un índice está fuera del rango del archivo, no coincide con ninguna línea y no produce ningún efecto. Para archivos grandes, otra opción es procesar las líneas de una en una en un archivo temporal y reemplazar el original cuando ambos archivos estén cerrados.

Método 1

Un administrador de contexto cierra el archivo aunque el bloque termine antes de lo previsto. El patrón de lectura y posterior escritura es sencillo y sirve para cualquier conjunto de índices, pero mantiene todas las líneas en memoria. Para archivos grandes, usa un archivo temporal en el mismo directorio y reemplaza el original cuando la escritura haya terminado correctamente.

Método 2

Si el archivo cabe en memoria, r+ permite leer y escribir con un único identificador. En este caso, newline="" desactiva la traducción de saltos de línea: readlines() conserva cada terminador, incluidos los CRLF, y writelines() los escribe sin cambios. Después de leer, vuelve al inicio con seek() y trunca el contenido anterior antes de escribir las líneas conservadas. Así evitas abrir el archivo original dos veces, pero la actualización no es atómica: un fallo durante la reescritura puede dejar contenido parcial. Tampoco es necesariamente más rápido que el primer patrón.

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as directory:
    path = Path(directory) / "notes.txt"
    path.write_text("red\ngreen\nblue\nyellow\n")
    indexes_to_remove = {1, 3}
    with path.open("r+", newline="") as file:
        lines = file.readlines()
        file.seek(0)
        file.truncate()
        file.writelines(
            line for index, line in enumerate(lines)
            if index not in indexes_to_remove
        )
    print(path.read_text(), end="")

red
blue

Eliminar la primera o la última línea de un archivo de Python

El corte de listas permite quitar una posición y conservar el resto. lines[1:] omite la primera línea; lines[:-1] omite la última. Antes de escribir el resultado del corte, comprueba que la lista contenga líneas; así el mismo código también funciona con un archivo vacío.

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as directory:
    path = Path(directory) / "notes.txt"
    path.write_text("first\nmiddle\nlast\n")
    lines = path.read_text().splitlines(keepends=True)
    without_first = lines[1:]
    path.write_text("".join(without_first))
    lines = path.read_text().splitlines(keepends=True)
    without_last = lines[:-1] if lines else []
    path.write_text("".join(without_last))
    print(path.read_text(), end="")

middle

El ejemplo elimina primero la primera línea y luego elimina la última de las que quedan. Para realizar una sola operación, conserva el corte correspondiente y escribe el resultado una vez. Aplicar un corte a una lista vacía produce otra lista vacía.

Eliminar una línea que coincida con un texto exacto

Compara el contenido de cada línea, sin sus caracteres de fin de línea, con la cadena objetivo. La comparación es exacta y distingue entre mayúsculas y minúsculas: los espacios y los demás caracteres también cuentan. El bucle siguiente elimina todas las líneas que coincidan. El archivo de prueba, que solo usa finales LF, conserva esos finales; Path.read_text() normalizaría la entrada CRLF a \n antes de escribirla.

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as directory:
    path = Path(directory) / "notes.txt"
    path.write_text("keep this\nremove this\nremove this\nkeep that\n")
    target = "remove this"
    lines = path.read_text().splitlines(keepends=True)
    retained = [
        line for line in lines
        if line.rstrip("\r\n") != target
    ]
    path.write_text("".join(retained))
    print(path.read_text(), end="")

keep this
keep that

Usa line.rstrip("\r\n") en vez de strip() cuando los espacios iniciales o finales formen parte del texto que quieres comparar. Si solo quieres eliminar la primera línea coincidente, encuentra su índice y omite únicamente esa posición.

Eliminar líneas que contengan una palabra

Para quitar las líneas que contengan una palabra o subcadena, usa in en vez de comparar la línea completa. Este ejemplo elimina todas las líneas que contienen blue; la búsqueda distingue entre mayúsculas y minúsculas, y también coincide con una línea que contenga bluebird. Un archivo temporal permite conservar intacto el original hasta que el texto filtrado esté listo.

import os
from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as directory:
    path = Path(directory) / "notes.txt"
    temporary_path = Path(directory) / "filtered.txt"
    path.write_text("red\nblue bird\ngreen\nbluebird\n")
    with path.open("r") as source, temporary_path.open("w") as target:
        for line in source:
            if "blue" not in line:
                target.write(line)
    os.replace(temporary_path, path)
    print(path.read_text(), end="")

red
green

Crea el archivo temporal en el mismo directorio que el original para que ambos estén en el mismo sistema de archivos al reemplazarlo. Cierra los dos identificadores antes de llamar a os.replace(). Si las coincidencias de subcadenas son demasiado amplias, usa una condición más específica, como buscar una palabra completa con una expresión regular.

Eliminar la línea más corta de un archivo de Python

Compara la longitud de las líneas después de quitar únicamente los caracteres de fin de línea. min() permite seleccionar un índice sin tener que suponer una longitud máxima. Si varias líneas tienen la longitud mínima, se selecciona la primera; al eliminar por índice, una línea posterior idéntica se conserva. El archivo de prueba, que solo usa finales LF, escribe las líneas conservadas con finales LF; Path.read_text() normaliza la entrada CRLF a \n antes de escribirla. Si el archivo no tiene líneas, no hay nada que eliminar.

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as directory:
    path = Path(directory) / "notes.txt"
    path.write_text("long line\nx\ncat\ny\n")
    lines = path.read_text().splitlines(keepends=True)
    if lines:
        shortest_index = min(
            range(len(lines)),
            key=lambda index: len(lines[index].rstrip("\r\n")),
        )
        del lines[shortest_index]
    path.write_text("".join(lines))
    print(path.read_text(), end="")

long line
cat
y

En este caso, x e y tienen la misma longitud mínima, así que solo se elimina x, que aparece primero. Si no quieres contar las líneas vacías, exclúyelas al elegir el índice y consérvalas en la salida.

Eliminar todas las líneas de un archivo de Python

Al abrir un archivo existente en modo de escritura, su contenido se trunca de inmediato. Usa este modo solo si quieres descartar todo el contenido. Se necesita un identificador de escritura; no se puede truncar un archivo abierto en modo de solo lectura.

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as directory:
    path = Path(directory) / "notes.txt"
    path.write_text("first\nsecond\n")
    with path.open("w"):
        pass
    print(repr(path.read_text()))

''