Ce guide vous éclairera sur les points communs et les différences fondamentales entre les tuples et les listes en Python. Vous saisirez également les situations optimales pour l’utilisation des tuples.
Les listes et les tuples sont des types de données natifs de Python, utilisés pour regrouper des éléments.
Bien que les tuples et les listes partagent des fonctionnalités telles que l’indexation, le découpage et la capacité de contenir des données hétérogènes, il est essentiel de comprendre leurs nuances pour choisir la structure de données appropriée.
Allons-y !
👩🏽💻 Vous pouvez interagir avec Python via un REPL ou utiliser un éditeur Python en ligne comme celui proposé par toptips.fr.
Comparaison Tuple vs Liste en Python : Points Communs
Commençons par explorer les similarités entre les listes et les tuples. Des exemples concrets de chaque type faciliteront la compréhension.
#1. Caractère Itérable en Python
En Python, les listes sont délimitées par des crochets, tandis que les tuples sont encadrés par des parenthèses. Il est également possible de créer un tuple en séparant ses valeurs par des virgules, sans parenthèses.
Ces deux structures de données sont itérables, ce qui permet de les parcourir avec une boucle `for`.
L’extrait de code ci-dessous illustre la manière de parcourir une liste.
nums = [2,6,7,10]
print(f"Type de nums est {type(nums)}")
for num in nums:
print(num)
# Résultat
Type de nums est <class 'list'>
2
6
7
10
Comme le montre l’extrait suivant, un tuple peut aussi être parcouru à l’aide d’une boucle.
nums = (2,6,7,10)
# Note : nums = 2,6,7,10 est aussi une manière valide de créer un tuple. Faites un test si nécessaire !
print(f"Type de nums est {type(nums)}")
for num in nums:
print(num)
# Résultat
Type de nums est <class 'tuple'>
2
6
7
10
#2. Création à Partir de Séquences
Une autre similitude réside dans la capacité des listes et des tuples à être créés à partir de séquences existantes, telles que des chaînes de caractères.
sample_str = "Coder!"
L’extrait de code suivant montre que `list(string)` retourne une liste dont les éléments sont les caractères de la chaîne.
list_from_str = list(sample_str) print(list_from_str) # Résultat ['C', 'o', 'd', 'e', 'r', '!']
De même, un tuple peut être créé à partir d’une chaîne ou d’une autre séquence via `tuple(sequence)`. L’exemple ci-dessous démontre cette possibilité.
tuple_from_str = tuple(sample_str)
print(tuple_from_str)
# Résultat
('C', 'o', 'd', 'e', 'r', '!')
#3. Indexation et Découpage
Python utilise l’indexation de base zéro, où le premier élément a l’index zéro, le second l’index un, et ainsi de suite. L’indexation négative permet d’accéder aux éléments en partant de la fin : le dernier élément a l’index -1, l’avant-dernier -2, etc.
list_from_str = ['C', 'o', 'd', 'e', 'r', '!'] print(list_from_str[1]) # o
L’élément à l’index -2 est l’avant-dernier, soit ‘r’.
tuple_from_str = ('C', 'o', 'd', 'e', 'r', '!')
print(tuple_from_str[-2])
# r
Le découpage permet de travailler avec une partie de la liste ou du tuple. `liste[début:fin]` retourne une portion allant de l’index de début jusqu’à l’index de fin – 1. La valeur par défaut pour `début` est 0, et pour `fin` le dernier élément de l’itérable.
Cette syntaxe s’applique également aux tuples. Voici un exemple de découpage de la liste et du tuple créés précédemment.
list_from_str = ['C', 'o', 'd', 'e', 'r', '!'] print(list_from_str[0:5]) ['C', 'o', 'd', 'e', 'r']
Il est possible de préciser un pas en plus des indices de début et de fin. `tuple(début:fin:pas)` retourne une portion du tuple allant de `début` à `fin`-1, avec un intervalle de `pas`.
tuple_from_str = ('C', 'o', 'd', 'e', 'r', '!')
print(tuple_from_str[::2])
('C', 'd', 'r')
Ici, le pas est de 2, ce qui signifie que la portion inclut un élément sur deux.
#4. Collections Multi-Types
Dans les exemples précédents, tous les éléments des listes et tuples étaient de même type.
Cependant, les listes et les tuples peuvent contenir des valeurs de types différents.
Dans l’extrait ci-dessous, `student_list` contient le nom de l’étudiant sous forme de chaîne, son âge sous forme d’entier et ses notes sous forme de flottant.
student_list = ["Jean",22,96.5]
for item in student_list:
print(f"{item} est de type {type(item)}")
# Résultat
Jean est de type <class 'str'>
22 est de type <class 'int'>
96.5 est de type <class 'float'>
Un exemple similaire avec un tuple :
student_tuple = ("Jeanne",23,99.5)
for item in student_tuple:
print(f"{item} est de type {type(item)}")
# Résultat
Jeanne est de type <class 'str'>
23 est de type <class 'int'>
99.5 est de type <class 'float'>
#5. Tests d’Appartenance
Les listes et les tuples permettent de vérifier si un élément spécifique est présent en utilisant l’opérateur `in`. L’expression `élément in itérable` retourne `True` si l’élément est présent dans l’itérable, `False` sinon.
"Alex" in student_list # False "Jeanne" in student_tuple # True
Vous avez maintenant pris connaissance des similarités entre les listes et les tuples. Penchons-nous maintenant sur les différences clés.
Tuple vs Liste en Python : Les Différences
#1. Mutabilité vs Immutabilité
La différence la plus significative entre les listes et les tuples en Python est que les tuples sont immuables. Cela signifie qu’un tuple ne peut pas être modifié après sa création.
▶️ Voici un exemple :
tuple1 = ("Java","Python","C++")
tuple1[0] = "Rust"
# Résultat
----> 2 tuple1[0] = "Rust"
TypeError: 'tuple' object does not support item assignment
Une liste est mutable, ce qui permet de modifier un élément spécifique à un index donné, comme le montre l’extrait de code suivant :
list1 = ["Java","Python","C++"] list1[0] = "Rust" print(list1) # Résultat ['Rust', 'Python', 'C++']
#2. Longueur Variable vs Longueur Fixe
Les listes en Python ont une longueur variable.
Elles permettent les opérations suivantes :
- Ajouter un élément à la fin
- Ajouter plusieurs éléments à la fin, à partir d’une autre liste
- Supprimer des éléments à des index spécifiques
list1 = [2,3,4,5] # ajouter un élément à la fin list1.append(9) print(list1) # ajouter les éléments de list2 à la fin de list1 list2 = [0,7] list1.extend(list2) print(list1) # supprimer un élément de list1 list1.pop(0) print(list1)
▶️ Sortie de l’extrait ci-dessus :
# Résultat [2, 3, 4, 5, 9] [2, 3, 4, 5, 9, 0, 7] [3, 4, 5, 9, 0, 7]
Les tuples ont une longueur fixe. Il n’est pas possible d’ajouter ou de supprimer des éléments d’un tuple existant. Toutefois, il est possible de redéfinir un tuple avec de nouvelles valeurs.
tuple1 = (2,4,6,8) tuple1 = (1,8,9) print(tuple1) # Résultat (1, 8, 9)
#3. Taille en Mémoire
Comme les listes ont une longueur variable, lorsqu’une liste est créée, une certaine quantité de mémoire lui est allouée. Les opérations comme `append()` et `extend()` peuvent nécessiter l’allocation de mémoire supplémentaire. Cette allocation est généralement supérieure à l’espace nécessaire pour stocker les éléments ajoutés.
Il est donc nécessaire de garder une trace du nombre d’éléments ainsi que de la mémoire allouée à la liste. De plus, un pointeur vers l’adresse des éléments est nécessaire. En conséquence, une liste de longueur *k* utilise plus de mémoire qu’un tuple de *k* éléments.
Voici une illustration simple.
La méthode `getsizeof()` du module `sys` permet de connaître la taille en mémoire d’un objet Python.
import sys
list1 = [4,5,9,14]
list_size = sys.getsizeof(list1)
print(f"Taille de la liste : {list_size}")
tuple1 = (4,5,9,14)
tuple_size = sys.getsizeof(tuple1)
print(f"Taille du tuple : {tuple_size}")
Comme le montre l’exemple ci-dessous, une liste occupe plus de mémoire qu’un tuple contenant les mêmes éléments.
# Résultat Taille de la liste : 104 Taille du tuple : 88
Quand utiliser un tuple en Python ?
Vous comprenez maintenant les similarités et les différences entre les listes et les tuples. Vous savez qu’une liste est la structure de données à privilégier lorsque vous avez besoin d’une collection modifiable.
Mais quand un tuple est-il préférable ?
C’est ce que nous allons explorer dans cette section.
#1. Collection en Lecture Seule
Lorsqu’une collection ne doit pas être modifiée, elle doit être définie comme un tuple. Par exemple, `couleur = (243,55,103)` représente une couleur en format RVB. Définir `couleur` comme tuple empêche toute modification accidentelle.
En résumé, il est préférable d’utiliser un tuple pour une collection qui ne doit pas être altérée pendant l’exécution du programme. Cela permet d’éviter toute modification involontaire des valeurs.
#2. Clés de Dictionnaire
Il est possible de créer un dictionnaire en utilisant les éléments d’une liste comme clés. La méthode `dict.fromkeys()` peut être utilisée à cette fin.
key_list = list("ABCD")
dict.fromkeys(key_list)
{'A': None, 'B': None, 'C': None, 'D': None}
Imaginez maintenant que vous modifiiez la liste et que vous placiez ‘D’ en premier élément (index 0), avant de créer le dictionnaire.
Qu’advient-il de la clé ‘A’ ?
Si vous essayez de créer un dictionnaire à partir de `key_list` et d’accéder à la valeur associée à la clé ‘A’, vous obtiendrez une `KeyError`.
key_list[0] = 'D' dict.fromkeys(key_list)['A'] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-31-c90392acc2cf> in <module>() ----> 1 dict.fromkeys(key_list)['A'] KeyError: 'A'
Les clés d’un dictionnaire doivent être uniques. Un second ‘D’ ne peut donc pas être utilisé comme clé.
dict.fromkeys(key_list)
{'B': None, 'C': None, 'D': None} # A n'est plus une clé.
Si, à la place, vous utilisiez un tuple, cette modification serait impossible et réduirait le risque d’erreurs. Il est donc préférable de créer un dictionnaire en utilisant les éléments d’un tuple comme clés.
key_tuple = tuple("ABCD")
dict.fromkeys(key_tuple)
{'A': None, 'B': None, 'C': None, 'D': None}
key_tuple[0] = 'D'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-2cecbefa7db2> in <module>()
----> 1 key_tuple[0] = 'D'
TypeError: 'tuple' object does not support item assignment
#3. Arguments de Fonction
L’immuabilité des tuples en fait des candidats parfaits pour être utilisés comme arguments de fonction.
Prenons la fonction `calculer_volume()` qui calcule le volume d’un parallélépipède, en fonction de sa longueur, largeur et hauteur :
def calculer_volume(dimensions): l,b,h = dimensions return l*b*h
Supposons que ces dimensions soient stockées dans une liste appelée `dimensions`. L’appel à `calculer_volume()` avec `dimensions` comme argument retourne le volume.
dimensions = [2,8,5] calculer_volume(dimensions) 80
Il est toujours possible de modifier les dimensions stockées dans une liste.
dimensions = [20,8,5] calculer_volume(dimensions) 800
Toutefois, il arrive parfois que les valeurs doivent rester constantes. Dans ce cas, il est préférable de stocker les arguments sous forme de tuple et de les utiliser dans l’appel de fonction.
#4. Valeurs de Retour de Fonction
En Python, les fonctions retournent souvent plusieurs valeurs sous forme de tuples. C’est le comportement par défaut lorsque plusieurs valeurs sont retournées.
Prenons la fonction `retourner_pairs()` :
def retourner_pairs(nombre): pairs = [i for i in range(nombre) if (i%2==0)] return pairs,len(pairs)
- Elle prend un nombre `nombre` en argument.
- Elle retourne la liste des nombres pairs dans l’intervalle [0, nombre), ainsi que la longueur de cette liste.
Définissons la valeur de `nombre` à 20 et appelons la fonction.
nombre = 20
L’appel à `retourner_pairs()` retourne les deux valeurs sous forme de tuple. La fonction `type()` permet de vérifier le type de la valeur de retour.
type(retourner_pairs(nombre)) # <class 'tuple'>
L’affichage de la valeur de retour confirme qu’il s’agit bien d’un tuple contenant la liste des nombres pairs en premier élément et la longueur de cette liste en second élément.
print(retourner_pairs(nombre)) ([0, 2, 4, 6, 8, 10, 12, 14, 16, 18], 10)
Comme le tuple contient deux éléments, il est possible de les décompresser dans deux variables.
pairs, nb_pairs = retourner_pairs(nombre) print(pairs) print(nb_pairs) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 10
Conclusion
J’espère que ce guide vous a permis de comprendre les nuances entre les tuples et les listes en Python.
Résumons les points essentiels :
- Les listes et les tuples sont des types de données natifs de Python.
- Points communs : itérabilité, indexation, découpage, support de données multi-types, et opérateur pour les tests d’appartenance.
- Différence clé : les listes sont modifiables, les tuples sont immuables.
- Autres différences : longueur fixe pour les tuples, variable pour les listes, taille mémoire plus petite pour les tuples.
- Quand utiliser un tuple ? Pour les collections immuables, les clés de dictionnaire et les arguments de fonctions.
Pour aller plus loin, explorez des projets Python pour vous entraîner. Découvrez aussi les méthodes pour supprimer les éléments dupliqués dans une liste. Bon apprentissage et bon codage ! 👩🏽💻