Manipulation de tuples

Manipulation de listes Manipulation de sets

Accès rapide :
La vidéo
Présentation du type tuple
Définition de tuples
Accéder aux valeurs d'un tuple
Vérifier la présence ou non d'une données dans le tuple
Parcourir un tuple
La notion de « tuple unpacking »
La notion de « slicing »
Utilisation conjointe d'un tuple et d'un générateur
Compléments sur la manipulation de vos tuples
Quelques fonctions applicables aux tuples
Quelques méthodes de la classe tuple
Quelques opérateurs de la classe tuple
Typage de vos tuples
Travaux pratiques
Les énoncés
Les corrections

La vidéo

Cette vidéo vous montre comment utiliser des tuples (des listes immuables) en Python.

Présentation du type tuple

Définition de tuples

En Python, le type tuple permet de représenter une liste 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'])
>>> 

Accéder aux valeurs d'un tuple

Une première chose à savoir, c'est quelle est la taille (le nombre d'éléments qui le constitue) de votre tuple. Pour ce faire, 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
>>> 

Vérifier la présence ou non d'une données dans le tuple

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

A contrario, vous pouvez vérifier si une information n'est pas présente dans le tuple avec l'opérateur not in. Voici des exemples d'utilisation.

>>> data = (10, 20, 30, 40, 50)
>>> 20 not in data
False
>>> 25 not in data
True
>>> 

Parcourir un tuple

Il est bien entendu possible de parcourir tous les éléments d'un tuple. Pour ce faire, vous pouvez utiliser une boucle while. Il faudra juste gérer un index qui va s'incrémenter au fur et à mesure de la progression dans le tuple. Tapez les lignes de code suivantes dans un éditeur Python (PyCharm par exemple) et non pas dans l'interpréteur interactif.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 

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

# On démarre le parcours à partir de la première position
index = 0

# On calcule, une fois pour toute, la taille du tuple
length = len(data)

# On traite chaque élément du tuple, un par un
while index < length:
    value = data[index]
    index += 1
    
    print(value)
    
print("Parcours terminé")

Et voici les résultats produits par cet exemple.

$> python sample.py
10
20
30
40
50
Boucle while terminée
$> 

Bien que la boucle while fonctionne parfaitement, ce n'est pas la meilleure manière de parcourir tous les éléments d'un tuple. Une autre construction est bien plus pratique : la boucle for. Effectivement, celle-ci vous évite de gérer l'index de parcours vous-même et elle va vous permettre de récupérer chaque valeur du tuple à tour de rôle dans une variable.

La syntaxe est simple : on commence par le mot clé for suivit du nom de la variable qui va recevoir une à une les valeurs de la collection, puis on trouve le mot clé in lui-même suivit de la collection à traiter et enfin un caractère : introduit le bloc d'instructions à exécuter à chaque tour de boucle. En voici un exemple d'utilisation.

 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é")

Les résultats sont exactement les mêmes que ceux produits par la boucle while. Et vous aurez certainement validé la simplicité de la syntaxe, comparé à la boucle while.

La notion de « tuple unpacking »

Le « tuple unpacking » (déballage de tuple, en français) consiste à sortir les valeurs stockées dans un tuple dans un ensemble de variables nommées.

>>> data = (10, 20, 30)
>>> a, b, c = data
>>> a
10
>>> b
20
>>> c
30
>>> a, b = data
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)
>>> 

La notion de « slicing »

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)
>>> 

Utilisation conjointe d'un tuple et d'un générateur

Un générateur est un objet permettant de produire des séquences de valeurs. Il est possible de produire un générateur assez facilement, comme le montre l'exemple suivant.

>>> g = (i for i in range(10) if i%2 == 0)
>>> g
<generator object <genexpr> at 0x7f72949d0f20>
>>> type(g)
<class 'generator'>
>>> for value in g: print(value)
... 
0
2
4
6
8
>>> 

Vous pouvez construire un tuple à partir d'un générateur en passant par le constructeur de la classe tuple : dans ce cas, il est possible de ne pas mettre les parenthèses du générateur, étant donné qu'on a déjà la paire de parenthèses de l'appel au constructeur.

