Quelle est la différence entre une liste et un tuple en Python ?

La différence principale est la mutabilité. Une liste est modifiable : on peut ajouter, supprimer ou remplacer des éléments après sa création. Un tuple est immuable : une fois créé, son contenu ne change plus. Les listes s'écrivent avec des crochets [1, 2, 3], les tuples avec des parenthèses (1, 2, 3). Les tuples sont plus légers en mémoire et peuvent servir de clés de dictionnaire, ce que les listes ne peuvent pas faire.

Quand utiliser un tuple plutôt qu'une liste en Python ?

Utilisez un tuple quand les données sont fixes et que chaque position a un sens précis : coordonnées GPS (latitude, longitude), date (année, mois, jour), couleur RGB (rouge, vert, bleu), retour de plusieurs valeurs depuis une fonction. Utilisez une liste quand la collection est amenée à évoluer : ajouter des éléments, trier, filtrer. Le choix communique aussi une intention au lecteur du code.

Peut-on utiliser un tuple comme clé de dictionnaire en Python ?

Oui. Un tuple est hashable (sa valeur ne change jamais), ce qui permet de l'utiliser comme clé de dictionnaire. Par exemple : d = {(48.85, 2.35): "Paris"}. Une liste ne peut pas être clé de dictionnaire car elle est mutable — Python lève une TypeError: unhashable type: 'list'. Pour la même raison, les tuples peuvent être ajoutés dans un set, pas les listes.

Comment créer un tuple à un seul élément en Python ?

Il faut ajouter une virgule après l'élément : mon_tuple = ("valeur",). Sans la virgule, Python interprète les parenthèses comme une simple expression et le résultat est une chaîne, pas un tuple. Vérifiez avec type(mon_tuple). Cette règle s'applique aussi sans parenthèses : valeur, crée aussi un tuple à un élément.

Les tuples sont-ils plus rapides que les listes en Python ?

Légèrement. Les tuples occupent moins de mémoire que les listes de même taille, et leur création est un peu plus rapide car Python peut les optimiser grâce à leur immuabilité. En pratique, la différence est négligeable pour la plupart des programmes. Le choix entre liste et tuple doit se baser sur la sémantique (données fixes ou évolutives), pas sur la performance.

Comment convertir une liste en tuple et inversement en Python ?

Pour convertir une liste en tuple, utilisez tuple(ma_liste). Pour convertir un tuple en liste, utilisez list(mon_tuple). Ces conversions créent un nouvel objet sans modifier l'original. La conversion tuple → liste est utile quand vous avez besoin de modifier temporairement des données immuables : convertissez en liste, modifiez, puis reconvertissez en tuple.

Qu'est-ce que le déballage (unpacking) de tuple en Python ?

Le déballage (unpacking) assigne les éléments d'un tuple à plusieurs variables en une seule ligne. Exemple : x, y = (3.0, 4.0) assigne 3.0 à x et 4.0 à y. C'est aussi ce qui se passe quand une fonction retourne plusieurs valeurs avec return a, b — Python crée un tuple implicitement. Avec l'opérateur *, on peut capturer plusieurs éléments : premier, *reste, dernier = (1, 2, 3, 4, 5).

Liste vs tuple en Python : différences et quand utiliser chacun

OUJOOD.COM

En Python, listes et tuples servent tous les deux à regrouper plusieurs valeurs dans une seule variable. La syntaxe est presque identique — crochets pour la liste, parenthèses pour le tuple. Mais ils ne sont pas interchangeables : leur différence fondamentale est la mutabilité.

Une liste peut être modifiée après sa création : on peut ajouter, supprimer ou remplacer des éléments. Un tuple est immuable : une fois créé, son contenu ne change plus. Ce cours explique ce que ça change en pratique, et comment choisir entre les deux.

Syntaxe de base

📋 Copier le code

# Liste : crochets, modifiable
fruits = ["pomme", "poire", "cerise"]
fruits.append("mangue")
fruits[0] = "abricot"
print(fruits)
# Résultat : ['abricot', 'poire', 'cerise', 'mangue']

# Tuple : parenthèses, non modifiable
coords = (48.85, 2.35)
print(coords[0])
# Résultat : 48.85

# Tentative de modification → erreur
try:
    coords[0] = 0
except TypeError as e:
    print(e)
# Résultat : 'tuple' object does not support item assignment

Différences clés

