Différence entre liste et tuple Python : la mutabilité
Quelle est la différence entre une liste et un tuple en Python ? En un mot : la mutabilité. Une liste [] est modifiable après sa création ; un tuple () est immuable. À part cela, les deux séquences se ressemblent beaucoup : elles sont ordonnées, indexées depuis zéro, parcourues avec la même syntaxe, et elles acceptent des doublons et des valeurs de types différents.
Cette différence de fond oriente tout le reste : les usages possibles, la mémoire occupée, les méthodes disponibles et même la possibilité d'utiliser la valeur comme clé de dictionnaire. Comprendre « liste vs tuple » en Python, c'est d'abord comprendre ce que la mutabilité implique concrètement dans votre code.
fruits = ["pomme", "poire"]
coordonnees = (48.86, 2.35)
print(len(fruits)) # 2
print(coordonnees[0]) # 48.86
print(type(fruits)) # <class 'list'>
print(type(coordonnees)) # <class 'tuple'>Syntaxe : crochets, parenthèses et virgules
La syntaxe est le premier repère visuel. Une liste s'écrit avec des crochets : [1, 2, 3]. Un tuple s'écrit le plus souvent entre parenthèses : (1, 2, 3). Mais ce sont les virgules qui créent le tuple, pas les parenthèses. Cette nuance devient visible dès qu'un tuple ne contient qu'un seul élément : ('pomme',) est un tuple, ('pomme') est simplement une chaîne entre parenthèses.
Un tuple vide s'écrit () et une liste vide []. On peut aussi créer un tuple à partir d'un itérable avec la fonction tuple(), comme tuple([1, 2, 3]). Python distingue ces deux conteneurs dans le tutoriel officiel, à consulter dans la documentation sur les listes et les tuples.
singleton = ("pomme",)
not_a_tuple = ("pomme")
print(type(singleton)) # <class 'tuple'>
print(type(not_a_tuple)) # <class 'str'>
tuples_vides = ()
via_builtin = tuple([1, 2, 3])
print(via_builtin) # (1, 2, 3)Mutabilité : ce qui change vraiment entre une liste et un tuple
Une liste offre toute la gamme des modifications : ajouter avec append() et extend(), insérer avec insert(), remplacer un élément par affectation à l'index, retirer avec remove() ou pop(), et trier en place avec sort(). C'est l'outil idéal pour une collection qui évolue au fil du programme.
Un tuple n'a aucune de ces méthodes. Toute tentative de modifier un élément existant déclenche une TypeError. En contrepartie, l'immutabilité apporte trois garanties : la taille est connue à la création, la valeur peut servir de clé de dictionnaire, et le tuple peut être partagé sans risque qu'une autre partie du code le modifie par inadvertance.
Attention à une nuance fréquente : un tuple est immuable, mais les objets qu'il contient ne le sont pas forcément. Si un tuple contient une liste, cette liste peut changer — ce qui reste figé, c'est l'emplacement du tuple, pas son contenu profond.
taches = ["relire", "tester"]
taches.append("publier")
taches[0] = "corriger"
taches.sort()
print(taches) # ['corriger', 'publier', 'relire']
coordonnees = (48.86, 2.35)
# coordonnees[0] = 0
# TypeError: 'tuple' object does not support item assignmentcontenu = (["brouillon"], "article")
contenu[0].append("relire")
print(contenu) # (["brouillon", "relire"], "article")Taille mémoire et vitesse : le tuple est-il plus rapide qu'une liste ?
Oui, à conditions égales. Un tuple consomme moins de mémoire qu'une liste de même contenu : sa taille est fixée à la création, tandis qu'une liste pré-alloue de l'espace pour anticiper d'éventuels append(). C'est la raison pour laquelle le tuple est légèrement plus rapide à créer et à parcourir.
Restons honnêtes sur les ordres de grandeur : pour la plupart des scripts, la différence de performance entre liste et tuple est négligeable. Choisissez d'abord le type qui exprime l'intention de votre code ; ne privilégiez un tuple pour la vitesse que sur des boucles chauffées ou des collections de très grande taille — et mesurez, ne devinez pas.
import sys
liste = [1, 2, 3, 4, 5]
tuple_ = (1, 2, 3, 4, 5)
print(sys.getsizeof(liste)) # ex. 120
print(sys.getsizeof(tuple_)) # ex. 88- Un tuple de même contenu pèse moins lourd en mémoire qu'une liste (sys.getsizeof le montre).
- Créer un tuple est plus rapide que construire une liste équivalente, car rien n'est pré-alloué pour la croissance.
- Itérer sur un tuple est légèrement plus rapide, car Python n'a pas à gérer de sur-allocation.
Quand utiliser une liste ou un tuple ?
La règle pratique : si la collection doit changer après sa création, utilisez une liste ; si elle représente un ensemble de valeurs fixe, utilisez un tuple. Un tuple est le bon choix pour un « enregistrement » : une coordonnée (x, y), une dimension (1920, 1080), une ligne d'un tableau, ou des valeurs retournées par une fonction.
Les tuples ont aussi l'avantage de s'écrire sans parenthèses dans l'instruction return, et leur déballage rend la lecture claire. Pour des enregistrements nommés, on monte d'un cran avec namedtuple ou les dataclasses, mais le tuple reste le socle de base à connaître.
def dimensions():
return 1920, 1080
largeur, hauteur = dimensions()
print(largeur, hauteur) # 1920 1080
from collections import namedtuple
Point = namedtuple("Point", ["x", "y"])
origine = Point(0, 0)
print(origine.x, origine.y) # 0 0- Liste : collection qui évolue — résultats, file de tâches, panier, étapes d'un traitement.
- Tuple : enregistrement fixe — coordonnées, dimensions, champs d'une donnée.
- Tuple : plusieurs valeurs retournées par une fonction, déballées à la réception.
- Tuple : clé de dictionnaire ou élément d'un set, car il est hachable.
- Tuple : arguments variables — les *args d'une fonction arrivent sous forme de tuple.
Tuples hachables : clés de dictionnaire et éléments de set
En Python, une clé de dictionnaire ou un élément d'un set doit être hachable. Les tuples faits de valeurs immuables le sont : un tuple de nombres ou de chaînes peut donc servir de clé, par exemple pour indexer des données par coordonnées.
Les listes, elles, ne sont jamais hachables : former une clé de dictionnaire avec une liste lève une TypeError. Même remarque pour les éléments d'un set. C'est une des différences concrètes entre liste et tuple qui oriente le design de vos structures de données.
coordonnees = (48.86, 2.35)
par_ville = {coordonnees: "Paris"}
print(par_ville[coordonnees]) # Paris
positions = {(0, 0), (1, 2)} # tuples hachables
# Une liste n'est pas hachable :
# par_ville[[48.86, 2.35]] = "Paris"
# TypeError: unhashable type: 'list'Conversions, comparaisons et déballage
On passe facilement d'un type à l'autre : tuple(liste) convertit une liste en tuple, et list(tuple) fait l'inverse. Ces conversions sont fréquentes à la frontière d'une API, lorsqu'une fonction exige une séquence immuable en entrée.
Les deux types partagent les opérations de base : slicing, len(), index(), count() et la comparaison élément par élément. Le déballage fonctionne aussi pour les deux : a, b = [5, 6] comme a, b = (5, 6). Toute la référence des séquences est disponible dans la documentation officielle sur le type tuple.
comme_tuple = tuple([1, 2, 3])
comme_liste = list((4, 5))
print(comme_tuple) # (1, 2, 3)
print(comme_liste) # [4, 5]
a, b = (5, 6)
print(a, b) # 5 6
print(sorted((3, 1, 2))) # [1, 2, 3] (sorted retourne une liste)Trois pièges fréquents à éviter
Même un développeur qui connaît les tuples se fait piéger de temps en temps. Voici les trois erreurs les plus fréquentes avec les listes et les tuples.
print(type((42))) # <class 'int'>
print(type((42,))) # <class 'tuple'>
nombres = (1, 2)
# nombres.append(3)
# AttributeError: 'tuple' object has no attribute 'append'- Oublier la virgule du singleton : (42) est un entier, alors que (42,) est un tuple. C'est la virgule qui fait le tuple.
- Croire qu'un tuple rend son contenu immuable : une liste placée dans un tuple reste modifiable.
- Chercher des méthodes de liste sur un tuple : append(), remove() et pop() n'existent pas sur un tuple.
En résumé : comment choisir entre liste et tuple
La règle tient en une phrase : si la collection doit changer après sa création, choisissez une liste ; si elle représente un ensemble de valeurs fixe, choisissez un tuple. Syntaxe, mémoire, hachabilité et méthodes disponibles découlent toutes de cette différence fondamentale entre liste et tuple Python.
Un dernier réflexe utile : préférez la lisibilité à la micro-optimisation, documentez pourquoi vous avez choisi l'immuabilité, et n'hésitez pas à convertir un type en l'autre à la frontière de vos fonctions.
Vous manipulez des structures de données Python au quotidien ? Nos équipes conçoivent des analyses de données sur mesure et automatisent vos traitements répétitifs. Échangeons sur votre projet via notre page contact.
- Liste [] : séquence ordonnée et modifiable, écrite avec des crochets.
- Tuple () : séquence ordonnée et immuable, créée par les virgules.
- Liste : collection dynamique — la laisser évoluer est son métier.
- Tuple : enregistrement fixe, clé de dictionnaire, valeurs retournées.
- Singleton : n'oubliez jamais la virgule finale.
FAQ : liste ou tuple en Python ?
Quelle est la différence entre une liste et un tuple en Python ?
La différence principale est la mutabilité : une liste se modifie (ajout, retrait, remplacement d'éléments), un tuple non. S'y ajoutent des différences de syntaxe (crochets contre virgules) et de mémoire, le tuple étant généralement plus léger à taille égale.
Un tuple est-il plus rapide qu'une liste ?
À taille égale, le tuple est plus rapide à créer et à parcourir, et consomme moins de mémoire. Mais la différence ne devient significative que sur de grandes collections : choisissez le type selon l'intention de votre code, pas selon un gain de vitesse hypothétique.
Peut-on modifier un tuple ?
Non, pas directement : on ne peut ni ajouter, ni retirer, ni remplacer ses éléments, sous peine de TypeError. En revanche, si le tuple contient un objet modifiable, comme une liste, cet objet garde ses propres méthodes de modification.
Comment créer un tuple avec un seul élément ?
En ajoutant une virgule finale : (42,) est un tuple, (42) est un entier. Sans virgule, les parenthèses n'ont aucun effet : c'est bien la virgule qui crée le tuple.
Un tuple peut-il être une clé de dictionnaire ?
Oui, s'il ne contient que des valeurs hachables. Un tuple de nombres ou de chaînes est hachable et peut servir de clé de dictionnaire ou d'élément d'un set. Une liste, jamais.
Quand utiliser un tuple plutôt qu'une liste ?
Utilisez un tuple quand les valeurs représentent un ensemble fixe : coordonnées, dimensions, champs d'un enregistrement, valeurs retournées par une fonction. Utilisez une liste dès qu'une collection doit évoluer : file de tâches, résultats, paniers.
