Supprimer la ligne du fichier en Python

Python ne propose pas d’opération intégrée pour supprimer une ligne quelconque d’un fichier texte. Lisez les lignes, écartez celles que vous souhaitez supprimer, puis réécrivez le texte restant. Les exemples ci-dessous utilisent des fichiers temporaires et sont autonomes.

Supprimer des lignes par leur numéro dans un fichier Python

En Python, enumerate() attribue à chaque ligne un index commençant à zéro : la première ligne a l’index 0. Lisez le fichier avant de l’ouvrir en écriture, car le mode w efface immédiatement son contenu. Pour sélectionner plusieurs index, utilisez un ensemble : toute ligne dont l’index y figure sera écartée.

Exécutez cet exemple :

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

Cet exemple, qui utilise uniquement des fins de ligne LF, écrit les lignes conservées avec des fins de ligne LF. Path.read_text() applique la gestion universelle des fins de ligne : les fins CRLF sont donc converties en \n avant l’écriture. Un index hors de la plage du fichier ne correspond à aucune ligne et n’a aucun effet. Pour les fichiers volumineux, une autre approche consiste à traiter les lignes une par une dans un fichier temporaire, puis à remplacer l’original après avoir fermé les deux fichiers.

Méthode 1

Un gestionnaire de contexte ferme le fichier même si le bloc se termine prématurément. La méthode qui consiste à lire puis à réécrire le fichier est simple et fonctionne avec les index de votre choix, mais elle conserve toutes les lignes en mémoire. Pour les fichiers volumineux, utilisez un fichier temporaire dans le même répertoire et remplacez l’original une fois l’écriture réussie.

Méthode 2

Si le fichier est assez petit pour tenir en mémoire, le mode r+ permet de lire et d’écrire avec un seul descripteur. Ici, newline="" désactive la traduction des fins de ligne : readlines() conserve chaque terminateur, y compris CRLF, et writelines() réécrit les terminateurs conservés sans les modifier. Après la lecture, revenez au début du fichier et tronquez son ancien contenu avant d’écrire les lignes conservées. Cette méthode évite d’ouvrir deux fois le fichier d’origine, mais la mise à jour n’est pas atomique : une erreur pendant la réécriture peut laisser un contenu partiel. Elle n’est pas intrinsèquement plus rapide que la première méthode.

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

Supprimer la première ou la dernière ligne d’un fichier Python

Le découpage d’une liste permet de retirer une position tout en conservant les autres éléments. lines[1:] omet la première ligne ; lines[:-1] omet la dernière. Vérifiez que la liste contient des lignes avant d’écrire le résultat découpé : le même code fonctionnera ainsi aussi avec un fichier vide.

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

L’exemple supprime d’abord la première ligne, puis la dernière parmi celles qui restent. Pour n’effectuer qu’une seule de ces opérations, conservez la tranche correspondante et écrivez-la une seule fois. Découper une liste vide produit une liste vide.

Supprimer une ligne qui correspond à un texte exact

Comparez le contenu de la ligne, sans ses caractères de fin de ligne, à la chaîne cible. La comparaison est exacte et sensible à la casse : les espaces et les autres caractères restent significatifs. La boucle ci-dessous supprime toutes les lignes correspondantes. Le jeu de données de cet exemple utilise uniquement des fins de ligne LF ; Path.read_text() normaliserait les fins CRLF en \n avant l’écriture.

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

Utilisez line.rstrip("\r\n") plutôt que strip() si les espaces au début ou à la fin font partie du texte à comparer. Si vous souhaitez supprimer uniquement la première ligne correspondante, repérez son index et omettez seulement cette position.

Supprimer les lignes qui contiennent un mot

Pour supprimer les lignes contenant un mot ou une sous-chaîne, utilisez le test in au lieu de comparer la ligne entière. Cet exemple supprime chaque ligne contenant blue ; la recherche respecte la casse et une ligne contenant bluebird correspond également. Le fichier temporaire permet de garder l’original intact jusqu’à ce que le texte filtré soit prêt.

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

Créez le fichier temporaire dans le même répertoire que l’original afin que le remplacement se fasse sur le même système de fichiers. Fermez les deux descripteurs avant d’appeler os.replace(). Si les correspondances par sous-chaîne sont trop larges, choisissez une condition plus précise, par exemple la recherche d’un mot entier à l’aide d’une expression régulière.

Supprimer la ligne la plus courte d’un fichier Python

Comparez la longueur des lignes après avoir retiré uniquement leurs caractères de fin de ligne. min() permet de sélectionner un index sans devoir supposer une longueur maximale. Si plusieurs lignes ont la longueur minimale, la première est sélectionnée ; la suppression par index permet de conserver une ligne identique située plus loin. Le jeu de données de cet exemple utilise uniquement des fins de ligne LF et les lignes conservées sont écrites avec des fins LF ; Path.read_text() normalise les fins CRLF en \n avant l’écriture. S’il n’y a aucune ligne, rien ne peut être supprimé.

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

Ici, x et y ont la même longueur minimale : seule x, qui apparaît en premier, est supprimée. Si les lignes vides ne doivent pas être prises en compte, excluez-les lors du choix de l’index, puis conservez-les dans le résultat.

Supprimer toutes les lignes d’un fichier Python

L’ouverture d’un fichier existant en mode écriture le tronque dès son ouverture. N’utilisez cette méthode que si vous souhaitez supprimer tout son contenu. Il faut disposer d’un descripteur ouvert en écriture : il n’est pas possible de tronquer un fichier ouvert en lecture seule.

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

''