Python Tuple vs List : Similitudes et différences, expliquées

Dans ce guide, vous apprendrez les similitudes et les différences entre les tuples Python et les listes . Vous comprendrez également quand vous devez utiliser un tuple.

La liste et les tuples sont tous deux des structures de données intégrées à Python. Ils peuvent être utilisés pour stocker une collection d'éléments.

De la prise en charge de l'indexation et du découpage au contenu de types de données hétérogènes, les tuples et les listes peuvent sembler avoir des fonctionnalités similaires. Par conséquent, comprendre les similitudes et les différences entre les deux peut vous aider à décider de la structure de données à utiliser.

Commençons.

Vous pouvez démarrer un Python REPL et suivre ce tutoriel. Vous pouvez également utiliser l'éditeur Python en ligne de Geekflare pour coder.

Python Tuple vs List : quelles sont les similitudes ?

Commençons par apprendre les similitudes entre les listes et les tuples. Pour faciliter un meilleur apprentissage, nous présentons des exemples de listes et de tuples.

#1 . Itérables Python

En Python, les listes sont entourées d'une paire de crochets, tandis que les tuples sont entre parenthèses. Vous pouvez également créer un tuple sous la forme d'un ensemble de valeurs séparées par des virgules, sans les parenthèses.

Ils sont tous deux itérables ; vous pouvez donc les parcourir en boucle à l'aide d'une boucle for .

La cellule de code ci-dessous montre comment parcourir une liste.

 nums = [2,6,7,10] print(f"Type of nums is {type(nums)}") for num in nums: print(num) # Output Type of nums is <class 'list'> 2 6 7 10

Comme expliqué ci-dessous, vous pouvez également parcourir un tuple en utilisant une boucle

 nums = (2,6,7,10) # Note: nums = 2,6,7,10 is a valid tuple as well. If needed, run a quick check! print(f"Type of nums is {type(nums)}") for num in nums: print(num) # Output Type of nums is <class 'tuple'> 2 6 7 10

#2 . Prise en charge de la création à partir d'autres séquences

La similitude suivante entre les listes et les tuples est qu'elles peuvent être créées à partir de séquences existantes telles que des chaînes.

 sample_str = "Coding!"

La cellule de code suivante montre comment list(string) renvoie une liste, dont les éléments de liste sont les caractères de la chaîne.

 list_from_str = list(sample_str) print(list_from_str) # Output ['C', 'o', 'd', 'i', 'n', 'g', '!']

De même, un tuple peut être créé à partir d'une chaîne ou d'une autre séquence en utilisant tuple(sequence) . La cellule de code ci-dessous montre comment vous pouvez le faire.

 tuple_from_str = tuple(sample_str) print(tuple_from_str) # Output ('C', 'o', 'd', 'i', 'n', 'g', '!')

#3 . Prise en charge de l'indexation et du découpage

Python prend en charge l'indexation zéro dans laquelle le premier élément est à l'index zéro, le second à l'index un, et ainsi de suite. Python prend également en charge l'indexation négative, où le dernier élément est à l'index -1, l'avant-dernier élément est à l'index -2, etc.

 list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[1]) # o

L'élément à l'index -2 est l'avant-dernier élément, 'g'.

 tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!') print(tuple_from_str[-2]) # g

Vous pouvez utiliser le découpage lorsque vous souhaitez travailler avec une petite section de la liste ou du tuple. list[start:end] renvoie une tranche de la liste commençant au début de l'index et s'étendant jusqu'à la fin - 1. La valeur par défaut pour un début est 0, et la fin est le dernier élément de l'itérable.

Vous pouvez découper des tuples en utilisant la même syntaxe. Créons des tranches de la liste et du tuple que nous avons créés précédemment.

 list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[0:5]) ['C', 'o', 'd', 'i', 'n']

Outre les valeurs de début et de fin, vous pouvez également spécifier une valeur de pas. tuple(start:end:step) renvoie une tranche du tuple du start à la end - 1 , par étapes de step .

 tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!') print(tuple_from_str[::2]) ('C', 'd', 'n', '!')

Ici, nous définissons la valeur de pas sur 2. Ainsi, la tranche contient un élément sur deux.

#4 . Collections de plusieurs types de données

Dans les exemples que nous avons examinés, tous les éléments de la liste et les tuples étaient du même type de données.

Cependant, vous pouvez stocker des valeurs de différents types de données dans une seule liste ou un tuple.

L'extrait de code sous student_list contient le nom d'un étudiant sous forme de chaîne, son âge sous forme d'entier et les notes sécurisées sous forme de nombre flottant.

 student_list = ["John",22,96.5] for item in student_list: print(f"{item} is of type {type(item)}") # Output John is of type <class 'str'> 22 is of type <class 'int'> 96.5 is of type <class 'float'>