Caractéristique	Liste	Tuple
Syntaxe	`[1, 2, 3]`	`(1, 2, 3)`
Modifiable	✅ Oui	❌ Non
Utilisable comme clé de dict	❌ Non	✅ Oui
Méthodes disponibles	append, remove, sort…	count, index
Mémoire	Plus lourde	Plus légère
Usage typique	Collection évolutive	Données fixes

Ce que l'immuabilité change concrètement

L'immuabilité d'un tuple a trois conséquences pratiques importantes.

1. Les tuples peuvent servir de clés de dictionnaire

Les clés d'un dictionnaire doivent être hashables — c'est-à-dire que leur valeur ne doit pas changer. Un tuple est hashable, une liste ne l'est pas.

📋 Copier le code

# Tuple comme clé de dictionnaire (coordonnées GPS → ville)
villes = {
    (48.85, 2.35): "Paris",
    (51.50, -0.12): "Londres",
    (40.71, -74.00): "New York"
}
print(villes[(48.85, 2.35)])
# Résultat : Paris

# Une liste ne peut pas être clé de dictionnaire
try:
    d = {[1, 2]: "valeur"}
except TypeError as e:
    print(e)
# Résultat : unhashable type: 'list'

2. Les tuples sont plus légers en mémoire

📋 Copier le code

import sys

liste = [1, 2, 3, 4, 5]
tuple_ = (1, 2, 3, 4, 5)

print(sys.getsizeof(liste))
# Résultat : 120 octets (environ)

print(sys.getsizeof(tuple_))
# Résultat : 80 octets (environ)

3. Les tuples signalent l'intention dans le code

Quand vous utilisez un tuple, vous communiquez à quiconque lit votre code : « Ces valeurs vont ensemble et ne changeront pas. » Un tuple de coordonnées GPS, une date (année, mois, jour), un point en 2D — ce sont des données structurées dont les éléments ont chacun un rôle précis.

📋 Copier le code

# Tuple : données structurées, chaque position a un sens précis
point = (3.0, 4.0)           # x, y
date_naissance = (1990, 6, 15)  # année, mois, jour
couleur_rgb = (255, 128, 0)     # rouge, vert, bleu

# Liste : collection d'éléments similaires, amenée à évoluer
scores = [85, 90, 78, 92]
noms = ["Alice", "Bob", "Claire"]

Déballage (unpacking)

Listes et tuples supportent tous les deux le déballage, mais on le voit le plus souvent avec des tuples — notamment pour retourner plusieurs valeurs depuis une fonction.

📋 Copier le code

# Déballage d'un tuple
point = (3.0, 4.0)
x, y = point
print(f"x = {x}, y = {y}")
# Résultat : x = 3.0, y = 4.0

# Fonction qui retourne plusieurs valeurs (tuple implicite)
def min_max(nombres):
    return min(nombres), max(nombres)

minimum, maximum = min_max([5, 2, 8, 1, 9])
print(f"Min : {minimum}, Max : {maximum}")
# Résultat : Min : 1, Max : 9

# Déballage avec * pour capturer le reste
premier, *reste, dernier = (10, 20, 30, 40, 50)
print(premier, reste, dernier)
# Résultat : 10 [20, 30, 40] 50

Convertir entre liste et tuple

📋 Copier le code

# Liste → tuple (figer les données)
noms = ["Alice", "Bob", "Claire"]
noms_fixes = tuple(noms)
print(noms_fixes)
# Résultat : ('Alice', 'Bob', 'Claire')

# Tuple → liste (pour modifier)
coords = (48.85, 2.35)
coords_liste = list(coords)
coords_liste[0] = 45.75
coords = tuple(coords_liste)
print(coords)
# Résultat : (45.75, 2.35)

Tuple à un seul élément

Attention à la syntaxe : un tuple à un seul élément nécessite une virgule obligatoire. Sans elle, Python interprète les parenthèses comme une simple expression.

📋 Copier le code

# Pas un tuple — juste une chaîne entre parenthèses
pas_un_tuple = ("bonjour")
print(type(pas_un_tuple))
# Résultat : <class 'str'>

# Tuple à un seul élément : virgule obligatoire
vrai_tuple = ("bonjour",)
print(type(vrai_tuple))
# Résultat : <class 'tuple'>

Par carabde | Mis à jour le 21 avril 2026

Cours précédent

Sommaire

Cours suivant