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

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

Les listes et les tuples sont deux structures de données intégrées à Python. Elles peuvent être utilisées pour stocker une collection d'éléments.

De la prise en charge de l'indexation et du découpage à la contenance 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 une REPL Python et suivre ce tutoriel. Vous pouvez également utiliser L'éditeur Python en ligne de Geekflare pour coder.

Python Tuple vs Liste : Quelles sont les similitudes ?

Commençons par apprendre les similitudes entre les listes et les tuples. Pour faciliter l'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 d'éléments de type carré alors 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 l'option parenthèses.

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

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 à l'aide d'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. Soutien à la création à partir d'autres séquences

La prochaine similitude entre les listes et les tuples est qu'ils peuvent être créés à partir de séquences existantes telles que des chaînes de caractères.

sample_str = "Coding!"

La cellule de code suivante montre comment list(string) renvoie une liste dont les éléments 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 de caractères ou d'une autre séquence à l'aide de la fonction tuple(sequence). La cellule de code ci-dessous montre comment procéder.

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 en tranches

Python supporte 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 supporte également l'indexation négative, où le dernier élément est à l'index -1, l'avant-dernier élément à l'index -2, et ainsi de suite.

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

L'élément à l'indice -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 en tranches 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 à l'indice start et s'étendant jusqu'à end - 1. La valeur par défaut pour le début est 0, et la fin est le dernier élément de la table itérative.

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 de start jusqu'à end - 1par étapes de step.

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

('C', 'd', 'n', '!')

Ici, nous avons fixé la valeur du pas à 2, de sorte que 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 ci-dessous student_list contient le nom de l'élève sous forme de chaîne de caractères, son âge sous forme d'entier et les notes obtenues sous forme de 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. Soutien aux tests d'adhésion

Les listes et les tuples vous permettent d'effectuer des tests d'appartenance pour vérifier 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 la fonction in de l'opérateur.

L'expression item in iterable s'évalue à True si le iterable contient le item; d'autre part, 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, nous allons apprendre les principales différences entre les deux structures de données.

Python Tuple vs Liste : Quelles sont les différences ?

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

La différence la plus importante entre une liste et un tuple en Python est qu'un tuple tuple est immuable. Cela signifie que vous ne peut 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 mutables, nous pouvons donc modifier la liste en changeant 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 et tuples de longueur fixe

Liste Python est une structure de données de longueur variable.

Vous pouvez procéder comme suit :

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

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)

▶️ Le résultat 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. Il n'est donc pas possible d'ajouter ou de supprimer des éléments d'un tuple existant. En revanche, vous pouvez redéfinir le tuple pour qu'il contienne des éléments différents.

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 fonction liste est un longueur variable structure des données.

Lorsque vous définissez la liste initialement, une taille spécifique lui est allouée en mémoire. Maintenant, lorsque vous modifiez une liste à l'aide de la fonction append() ou extend() il convient d'allouer de la mémoire supplémentaire pour stocker les éléments ajoutés. Cette allocation est presque toujours supérieure au nombre d'éléments ajoutés.

Il est donc nécessaire de garder une trace du nombre d'éléments de la liste et de l'espace alloué. En outre, comme les listes sont de longueur variable, il existe un pointeur qui indique l'adresse des éléments de la liste. Par conséquent, les listes de longueur k occupe plus de mémoire qu'un tuple ayant la même valeur. k éléments.

Voici une illustration simple.

Vous pouvez utiliser la fonction sys du module getsizeof() 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 le montre la sortie ci-dessous.

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

Quand utiliser un tuple Python ?

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

Mais quand faut-il utiliser un tuple à la place ?

Nous y reviendrons dans cette section.

#1. Collection en lecture seule

Lorsque vous souhaitez 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 permet de s'assurer qu'elle ne peut pas être modifiée.

Par essence, lorsque vous avez besoin d'une collection en lecture seule : les valeurs ne doivent pas être modifiées au cours du programme, vous devez envisager d'utiliser un tuple. Vous éviterez ainsi toute modification involontaire des valeurs.

#2. Clés du dictionnaire

Par exemple, vous créez un dictionnaire en utilisant les éléments de la liste key_list comme clés. Vous pouvez utiliser les 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 modifiez la liste pour qu'elle contienne "D" comme premier élément (indice 0)-avant la création du dictionnaire.

Qu'advient-il maintenant de la clé "A" du dictionnaire ?

Si vous essayez de créer un dictionnaire à partir de key_list et accéder à la valeur correspondant à la clé 'A', vous rencontrerez un problème de type 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 plutôt un tuple, une telle modification est impossible et vous risquez moins de rencontrer des 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 permet également de les transmettre en tant qu'arguments de fonction.

Considérons la fonction suivante find_volume() qui renvoie le volume d'un parallélépipède en fonction de ses 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 dimensions comme argument renvoie le volume.

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

Vous pouvez toujours modifier les dimensions enregistré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. Dans ce cas, vous devez envisager de stocker les arguments sous la forme d'un tuple et de les utiliser dans l'appel de la 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érons 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 faut un certain nombre num comme argument
• Elle renvoie la liste des nombres pairs dans l'intervalle [0,num) et la longueur de cette liste.

Fixons la valeur de num 20 et appeler la fonction.

num = 20

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 le tuple contient deux éléments, vous pouvez les décomposer 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 entre les tuple et les listes en Python.

Terminons ce tutoriel par un bref résumé :

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

Ensuite, consultez Projets Python pour pratiquer et apprendre. Ou apprendre des méthodes pour supprimer les doublons des listes Python. Bon apprentissage ! puis bon codage!👩🏽‍💻