Le n-uplet (tuple)¶
Un n-uplet (appelé tuple en anglais) est une séquence non modifiable de données ordonnées. Cela signifie que chaque élément du tuple est associé à une position (un index). Le premier élément d’un tuple possède l’index 0 et le dernier élément possède l’index n - 1 pour une liste contenant n éléments. Contrairement aux listes, les tuples ne sont pas modifiables.
Créer un tuple¶
Pour créer un tuple, on écrit la séquence des éléments entre parenthèses () et
séparés par des virgules :
tuple_vide = ()
mon_tuple = (10, 20, 30, 40)
tuple_depareille = (None, 1, "shrubbery", True)
Comme le montre le tuple_depareille ci-dessus, un tuple peut contenir
des éléments de types différents. Il peut même contenir un élément ou des
éléments None, ce qui signifie qu’il contient un élément qui n’est rien.
Astuce
Les parenthèses sont utilisés également pour modifier l’ordre de précellence des opérateurs arithmétiques et logiques. Il y a donc une ambiguïté lorsqu’une seule valeur est mise entre parenthèses :
a = (1)
Pour l’interpréteur Python, a va contenir l’entier 1. Pour indiquer
que l’on veut créer un tuple d’un seul élément qui vaut 1, il faut écrire :
a = (1,)
Accéder aux éléments¶
Comme pour les listes, pour accéder à un élément d’un tuple, il faut utiliser les crochets et préciser l’index de l’élément.
mon_tuple = (10, 20, 30, 40)
premier_element = mon_tuple[0]
second_element = mon_tuple[1]
Comme pour les listes, il est possible d’utiliser un index négatif pour compter à partir de la fin du tuple. Le dernier élément a l’index -1.
Les opérations sur les tuples¶
On peut effectuer les mêmes opérations sur les tuples que sur les listes pour la consultation. Par définition, il n’est pas possible d’effectuer une opération modifiant le contenu d’un tuple.
Connaître la taille d’un tuple¶
Pour connaître le nombre d’éléments d’un tuple, il faut utiliser la fonction
len() (qui est la contraction de length) :
mon_tuple = (10, 20, 30, 40)
taille_tuple = len(mon_tuple)
print(taille_tuple)
# affiche 4
Ajouter deux tuples ensemble¶
L’opérateur + permet d’ajouter deux tuples ensemble pour former un troisième
tuple :
mon_tuple = (0, 1, 2) + (10, 20, 30)
print(mon_tuple)
# affiche (0, 1, 2, 10, 20, 30)
Astuce
Pour augmenter la taille d’un tuple, vous pouvez utiliser l’opération +=.
Techniquement, le tuple n’est pas modifié, un nouveau tuple est créé et
assigné à la variable à gauche
mon_tuple = (0, 1, 2)
mon_tuple_original = mon_tuple
mon_tuple += (10, 20, 30)
print(mon_tuple)
# affiche (0, 1, 2, 10, 20, 30)
print(mon_tuple == mon_tuple_original)
# affiche False car un nouveau tuple a été créé
print(mon_tuple_original)
# affiche (0, 1, 2)
Créer un tuple étendu¶
L’opérateur * permet de créer un tuple en répétant le contenu d’un tuple
autant de fois que spécifié :
mon_tuple = ('ni') * 5
print(mon_tuple)
# affiche ('ni', 'ni', 'ni', 'ni', 'ni')
Savoir si un élément est présent dans un tuple¶
Pour savoir si un élément est présent dans un tuple on peut utiliser le mot-clé
in :
>>> mon_tuple = (1, 2, 3)
>>> 2 in mon_tuple
True
>>> 12 in mon_tuple
False
>>> 12 not in mon_tuple
True
Comparer deux tuples¶
On peut utiliser tous les opérateurs de comparaison entre deux tuples.
>>> mon_tuple = (1, 2, 3)
>>> mon_tuple == (1, 2, 3)
True
>>> mon_tuple != ()
True
>>> mon_tuple < (1, 2, 3, 4)
True
>>> mon_tuple > (1, 2)
True
Pour que deux tuples soient égaux, ils doivent avoir la même taille et contenir des éléments deux à deux identiques.
Connaître le plus grand élément d’un tuple¶
Pour connaître le plus grand élément d’un tuple, il faut utiliser la fonction
max() :
mon_tuple = (10, 20, 30, 40)
element = max(mon_tuple)
print(element)
# affiche 40
Cela suppose néanmoins que tous les éléments d’un tuple sont comparables et
donc de type similaire sinon on obtient une erreur de type TypeError.
>>> mon_tuple = (10, "coconut")
>>> element = max(mon_tuple)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'str' and 'int'
Connaître le plus petit élément d’une tuple¶
Pour connaître le plus petit élément d’un tuple, il faut utiliser la fonction
min() :
mon_tuple = ("a", "b", "c")
element = min(mon_tuple)
print(element)
# affiche a
Comme pour la méthode max(), cela suppose que tous les éléments d’un
tuple sont comparables et donc de type similaire.
Découper un tuple¶
Il est possible de découper (slice) un tuple. Comme le tuple n’est pas
modifiable, cette opération crée un nouveau tuple et copie les éléments
du tuple originel vers le nouveau tuple. Pour découper, on utilise les
crochets [] avec l’une des notations suivantes :
[index départ : indice supérieur : pas d’incrément]
[index départ : indice supérieur]
mon_tuple = (10, 20, 30, 40)
autre_tuple = mon_tuple[1:3]
print(autre_tuple)
# affiche (20, 30)
mon_tuple = (10, 20, 30, 40)
derniers_elements = mon_tuple[-3:3]
print(derniers_elements)
# affiche (20, 30)
mon_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)
nombres_pairs = mon_tuple[1:9:2]
print(nombres_pairs)
# affiche (2, 4, 6, 8)
Par défaut, l’indice de départ est 0, l’indice de fin est nombre d’éléments + 1 et le pas est 1. Vous pouvez omettre ces valeurs.
mon_tuple = (10, 20, 30, 40)
tuple_sauf_dernier_element = mon_tuple[:-1]
print(tuple_sauf_dernier_element)
# affiche (10, 20, 30)
tuple_sauf_premier_element = mon_tuple[1:]
print(tuple_sauf_premier_element)
# affiche (20, 30, 40)
un_sur_deux = mon_tuple[::2]
print(un_sur_deux)
# affiche (10, 30)
Compter les occurrences dans un tuple¶
Pour compter le nombre d’occurrences d’un élément, on utilise la méthode
count(e).
mon_tuple = ("John", "Eric", "Michael", "John", "Eric", "John")
occurrence = mon_tuple.count("John")
print(occurrence)
# affiche 3
Listes et tuples¶
Les listes et les tuples sont des séquences, il est donc possible de créer
une tuple à partir d’une liste et réciproquement. Pour cela, on utilise
les méthodes tuple(seq) et list(seq) :
mon_tuple = (1, 2, 3)
ma_liste = list(mon_tuple)
print(ma_liste)
# affiche [1, 2, 3]
# on inverse l'ordre des éléments de la liste
ma_liste.reverse()
mon_tuple = tuple(ma_liste)
print(mon_tuple)
# affiche (3, 2, 1)
Attention, ces fonctions ne transforment pas la nature de la séquence,
l’interpréteur crée en mémoire des copies de type list ou tuple.
Pourquoi utiliser des tuples plutôt que des listes ? Il s’agit bien souvent d’une optimisation pour l’exécution du code. En effet, un tuple est plus performant qu’une liste. Comme sa structure ne peut pas être modifiée, son implémentation permet un stockage en mémoire plus compact.
Les chaînes de caractères comme tuple¶
Les chaînes de caractères ne sont pas réellement des tuples, néanmoins elles sont des séquences non modifiables de caractères. Il est donc possible de leur appliquer les mêmes opérations.
>>> s = "Good night ding ding ding"
>>> len(s)
25
>>> s[0]
'G'
>>> "ding" in s
True
>>> "dong" not in s
True
>>> s[-4:]
'ding'
>>> s.count("ding")
3
>>> "Good" != s
True
>>> "Good" < s
True
>>> tuple(s)
('G', 'o', 'o', 'd', ' ', 'n', 'i', 'g', 'h', 't', ' ', 'd', 'i', 'n', 'g', ' ', 'd', 'i', 'n', 'g', ' ', 'd', 'i', 'n', 'g')
>>> list(s)
['G', 'o', 'o', 'd', ' ', 'n', 'i', 'g', 'h', 't', ' ', 'd', 'i', 'n', 'g', ' ', 'd', 'i', 'n', 'g', ' ', 'd', 'i', 'n', 'g']