del en Python : supprimer un nom ou un élément

Définition

Un programme accumule des choses dont il n'a plus besoin : une clé de configuration devenue fausse, une variable qui ne doit surtout pas resservir plus bas. Le plus souvent, il suffit de ne plus s'en occuper ; parfois la donnée gêne vraiment, et il faut l'effacer.

del est le mot que Python réserve à ce geste. C'est une instruction, pas une fonction : elle ne prend pas de parenthèses, ne renvoie rien, et ne peut donc jamais se placer à droite d'un signe égal. Ce statut à part a une raison : elle agit sur la cible elle-même, alors qu'une fonction ne reçoit que le contenu d'une variable, jamais l'étiquette qui la désigne.

Selon ce qui le suit, del efface un nom de l'espace courant, un élément d'une liste, une entrée de dictionnaire ou un attribut d'objet. Voici les deux usages les plus fréquents.

stock = {"pommes": 12, "poires": 4}
del stock["poires"]
print(stock)
# {'pommes': 12}

nombres = [10, 20, 30, 40]
del nombres[1]
print(nombres)
# [10, 30, 40]

La collection est modifiée sur place : c'est l'objet d'origine qui a changé, et rien ne revient de l'opération, pas même l'élément retiré.

C'est là que del se sépare de pop et remove, deux méthodes attachées à un type précis. Lui appartient à la grammaire, comme if ou return, et fonctionne à l'identique sur des objets sans rapport.

Supprimer un nom n'est pas supprimer l'objet

Voilà le malentendu qui coûte le plus cher : beaucoup lisent del comme un ordre de destruction, une place rendue en mémoire. Ce n'est pas ce qui se produit.

Une variable n'est pas une boîte qui contient une valeur, c'est une étiquette collée sur un objet. Deux étiquettes peuvent désigner le même objet, ce qui arrive dès qu'une liste est passée à une fonction. Ce que del décolle, c'est l'étiquette.

a = [1, 2, 3]
b = a          # deux noms, un seul objet

del a
print(b)       # [1, 2, 3] : l'objet vit toujours

Le nom a a quitté l'espace courant, et le réutiliser déclenche une NameError. L'objet, lui, se porte bien, puisque b le désigne encore.

Cette instruction gère donc les noms, pas la mémoire. Python compte les références qui pointent vers chaque objet et rend la place quand ce compteur retombe à zéro : effacer la dernière référence libère bien l'objet, mais c'est une conséquence, jamais une promesse.

Ce qu'il efface selon la cible

La même instruction couvre cinq écritures. Ce qui change d'une ligne à l'autre n'est pas l'effet, assez prévisible, mais la façon d'échouer : c'est la colonne à lire en premier quand la cible vient d'un fichier ou du réseau.

La ligne des tranches détonne : une tranche (slicing) ne réclame pas un rang précis mais ce qui se trouve entre deux bornes. Quand cette zone est vide, il n'y a rien à retirer, donc rien à signaler.

Une limite manque au tableau : la cible doit être mutable. Sur un objet immuable, une chaîne ou un tuple, retirer un élément est refusé par un TypeError. Effacer le nom entier reste possible, sans toucher au contenu.

Reste la portée : dans une fonction, effacer une variable définie à l'extérieur suppose de la déclarer global au préalable, faute de quoi Python vise la variable locale du même nom et se plaint qu'elle n'existe pas.

del, pop, remove et clear

Quatre outils retirent des éléments d'une liste, et chacun répond à une demande différente.

Le choix tient à ce que vous comptez faire de l'élément. S'il vous sert encore, pop vous le rend au passage ; sinon, del dit exactement cela, sans laisser croire qu'une valeur est récupérée quelque part.

Sur un dictionnaire, pop accepte en plus une valeur de repli, souvent None, renvoyée quand la clé manque au lieu d'une KeyError : la version indulgente, pour des clés dont l'absence n'a rien d'anormal.

Le piège de la suppression pendant un parcours

Ce dernier point envoie beaucoup de monde chercher de l'aide, et pour une raison précise : le programme ne plante pas, il rend un résultat faux. Retirer des éléments d'une liste pendant qu'on la parcourt décale les rangs sous les pieds de la boucle. Quand l'élément de rang 1 disparaît, l'ancien rang 2 glisse en rang 1, mais la boucle demande le rang 2, et l'élément qui vient de glisser n'est jamais examiné.

nombres = [1, 2, 2, 3]

# Faux : la liste change pendant le parcours
for i, n in enumerate(nombres):
    if n == 2:
        del nombres[i]
# [1, 2, 3] : un 2 a survécu

# Juste : reconstruire plutôt que retirer
nombres = [n for n in nombres if n != 2]

Un 2 a survécu et rien ne l'a signalé. Sur quatre éléments l'anomalie se voit ; sur dix mille lignes, elle part en production et se découvre le jour où un total ne tombe pas juste.

Les dictionnaires sont plus francs : modifier leur taille en cours d'itération lève une exception immédiate au lieu de sauter des entrées en silence. Reconstruire reste de toute façon plus simple à relire qu'un parcours à rebours, l'autre solution classique.

Questions fréquentes

Pas directement. Il retire une référence, et la place n'est rendue que lorsque la dernière disparaît. Sur un objet rangé dans une autre liste, la mémoire reste occupée comme avant et l'objet demeure accessible par son autre nom.

Oui, en séparant les cibles par des virgules : del a, b, stock["poires"] efface les trois. Elles sont traitées de gauche à droite, et c'est là qu'il faut être prudent. Si la deuxième échoue, la première est déjà partie et la troisième ne sera jamais atteinte.

Rarement. Les variables locales disparaissent d'elles-mêmes à la sortie de la fonction, et un usage systématique alourdit la lecture. Deux cas le justifient : un très gros objet qu'on veut cesser de retenir pendant un traitement long, et un nom réutilisé plus bas dont on veut interdire la relecture par erreur.