le type tuple permet de représenter une collection de données immuable. Une fois instancié, il n'est plus possible de changer le contenu d'un tuple (ce qui n'est pas le cas d'une liste Python). Pour introduire un tuple, il faut utiliser une paire de parenthèses, contrairement à une liste ou il fallait utiliser une paire de crochets. Voici un premier exemple de définition de tuple.

>>> data = (10, 20, 30, 40, 50)
>>> data
(10, 20, 30, 40, 50)
>>> type(data)
<class 'tuple'>
>>> 

Comme nous l'avons dit, une fois son instanciation terminée, un tuple est immuable (non modifiable). Le plus simple, pour s'en rendre compte, est de tenter de modifier une valeur du tuple ou de supprimer une information. Voici les messages d'erreurs qui seront alors produits.

>>> data = (10, 20, 30, 40, 50)
>>> data[2]
30
>>> data[2] = 3000
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> del data[2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion
>>> data.append(60)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
>>> 

Un tuple Python n'est pas limité à un type de données unique : vous pouvez donc avoir des données quelconque dans un tuple. Voici un exemple de définition d'un tuple contenant des données diverses et variées.

>>> data = (10, 2.3, True, "Une chaîne", False, ["une", "sous", "liste"])
>>> data
(10, 2.3, True, 'Une chaîne', False, ['une', 'sous', 'liste'])
>>> 

Pour calculer la taille d'une tuple, il faut utiliser la fonction len.

>>> data = (10, 20, 30, 40, 50)
>>> nb = len(data)
>>> print("Nombre d'éléments :", nb)
Nombre d'éléments : 5
>>> 

Une fois la taille du tuple connue, vous pouvez commencer à manipuler les valeurs qui y sont contenues via l'opérateur []. Cet opérateur permet d'accéder à un élément du tuple par sa position. Il est important de mémoriser que les indices (les positions) dans un tuple commencent à 0. Ainsi, si un tuple contient cinq éléments alors les indices seront compris entre 0 et 4. Voici un exemple de récupération des valeurs d'un tuple.

>>> data = (10, 20, 30, 40, 50)
>>> data[0]     # On récupère le premier élément
10
>>> data[1]     # Le second
20
>>> data[2]
30
>>> data[3]
40
>>> data[4]     # Le dernier élément du tuple
50
>>> data[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> 

Contrairement à certains autres langages de programmation, Python autorise l'utilisation d'index négatifs : Dans ce cas, on accède aux valeurs de la collection par la fin : -1 correspond à l'indice du dernier éléments du tuple, -2 correspond à l'indice de l'avant-dernier élément... Voici un exemple d'utilisation d'index négatif.

>>> data = (10, 20, 30, 40, 50)
>>> data[-1]    # Dernier élément
50
>>> data[-2]
40
>>> data[-3]
30
>>> data[-4]
20
>>> data[-5]
10
>>> data[-6]    # Premier élément
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> 

Il est aussi possible de savoir si une valeur est présente dans le tuple en utilisant l'opérateur in. Voici un exemple d'utilisation.

>>> l = (10, 20, 30, 40, 50)
>>> 10 in l
True
>>> 100 in l
False
>>> is_present = 30 in l
>>> if is_present: print("30 est présent dans le tuple")
... 
30 est présent dans le tuple
>>> 

Il est bien entendu possible de parcourir tous les éléments d'un tuple avec une boucle (for ou while).

 1 
 2 
 3 
 4 
 5 
 6 
 7 

data = (10, 20, 30, 40, 50)

# On traite chaque élément du tuple, un par un
for value in data:
    print(value)
    
print("Parcours terminé")

Nous avons parlé de l'opérateur [] qui permet d'accéder aux éléments d'un tuple. Pour le moment, nous avons accédé aux valeurs une à une, mais il est aussi possible d'accéder à plusieurs valeurs du tuple via un seul appel à l'opérateur [] (un sous-tuple). Dans ce cas, on parle de « slice » (de tranches, si l'on parle en français).

Pour extraire une sous-tuple, à l'instar des chaînes de caractères ou des listes, il faut passer l'indice de début (basé à partir de 0) et l'indice de fin (position exclusive) de cette dernière. Les deux indices doivent être séparés par un caractère :. Voici quelques exemples d'utilisation.

>>> data = (10, 20, 30, 40, 50)
>>> data[1:3]
(20, 30)
>>> data[1:4]
(20, 30, 40)
>>> data[1:5]
(20, 30, 40, 50)
>>> data[:4]
(10, 20, 30, 40)
>>> data[2:]
(30, 40, 50)
>>> data[:]
(10, 20, 30, 40, 50)
>>> 

Il est aussi possible d'extraire les éléments d'un sous-tuple tout les « n » éléments. Imaginons que vous ayez une liste qui contiennent des coordonnées x, y qui suivent les une après les autres. Si vous souhaitez extraire que les abscisses (les x), vous pouvez le faire en spécifiant la slice suivante : coords[::2] (avec le pas en troisième paramètre de la slice). Pour obtenir toutes les ordonnées (les y), veuillez utiliser la slice suivante : coords[1::2], pour débuter l'extraction à partir de la seconde valeur par pas de 2. Voici un exemple d'utilisation.

>>> #         x, y, x,  y, x,  y,  x, y
>>> coords = (0, 0, 10, 5, 13, 12, 5, 7)
>>> 
>>> all_x = coords[::2]
>>> all_x
(0, 10, 13, 5)
>>> 
>>> all_y = coords[1::2]
>>> all_y
(0, 5, 12, 7)
>>> 

De nombreux autres opérateurs sont aussi proposés par la classe tuple. Voici quelques exemples d'utilisation.

>>> t = (10, 20, 30, 40, 50)
>>> t2 = (60, 70, 80, 90, 100)
>>> 
>>> # Concaténation de tuples
>>> full = t + t2
>>> full
(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
>>> 
>>> # Répétition d'un tuple
>>> t * 3
(10, 20, 30, 40, 50, 10, 20, 30, 40, 50, 10, 20, 30, 40, 50)
>>> 
>>> # Comparaison de tuples
>>> t == t2
False
>>> 
>>> # Recherche d'une valeur dans un tuple
>>> 30 in t
True
>>> 70 in t
False
>>> 

Il est possible de typer vos tuples en utilisant la syntaxe suivante.

 1 
 2 
 3 

# Attention : Python 3.9 ou supérieur requis !!!
data: tuple[float] = (10, 20.2, 13.4)
print(data)