Mettre à jour les tuples en Python

Les tuples Python sont des séquences immuables — une fois créés, leur structure ne peut pas être modifiée. Il est impossible d'ajouter, de supprimer ou de réaffecter des éléments directement. Malgré cela, il est toujours possible de produire un nouveau tuple modifié à partir d'un tuple existant. Cette page présente toutes les techniques pratiques : conversion en liste, concaténation, découpage, remplacement de toutes les occurrences d'une valeur, et bien plus encore. Elle explique également le principal piège à éviter — les objets mutables imbriqués dans un tuple.

Pourquoi les tuples sont immuables

La garantie d'immuabilité de Python est intentionnelle. Les tuples peuvent être utilisés comme clés de dictionnaire ou membres d'un ensemble précisément parce que leur identité ne change jamais. Toute tentative de modification d'un tuple en place lève une TypeError :

Toute tentative d'affectation directe lève une TypeError

t = (1, 2, 3, 4, 5)
t[2] = 6  # TypeError: 'tuple' object does not support item assignment

Chaque technique présentée ci-dessous crée un tout nouveau tuple plutôt que de modifier l'original.

Conversion en liste

L'approche la plus lisible pour des modifications complexes : convertir en liste, effectuer toutes les modifications, puis reconvertir.

Convertir un tuple en liste, le modifier, puis le reconvertir

Résultat :

(1, 2, 6, 4, 5)

Utilisez cette approche lorsque vous devez effectuer plusieurs modifications à la fois — par exemple, trier, filtrer ou appliquer une transformation sur tous les éléments — car les listes prennent en charge toutes les opérations de mutation.

Remplacement d'une valeur par découpage et concaténation

Pour échanger un seul élément, il est possible de découper le tuple autour de l'index cible et de concaténer la nouvelle valeur. Aucune conversion en liste n'est nécessaire.

Remplacer un élément par découpage + concaténation

t = (1, 2, 3, 4, 5)

# Replace the element at index 2 (value 3) with 6
t = t[:2] + (6,) + t[3:]

print(t)

Résultat :

(1, 2, 6, 4, 5)

Le découpage t[:2] donne (1, 2), le littéral (6,) est le remplacement (notez la virgule finale — elle en fait un tuple), et t[3:] donne (4, 5). La concaténation assemble les trois en un nouveau tuple.

Remplacement de toutes les occurrences d'une valeur

Utilisez une expression génératrice dans tuple() pour remplacer chaque occurrence d'une valeur par une autre.

Remplacer toutes les occurrences d'une valeur dans un tuple

t = (1, 2, 2, 3, 2)

# Replace every 2 with 5
t = tuple(5 if x == 2 else x for x in t)

print(t)

Résultat :

(1, 5, 5, 3, 5)

Cette approche est plus concise que la conversion en liste lorsque le seul objectif est une substitution de valeur.

Ajout d'éléments

Ajouter à la fin

Utilisez l'opérateur + pour ajouter des éléments. Le membre de droite doit également être un tuple — d'où la virgule finale dans (4,).

Ajouter un élément à un tuple

t = (1, 2, 3)
t = t + (4,)
print(t)

Résultat :

(1, 2, 3, 4)

Le raccourci d'affectation augmentée += fonctionne de la même manière :

Utiliser += pour étendre un tuple

t = (1, 2, 3)
t += (4, 5)
print(t)

Résultat :

(1, 2, 3, 4, 5)

Remarque : += ne modifie pas l'objet tuple original — Python relie le nom de la variable à un tuple nouvellement créé. Si une autre variable référence toujours l'original, celui-ci reste inchangé.

Ajouter au début

Ajouter un élément au début d'un tuple

t = (1, 2, 3)
t = (0,) + t
print(t)

Résultat :

(0, 1, 2, 3)

Insérer au milieu

Il n'existe pas de méthode insert() directe pour les tuples. Combinez deux découpages autour de la position souhaitée :

Insérer un élément à une position spécifique

t = (1, 2, 4, 5)

# Insert 3 at index 2
t = t[:2] + (3,) + t[2:]

print(t)

Résultat :

(1, 2, 3, 4, 5)

Suppression d'éléments

Supprimer par index

Découpez autour de l'index que vous souhaitez supprimer :

Supprimer l'élément à l'index 2

t = (1, 2, 3, 4, 5)

# Remove the element at index 2 (value 3)
t = t[:2] + t[3:]

print(t)

Résultat :

(1, 2, 4, 5)

Supprimer par valeur

Utilisez une expression génératrice pour filtrer les valeurs correspondantes :

Supprimer toutes les occurrences d'une valeur spécifique

t = ('apple', 'banana', 'cherry', 'banana')

t = tuple(x for x in t if x != 'banana')

print(t)

Résultat :

('apple', 'cherry')

Cela supprime chaque occurrence de la valeur en un seul passage. Si vous souhaitez supprimer uniquement la première occurrence, convertissez en liste, appelez .remove(), puis reconvertissez.

Utilisation du déballage de tuple

Déballer un tuple dans des variables nommées vous permet de le reconstruire avec des positions spécifiques modifiées. C'est particulièrement utile lorsque le tuple est petit et que vous souhaitez renommer les éléments pour plus de clarté.

Reconstruire un tuple par déballage et réaffectation de variables spécifiques

t = (1, 2, 3, 4, 5)
a, b, c, d, e = t

# Replace the third element
t = (a, b, 6, d, e)

print(t)

Résultat :

(1, 2, 6, 4, 5)

Évitez cette approche pour les grands tuples — vous vous retrouvez à écrire une variable par élément, ce qui est verbeux et source d'erreurs.

Piège : objets mutables dans un tuple

L'immuabilité d'un tuple s'applique uniquement aux références qu'il contient, et non aux objets vers lesquels ces références pointent. Si un tuple contient un objet mutable — tel qu'une liste — vous pouvez modifier la liste, et le changement est visible au travers du tuple.

Modification d'une liste imbriquée dans un tuple

t = ([1, 2], [3, 4])

# The tuple itself is immutable, but its elements (lists) are not
t[0].append(5)

print(t)

Résultat :

([1, 2, 5], [3, 4])

Le tuple conserve toujours les mêmes deux références de liste — cette partie est immuable. Mais l'objet liste vers lequel t[0] pointe a été muté. C'est une source de confusion fréquente lorsque les tuples sont utilisés comme clés de dictionnaire ; seuls les tuples entièrement immuables (ne contenant ni listes, ni dictionnaires, ni autres objets mutables) sont hachables.

Choisir la bonne approche

Pour en savoir plus sur l'utilisation des tuples, consultez Accéder aux tuples, Déballer les tuples, Itérer sur les tuples et Méthodes des tuples.

Pratique