Nous pouvons trouver un exemple similaire pour un tuple.

 student_tuple = ("Jane",23,99.5) for item in student_tuple: print(f"{item} is of type {type(item)}") # Output Jane is of type <class 'str'> 23 is of type <class 'int'> 99.5 is of type <class 'float'>

#5 . Prise en charge des tests d'adhésion

Les listes et les tuples vous permettent d'effectuer des tests d'appartenance pour la présence de certains éléments. Si vous souhaitez vérifier si un élément spécifique est présent dans une liste ou un tuple, vous pouvez utiliser l'opérateur in .

L' item in iterable est évalué à True si l' iterable contient l' item ; sinon, False .

 "Alex" in student_list # False "Jane" in student_tuple # True

Jusqu'à présent, vous avez appris les similitudes entre les listes et les tuples en Python. Ensuite, apprenons les principales différences entre les deux structures de données.

Python Tuple vs List : quelles sont les différences ?

#1 . Mutabilité des listes et immuabilité des tuples en Python

La différence la plus cruciale entre une liste et un tuple en Python est qu'un tuple est immuable . Cela signifie que vous ne pouvez pas modifier un tuple en place.

️ Voici un exemple.

 tuple1 = ("Java","Python","C++") tuple1[0] = "Rust" # Output ----> 2 tuple1[0] = "Rust" TypeError: 'tuple' object does not support item assignment

Une liste est une structure de données modifiable, nous pouvons donc modifier la liste en modifiant un élément à un index spécifique, comme dans la cellule de code suivante.

 list1 = ["Java","Python","C++"] list1[0] = "Rust" print(list1) # Output ['Rust', 'Python', 'C++']

#2 . Listes de longueur variable vs tuples de longueur fixe

La liste Python est une structure de données de longueur variable.

Vous pouvez effectuer les opérations suivantes :

• Ajouter un élément à la fin de la liste
• Ajouter des éléments d'une autre liste à la fin de la liste actuelle
• Supprimer les éléments d'un index spécifique de la liste

 list1 = [2,3,4,5] # add an item to the end list1.append(9) print(list1) # add items from list2 to the end of list1 list2 = [0,7] list1.extend(list2) print(list1) # remove an item from list1 list1.pop(0) print(list1)

️ La sortie de l'extrait de code ci-dessus.

 # Output [2, 3, 4, 5, 9] [2, 3, 4, 5, 9, 0, 7] [3, 4, 5, 9, 0, 7]

Les tuples sont des structures de données de longueur fixe. Vous ne pouvez donc pas ajouter ou supprimer des éléments d'un tuple existant. Mais vous pouvez redéfinir le tuple pour qu'il contienne différents éléments.

 tuple1 = (2,4,6,8) tuple1 = (1,8,9) print(tuple1) # Output (1, 8, 9)

#3 . Taille en mémoire

Nous allons maintenant nous appuyer sur ce que nous avons appris dans la section précédente : la liste est une structure de données de longueur variable .

Lorsque vous définissez initialement la liste, une taille spécifique lui est allouée en mémoire. Désormais, lorsque vous modifiez une liste à l'aide des méthodes append() ou extend() , de la mémoire supplémentaire doit être allouée pour stocker les éléments ajoutés. Cette allocation est presque toujours effectuée plus que le nombre d'éléments que vous ajoutez.

Il est donc nécessaire de garder une trace du nombre d'éléments sur la liste et de l'espace alloué. De plus, comme les listes sont de longueur variable, il y a un pointeur qui pointe vers l'adresse des éléments de la liste. Par conséquent, les listes de longueur k occupent plus de mémoire qu'un tuple avec les mêmes k éléments.

Voici une illustration simple.

Vous pouvez utiliser la méthode getsizeof() du module sys intégré sur un objet Python pour obtenir la taille d'un objet en mémoire.

 import sys list1 = [4,5,9,14] list_size = sys.getsizeof(list1) print(f"Size of list:{list_size}") tuple1 = (4,5,9,14) tuple_size = sys.getsizeof(tuple1) print(f"Size of tuple:{tuple_size}")

Une liste occupe plus de mémoire qu'un tuple pour le même nombre et la même valeur d'éléments, comme vérifié dans la sortie ci-dessous.

 # Output Size of list:104 Size of tuple:88

Quand devriez-vous utiliser un tuple Python ?

D'après les différences et les similitudes entre les listes Python et les tuples, vous savez que si vous avez besoin d'une collection mutable , vous devez utiliser un list .

Mais quand devriez-vous utiliser un tuple à la place ?

Nous y reviendrons dans cette section.

