Les tuples Python et les données immuables

Les tuples Python sont des séquences ordonnées de données. Contrairement à une liste, un tuple est immuable, c’est-à-dire que les données ne peuvent pas être modifiées.

Un tuple Python peut contenir des éléments de types différents et autant d’éléments que vous le souhaitez. En plus d’être immuable, vous pouvez distinguer un tuple d’une liste grâce aux parenthèses. Cependant, l’utilisation de parenthèses est facultative.

Comment créer un tuple

Pour créer un tuple, vous pouvez placer les éléments ou non entre parenthèses et les séparer par une virgule.

>>> tuple_vide =()
>>> mon_tuple = (1,2,3)
>>> un_autre_tuple = "a","b","c"
>>> encore_un_tuple = (5, "bonjour")

Il est également possible de créer un tuple imbriqué.

>>> tuple_imb = (1,("a","b"), "c")

De plus, on peut créer un tuple avec un seul élément. Mais comme cela ressemblera à une chaîne de caractère, on mettra une virgule après l’élément pour indiquer à Python qu’il s’agit d’un tuple.

>>> tuple_virgule = ("je suis un tuple",)

Accéder aux éléments d’un tuple

L’indexation des tuples est similaire à celle des listes, le premier élément porte l’indice zéro et le dernier élément est n-1 (n éléments). De plus, l’indexation inverse utilise un index négatif, c’est-à-dire que le dernier élément est accessible en utilisant l’indice (-1) et ainsi de suite. Aussi, rappelez-vous que lorsque vous utilisez une intervalle d’indexation, le dernier élément est exclu :
[du_premier_inclus : au_dernier_exclu].

>>> mon_tuple = 1, 2, "fruit", "livre", 5
>>> mon_tuple[0]
1
>>> mon_tuple[-2]
'livre'
>>> mon_tuple[-1]
5
>>> mon_tuple[1:2]
(2,)          # remarquez la virgule
>>> mon_tuple[1:3]
(2, 'pomme')

Modification, réaffectation et suppression des tuples Python

Un tuple est immuable, vous ne pouvez donc pas modifier ses éléments. Cependant, s’il contient un élément de type mutable, comme une liste, vous pouvez modifier cet élément particulier.
Par exemple, nous allons modifier les éléments d’une liste, qui se trouve dans un tuple.

>>> mon_tuple = ("a", 3, [5,9])
# remplacer l'élément avec l'indice 1 de la liste, 
# qui possède la valeur 9
# la liste porte l'indice 2 dans le tuple
>>> mon_tuple[2][1] = "c"
>>> mon_tuple
('a', 3, [5, 'c'])

Pour réaffecter un tuple Python, vous pouvez simplement créer une autre collection d’éléments et l’assigner au tuple.

>>> mon_tuple = ("un autre tuple",)

Nous allons réaffecter certains éléments de mon_tuple.

>>> id(mon_tuple)
140147516576192
>>> mon_tuple = ("a", 5, (3,2))
>>> mon_tuple
('a', 5, (3, 2))
>>> id(mon_tuple)
140147516660736

Certains vont penser qu’on a modifié le tuple.
Remarquez les identifiants ou l’adresse en mémoire des deux tuples. Ils n’ont pas la même adresse mémoire, tout simplement parce qu’on réaffectant le tuple on a créé un nouveau, on a pas modifié l’ancien.

Par contre, vous ne pouvez pas modifier les tuples Python en utilisant les indices.

# remplacer "a" par "b"
>>> mon_tuple[0] = "b"
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    mon_tuple[0] = "b"
TypeError: 'tuple' object does not support item assignment

On supprime un tuple et tous ses éléments avec le mot-clé del.

>>> del mon_tuple
>>> mon_tuple
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    mon_tuple
NameError: name 'mon_tuple' is not defined

Pour tester si un tuple contient un élément spécifique, vous pouvez utiliser les opérateurs d’appartenance in et not in.

>>> mon_tuple = ("a", 3, [1,2])
>>> 1 in mon_tuple
False
>>> [1,2] in mon_tuple
True
>>> 3 not in mon_tuple
False
>>> "a" in mon_tuple
True

En fait, le 1 n’est pas un élément du tuple, mais un élément de la liste qui se trouve à l’intérieur du tuple. Rappelez-vous, ici on pale d’éléments.

Les méthodes de tuples

On a deux méthodes seulement qui fonctionnent avec des tuples Python.

count() : renvoie le nombre de fois où l’élément apparaît dans le tuple.

>>> mon_tuple = ("bonjour", 1, 2, 1, 2)
>>> mon_tuple.count(1)
2
>>> mon_tuple.count('b')
0
>>> mon_tuple.count("bonjour")
1

