Les tuples en Python

En Python, un tuple permet de stocker des collections ordonnées de données, à la différence près qu’un tuple est immuable : on ne peut pas le modifier après sa création (un peu comme un frozenset). C’est un excellent choix quand on souhaite garantir que nos données ne changeront pas.

Qu'est-ce qu'un tuple en Python ?

Un tuple est une structure de données immuable.

Une fois créé, son contenu ne peut pas être modifié : ni les éléments, ni la taille.

Cela le rend plus sûr, notamment dans les cas où l’on veut s’assurer que les données restent constantes (coordonnées, couleurs, paramètres fixes...).

Voici un exemple de tuple :

coordonnees = (48.8566, 2.3522)

Ce tuple contient deux valeurs :

1. latitude ;
2. et longitude.

C’est idéal pour des paires ou groupes de données fixes.

L'immuabilité rend les tuples plus rapides et sécurisés que les listes dans certaines situations.

Créer un tuple

Pour créer un tuple, il y a plusieurs possibilités.

Syntaxe classique avec les parenthèses

La syntaxe classique consiste à utiliser un couple de parenthèses :

couleurs = ("rouge", "vert", "bleu")

Syntaxe moins classique, sans les parenthèses

Il existe aussi une syntaxe qu'on peut retrouver sur internet et dans certains codes source, qui consiste à ne pas mettre de parenthèses :

coord = 1, 2  # équivalent à (1, 2)

Le cas du tuple vide

Voici comment il est possible de créer un tuple vide :

vide = ()

Le cas du tuple avec un seul élément

solo = ("unique",)  # le virgule est obligatoire

Cette syntaxe est très importante : nous devons obligatoirement ajouter une virgule après avoir défini notre élément.

Sans cette virgule, Python comprendrait l'expression comme une valeur qu'on aurait entouré de parenthèses. Cette petite expérience le démontre :

ceci_est_un_tuple = (5,)
print(type(ceci_est_un_tuple)) # Affiche "<class 'tuple'>"

ceci_est_pas_un_tuple = (5)
print(type(ceci_est_pas_un_tuple)) # Affiche "<class 'int'>

Accéder aux éléments d'un tuple

Tout comme les listes, les tuples sont indexables ! Nous pouvons donc accéder à leurs éléments grâce aux index (0, 1, 2, 3, ...).

couleurs = ("rouge", "vert", "bleu")
print(couleurs[0])   # rouge
print(couleurs[-1])  # bleu car on démarre par la fin

On peut aussi les parcourir avec des boucles :

for c in couleurs:
    print(c)

Les tuples supportent aussi le slicing ([debut:fin]) comme les listes.

C'est une technique qui permet d’extraire une sous-partie d’un tuple.

Le premier index est inclus, le second est exclu. Cela permet, par exemple, de récupérer les trois premiers éléments d’un tuple avec mon_tuple[0:3]. On peut aussi utiliser des valeurs négatives (-1, -2, etc.) pour compter à partir de la fin.

PYTHON

valeurs = (10, 20, 30, 40, 50)
print(valeurs[1:4])  # (20, 30, 40)
print(valeurs[:3])   # (10, 20, 30)
print(valeurs[-2:])  # (40, 50)

Le slicing ne modifie jamais le tuple original, mais il retourne une copie de la portion sélectionnée. 😉

Les tuples et l'immuabilité

L'immuabilité est la caractéristique centrale des tuples. Une fois créés, leurs éléments ne peuvent plus être modifiés, supprimés ou réassignés.

Ceci n'est donc pas possible :

couleurs = ("rouge", "vert", "bleu")
couleurs[0] = "jaune" # ❌ TypeError (on ne peut pas réassigner)
del couleurs[1] # ❌ TypeError (on ne peut pas supprimer)

Nous pouvons seulement parcourir, copier ou encore concaténer ses valeurs.

On peut également tester la présence d'un élément avec in :

PYTHON

print("rouge" in couleurs)  # True

C'est justement cette immuabilité qui permet d’utiliser les tuples comme valeurs de référence fiables.

Les avantages des tuples

Les tuples ne sont pas qu’une version "bloquée" des listes. Ils ont des avantages concrets dans certains cas :

• Performance : ils consomment moins de mémoire et sont légèrement plus rapides que les listes ;
• Sécurité : leur immuabilité évite les modifications accidentelles ;
• Utilisables comme clés : contrairement aux listes, les tuples peuvent être hashés, ce qui permet de les utiliser comme clés de dictionnaires ou éléments d’un set ;
• Clarté sémantique : ils indiquent que les valeurs sont fixes et ont un ordre défini (ex. : coordonnées, date, paramètres) ce qui en fait un atout parfait pour des constantes.

Par exemple, il est beaucoup plus intéressant d'avoir un tuple pour stocker des coordonnées géographiques qu'une liste (car les coordonnées sont censées fonctionner ensemble et ne doivent donc pas être modifiés).

coord = (48.85, 2.35)  # Tuple = coordonnées (lat, long)

Les différences entre les tuples et les listes