#1 . Collection en lecture seule

Chaque fois que vous voulez qu'une collection soit immuable, vous devez la définir comme un tuple. Supposons que color = (243,55,103) un tuple contenant les valeurs RVB correspondant à une nuance de couleur. Définir la couleur comme un tuple garantit qu'elle ne peut pas être modifiée.

Essentiellement, lorsque vous avez besoin qu'une collection soit en lecture seule : les valeurs ne doivent pas être modifiées pendant le programme, vous devez envisager d'utiliser un tuple. Cela empêchera la modification involontaire des valeurs.

#2 . Clés du dictionnaire

Par exemple, vous créez un dictionnaire en utilisant les éléments de liste key_list comme clés. Vous pouvez utiliser la méthode dict.fromkeys() pour créer un dictionnaire à partir d'une liste.

 key_list = list("ABCD") dict.fromkeys(key_list) {'A': None, 'B': None, 'C': None, 'D': None}

Supposons que vous modifiiez la liste pour qu'elle contienne 'D' comme premier élément (index 0) — avant de créer le dictionnaire.

Maintenant, qu'arrive-t-il à la clé de dictionnaire 'A' ?

Si vous essayez de créer un dictionnaire à partir de key_list et d'accéder à la valeur correspondant à la clé 'A', vous rencontrerez 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. Vous ne pouvez donc pas avoir un deuxième 'D' comme clé.

 dict.fromkeys(key_list) {'B': None, 'C': None, 'D': None} # A is no longer a key.

Si vous utilisez à la place un tuple, une telle modification est impossible et vous risquez moins de rencontrer des erreurs. Par conséquent, vous devriez préférer 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 la fonction

L'immuabilité des tuples les rend également aptes à être transmis en tant qu'arguments de fonction.

Considérez la fonction suivante find_volume() qui renvoie le volume d'un cuboïde compte tenu des dimensions : longueur, largeur et hauteur.

 def find_volume(dimensions): l,b,h = dimensions return l*b*h

Supposons que ces dimensions soient disponibles dans une liste appelée dimensions . L'appel à find_volume() avec des dimensions comme argument renvoie le volume.

 dimensions = [2,8,5] find_volume(dimensions) 80

Vous pouvez toujours modifier les dimensions stockées dans une liste.

 dimensions = [20,8,5] find_volume(dimensions) 800

Cependant, vous aurez parfois besoin que les valeurs restent constantes et résistent aux modifications. C'est alors que vous devriez envisager de stocker les arguments sous forme de tuple et de les utiliser dans l'appel de fonction.

#4 . Valeurs de retour des fonctions

En Python, vous rencontrerez des tuples dans les valeurs de retour des fonctions. Lorsque vous renvoyez plusieurs valeurs à partir d'une fonction, Python les renvoie implicitement sous la forme d'un tuple.

Considérez la fonction suivante return_even() :

 def return_even(num): even = [i for i in range(num) if (i%2==0)] return even,len(even)

• Il prend un nombre num comme argument
• Il renvoie la liste des nombres pairs dans l'intervalle [0,num) et la longueur de cette liste.

Définissons la valeur de num 20 et appelons la fonction.

 num = 20

L'appel return_even() renvoie les deux valeurs dans un tuple. Vous pouvez appeler la fonction type() avec l'appel de fonction comme argument de vérification.

 type(return_even(num)) # <class 'tuple'>

Vous pouvez imprimer la valeur de retour pour vérifier qu'il s'agit d'un tuple contenant la liste des nombres pairs comme premier élément et la longueur de la liste comme deuxième élément.

 print(return_even(num)) ([0, 2, 4, 6, 8, 10, 12, 14, 16, 18], 10)

Comme il y a deux éléments dans le tuple, vous pouvez les décompresser en deux variables, comme indiqué ci-dessous.

 even_nums, count = return_even(num) print(even_nums) print(count) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 10

Conclusion

J'espère que ce tutoriel a fourni une comparaison complète de Python tuple vs list.

Terminons le didacticiel avec un bref résumé :

• La liste et les tuples sont des structures de données intégrées à Python.
• Similitudes : itérables, prise en charge de l'indexation, du découpage, de différents types de données et d'un opérateur pour les tests d'appartenance.
• Différence clé : les listes sont modifiables et les tuples sont immuables.
• Autres différences : Longueur fixe des tuples et longueur variable des listes, taille plus petite en mémoire des tuples.
• Quand utiliser un tuple ? Pour les collections immuables, les clés de dictionnaire et les arguments de fonction.

Ensuite, consultez les projets Python pour vous entraîner et apprendre. Ou apprenez des méthodes pour supprimer les éléments en double des listes Python. Bon apprentissage! alors, bon codage !