Donc, encore une fois, le « b » est un élément de la chaîne « bonjour » et non pas de notre tuple.

>>> 'b' in mon_tuple
False
>>> 'b' in mon_tuple[0]
True

index() : renvoie l’index du premier élément qui est égal à l’élément donné.

>>> mon_tuple = ("a", 1, 5, 8,"a")
>>> mon_tuple.index("a")
0

Les fonctions intégrées et les tuples

Plusieurs fonctions intégrées sont souvent utilisées avec les tuples Python pour effectuer des tâches spécifiques.

len() : renvoie le nombre d’éléments d’un tuple.

>>> len(mon_tuple)
5

max() : renvoie le plus grand élément d’un tuple.

>>> mon_tuple = 4,5,6
>>> max(mon_tuple)
6

Lorsqu’un tuple Python contient des éléments de type chaînes de caractère, max() évalue les éléments par ordre alphabétique et renvoie le dernier élément.

>>> mon_tuple = "a","b","c"
>>> max(mon_tuple)
'c'

min() : renvoie le plus petit élément d’un tuple.

>>> mon_tuple = 4,5,6
>>> min(mon_tuple)
4

sorted() : renvoie une liste triée, mais ne trie pas le tuple lui-même.

>>> mon_tuple = (5,2,8,20,14,9)
>>> sorted(mon_tuple)
[2, 5, 8, 9, 14, 20]

L’ordre dans le tuple restera le même.

>>> mon_tuple
(5, 2, 8, 20, 14, 9)

sum() : renvoie la somme de tous les éléments d’un tuple.

>>> sum(mon_tuple)
58

tuple() : convertit les itérables comme une chaîne, une liste, un dictionnaire ou un set en tuple.

>>> tuple("python")
('p', 'y', 't', 'h', 'o', 'n')

enumerate() : renvoie un objet contenant la valeur et l’index de tous les éléments du tuple Python.

>>> mon_tuple = (5,2,8)
>>> enumerate(mon_tuple)
<enumerate object at 0x7ff3255f9d00>
>>> for i in enumerate(mon_tuple):
	print(i)
	
(0, 5)
(1, 2)
(2, 8)

Les dictionnaires et les tuples

Les dictionnaires possèdent une méthode appelée items() qui renvoie une liste de tuples, où chaque tuple est une paire clé-valeur.

>>> dic = {'a':20, 'b':15, 'c':25}
>>> lt = dic.items()
>>> lt
dict_items([('a', 20), ('b', 15), ('c', 25)])
>>> list(lt)
[('a', 20), ('b', 15), ('c', 25)]

Les éléments d’un dictionnaire ne sont pas ordonnés. Cependant, comme la liste est mutable, nous pouvons la modifier et la trier.
La conversion d’un dictionnaire en une liste de tuples permet de le trier par clé.

>>> dic = {'c':20, 'a':15, 'b':25}
>>> lt = list(dic.items())
>>> lt.sort()
>>> lt
[('a', 15), ('b', 25), ('c', 20)]

L’affectation multiple d’un dictionnaire

Nous allons combiner la méthode items() des dictionnaires, l’affectation de tuple et la boucle for pour afficher les clés et les valeurs d’un dictionnaire.

>>> for a, b in list(dic.items()):
	print(a, b)
	
c 20
a 15
b 25

Vous pouvez également afficher les valeurs avant les clés.

>>> for a, b in list(dic.items()):
	print(b, a)
	
20 c
15 a
25 b

Ce qui nous permettra de trier le dictionnaire selon les valeurs des clés.
Donc, nous allons itérer les éléments, puis les mettre dans une liste.

>>> for a, b in list(dic.items()):
	lst.append((b,a))  # mettre le résultat dans une liste
	lst.sort()         # trier la liste

	
>>> lst
[(15, 'a'), (20, 'c'), (25, 'b')]

Tuples vs listes

À l’exception du fait que l’un, est mutable et l’autre non, les tuples et les listes sont presque similaires. Vous utiliserez probablement un tuple pour des éléments de types de données différents, tandis que vous préférerez une liste lorsque vous travaillez sur des éléments de types de données similaires.

La nature immuable des tuples entraîne une itération plus rapide qui peut aider à améliorer les performances d’un programme.

En outre, les éléments d’un tuple immuables peuvent être utilisés comme clés de dictionnaire, ce qui n’est pas possible avec une liste.

L’utilisation de données non-modifiables en tant que tuple garantira qu’elles resteront protégées en écriture.

Aussi, si vous passez une séquence en tant qu’argument à une fonction, l’utilisation de tuples réduit le potentiel de comportement inattendu à cause des alias.