Bien qu’ils partagent de nombreuses caractéristiques (ordonnés, indexables, itérables), les listes et tuples ont des objectifs bien différents.

Quand utiliser un tuple ? 🥸

Lorsque l'on souhaite garantir l’intégrité des données (pas de modification possible) ou créer des paires/clés fixes dans un dictionnaire.

Utiliser des tuples comme clés de dictionnaire

L’un des grands atouts du tuple est sa capacité à être utilisé comme clé dans un dictionnaire

C'est possible car un tuple est hashable (en tout cas tant qu’il contient uniquement des objets hashables (ex. : int, str, float, etc.)).

Exemple :

etudiants = {
    ("Jean", "Dupont"): 15,
    ("Alice", "Martin"): 18
}

Ici, la clé est un tuple représentant le nom complet de l’étudiant. Cela permet de gérer des paires de données naturellement, sans les concaténer dans une chaîne.

Unpacking et packing de tuples

Le déballage (ou unpacking 🇺🇸) permet d'assigner les valeurs d’un tuple directement à plusieurs variables, en une seule ligne. C’est une manière élégante de rendre le code plus lisible et expressif.

coordonnees = (48.8566, 2.3522)
latitude, longitude = coordonnees

print(latitude)   # 48.8566
print(longitude)  # 2.3522

Dans cet exemple, les deux variables reçoivent respectivement les premier et deuxième éléments du tuple.

Ceci est rendu possible car un tuple ne fait qu'emballer (packing 🇺🇸) plusieurs données dans une seule variable (ce qui crée un tuple).

Le fait d'assigner plusieurs variables à un tuple provoque sont déballage (donc son unpacking 🇺🇸).

Attention cependant à bien respecter le nombre d'éléments dans votre tuple :

PYTHON

a, b, c = (1, 2)  # ❌ ValueError : pas assez de valeurs

Les tuples et l'affectation multiple

L’affectation multiple permet d’initialiser plusieurs variables simultanément à l’aide d’un tuple implicite.

Exemple :

x, y = 5, 10

En réalité, Python convertit cela en :

(x, y) = (5, 10)

C’est aussi la base du swap (l'échange de variables) sans variable temporaire :

a, b = 1, 2
a, b = b, a

Ceci est très utilisé dans les fonctions de tri ou les boucles par exemple ! 😋

Les fonctions utiles avec les tuples

Même si les tuples sont immuables, Python fournit plusieurs fonctions intégrées pour les manipuler, analyser ou transformer.

Voici un petit tableau récapitulatif :

Un petit exemple :

notes = (14, 18, 15)
print(len(notes))   # 3
print(max(notes))   # 18
print(sum(notes))   # 47

Pour parcourir un tuple avec les index, utilisez enumerate() :

PYTHON

for i, val in enumerate(notes):
    print(f"Note {i} : {val}")

Compréhension et génération de tuples

Contrairement aux listes, il n'existe pas de compréhension de tuples ((x for x in iterable) crée en réalité un générateur, pas un tuple).

Pour créer un tuple à partir d’une expression, on utilise souvent une compréhension de liste avec une conversion :

carres = tuple([x ** 2 for x in range(5)])
print(carres)  # (0, 1, 4, 9, 16)

Attention à ne pas comprendre avec ceci :

PYTHON

gen = (x ** 2 for x in range(5))  # Ce n'est PAS un tuple mais un générateur

Pour transformer ce générateur en tuple il faut utiliser la fonction tuple() :

PYTHON

carres = tuple(gen)

Ceci permet de forcer l'évaluation du générateur afin de rendre les valeurs accessibles immédiatement.

Les tuples nommés (namedtuple)

Les namedtuple sont des tuples avec des noms de champs, disponibles dans le module collections.

Ils offrent une lisibilité accrue tout en conservant les avantages d’un tuple comme son immuabilité.

Voici comment les utiliser :

from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])
p = Point(1, 2)

print(p.x)  # 1
print(p.y)  # 2

L'avantage est qu'on peut désormais appeler nos éléments peur leur non à la place de leur index.

Questions fréquentes sur les tuples

Quand on débute avec les tuples (pas que d'ailleurs !) on peut se poser de nombreuses questions... Voici un petit tour des questions les plus fréquentes sur les tuples.

Quelle est la différence entre tuple et liste ?

Un tuple est immuable (non modifiable), une liste est mutable. Le tuple est généralement plus rapide et utilisé pour des données constantes.

Puis-je modifier un élément d’un tuple ?

Non. Une fois créé, un tuple ne peut pas être modifié. C’est l’un de ses principes fondamentaux.

Est-ce qu’un tuple peut contenir d’autres types ?

Oui ! Il peut contenir des entiers, des chaînes, des listes, voire d’autres tuples. Il peut même être vide.

mixte = (1, "Python", [3, 4])

Quelle est la meilleure façon de créer un tuple ?

Pour plusieurs éléments : t = (1, 2, 3).

Pour un seul : t = (1,) (ne pas oublier la virgule !).

Comment apprendre vraiment Python ?

Avec une formation complète sur le sujet !