>>> # Avec les parenthèses du générateur
>>> t = tuple((i for i in range(10) if i % 2 == 0))
>>> t
(0, 2, 4, 6, 8)
>>> 
>>> # Sans les parenthèses du générateur
>>> t2 = tuple(i for i in range(10) if i % 2 == 0)
>>> t2
(0, 2, 4, 6, 8)
>>> 
>>> t == t2
True
>>> type(t)
<class 'tuple'>
>>>

Compléments sur la manipulation de vos tuples

Quelques fonctions applicables aux tuples

Il existe de nombreuses fonctions applicables aux tuples Python. Nous pouvons notamment citer :

• len : cette fonction permet de calculer la taille d'un tuple (mais nous l'avions déjà présentée dans ce document).

  >>> data = (50, 10, 30, 20, 40, 60)
  >>> len(data)
  6
  >>> 

• max : cette fonction permet de calculer la valeur maximale contenu dans un tuple. Il est à noter que cette fonction peut aussi être invoquée avec un nombre quelconques de paramètres : dans ce cas, c'est le paramètre contenant la plus grande valeur qui sera retourné.

  >>> data = (50, 10, 30, 20, 40, 60)
  >>> max(data)                     # Invoquée avec un tuple de valeur
  60
  >>> max(50, 10, 30, 20, 40, 60)   # Invoquée avec un nombre variable de paramètres
  60
  >>> 

• min : cette fonction permet de calculer la valeur minimale contenu dans un tuple. Il est à noter que cette fonction peut aussi être invoquée avec un nombre quelconques de paramètres : dans ce cas, c'est le paramètre contenant la plus grande petite qui sera retourné.

  >>> data = (50, 10, 30, 20, 40, 60)
  >>> min(data)                     # Invoquée avec un tuple de valeur
  10
  >>> min(50, 10, 30, 20, 40, 60)   # Invoquée avec un nombre variable de paramètres
  10
  >>> 

• sum : cette fonction permet de sommer toutes les valeurs de le tuple passé en paramètre. Attention, les données du tuple doivent obligatoirement être numériques.

  >>> data = (50, 10, 30, 60, 40, 20)
  >>> total = sum(data)
  >>> total
  210
  >>> 

Quelques méthodes de la classe tuple

Vous vous en doutez, la classe tuple expose aussi quelques méthodes bien utiles. En voici quelques-unes : vous pouvez cliquer sur le nom de la méthode pour en obtenir un descriptif plus détaillé.

Quelques opérateurs de la classe tuple

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

Typage de vos tuples

Nous avons vu, dans les chapitres précédents, qu'il était possible de spécifier le type de vos variables lors de leurs déclarations. Il en va de même pour vos tuples et vous pouvez même indiquer le type des éléments qu'un tuple doit contenir. Voici un exemple de code indiquant que la variable data sera typée en tant que tuple de valeurs flottantes (tuple[float]).

 1 
 2 
 3 

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

 1 
 2 
 3 
 4 
 5 

from typing import Tuple

# Syntaxe recommandée pour des versions antérieures à Python 3.9            
data: Tuple[float] = [10, 20.2, 13.4]
print(data)

N'oubliez pas que certains IDEs peuvent vérifier les informations de typage : c'est le cas de PyCharm. Si vous tentez d'insérer autre chose qu'une valeur flottante dans le tuple ci-dessus, l'IDE pourra signaler cette incohérence. Voici une capture d'écran de PyCharm montrant cette capacité.

Vous pouvez aussi utiliser l'outil « mypy » pour vérifier la cohérence des types de votre programme. Voici un exemple de vérification.

[$> mypy test_typing.py 
test_typing.py:2: error: Incompatible types in assignment (expression has type "Tuple[int, float, float, str]", variable has type "Tuple[float]")
Found 1 error in 1 file (checked 1 source file)
$> 

Travaux pratiques

Les énoncés

Exercice 1 : je vous donne le tuple suivant comme base de travail. Il est constitué de triplets d'informations associés à des villes. La première information est le nom de la ville (dans l'exemple, des villages du sud de la France : faut venir les visiter ;-) ), la seconde information est la latitude du lieu et enfin on trouve la longitude. Il peut y avoir un nombre quelconque de triplet.

 1 
 2 
 3 
 4 
 5 
 6 
 7 

data = (
    "Andon", 43.77348, 6.78596,
    "Caille", 43.77887, 6.72979,
    "Séranon", 43.77435, 6.70415,
    "Valderoure", 43.79629, 6.70749
    # Vous ne devez pas présager du nombre de triplets.
)

Débrouillez-vous pour en extraire les données et produire l'affichage suivant :

+---------------+---------------+---------------+
| Ville         |      Latitude |     Longitude |
+---------------+---------------+---------------+
| Andon         |      43.77348 |       6.78596 |
| Caille        |      43.77887 |       6.72979 |
| Séranon       |      43.77435 |       6.70415 |
| Valderoure    |      43.79629 |       6.70749 |
+---------------+---------------+---------------+

Exercice 2 : vous devez produire le même affichage que dans l'exercice précédent, mais en utilisant le tuple de tuples suivant comme données d'entrée.

 1 
 2 
 3 
 4 
 5 
 6 
 7 

data = (
    ("Andon", 43.77348, 6.78596),
    ("Caille", 43.77887, 6.72979),
    ("Séranon", 43.77435, 6.70415),
    ("Valderoure", 43.79629, 6.70749)
    # Vous ne devez pas présager du nombre de triplets.
)

Exercice 3 : écrire un programme qui calcule la somme et la valeur moyenne d'un tuple de données numériques. Oui, je sais, on a déjà fait cet exercice avec les listes, mais c'est juste histoire de vérifier que cela marche aussi avec les tuples.

Comme toujours, essayez de ne pas trop regarder les corrections avant d'avoir terminé chaque exercice. ;-)

Les corrections

Exercice 1 : voici comment afficher les données du tuple de coordonnées GPS.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 

data = (
    "Andon", 43.77348, 6.78596,
    "Caille", 43.77887, 6.72979,
    "Séranon", 43.77435, 6.70415,
    "Valderoure", 43.79629, 6.70749
    # Vous ne devez pas présager du nombre de triplets.
)

cities = data[::3]
latitudes = data[1::3]
longitudes = data[2::3]

city_count = len(cities)

separator = f"+{'-' * 15}+{'-' * 15}+{'-' * 15}+"
header = f"| {'Ville':13s} | {'Latitude':>13s} | {'Longitude':>13s} |"

print(separator)
print(header)
print(separator)
for i in range(city_count):
    city = cities[i]
    lat = latitudes[i]
    long = longitudes[i]
    print(f"| {city:13s} | {lat:13.5f} | {long:13.5f} |")
print(separator)

Exercice 2 : voici comment afficher les données du tuple de tuples de coordonnées GPS.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 

data = (
    ("Andon", 43.77348, 6.78596),
    ("Caille", 43.77887, 6.72979),
    ("Séranon", 43.77435, 6.70415),
    ("Valderoure", 43.79629, 6.70749)
    # Vous ne devez pas présager du nombre de triplets.
)

city_count = len(data)

separator = f"+{'-' * 15}+{'-' * 15}+{'-' * 15}+"
header = f"| {'Ville':13s} | {'Latitude':>13s} | {'Longitude':>13s} |"

print(separator)
print(header)
print(separator)
for city_data in data:
    city = city_data[0]
    lat = city_data[1]
    long = city_data[2]
    print(f"| {city:13s} | {lat:13.5f} | {long:13.5f} |")
print(separator)

Exercice 3 : voici donc comment calculer la somme et la moyenne d'un tuple de valeurs numériques.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 

# Un jeu de données de démonstration
data = (10.1, 5.6, 8.3, 20.9, 17.2)

# On calcule la somme des valeurs et la moyenne
total = sum(data)
mean = total / len(data)

# On affiche les résultats
print(f"Total = {total:.2f}")
print(f"Mean = {mean:.2f}")

Manipulation de listes Manipulation de sets