Les tuples
Regrouper plusieurs valeurs dans un seul objet, le tuple, pour qu’une fonction puisse renvoyer plusieurs résultats à la fois.
Une fonction peut-elle renvoyer deux valeurs ?
Dans le Doc. 2,4, la fonction plus_grand_plus_petit retournait une chaîne de caractères comme "max : 18.0, min : 7.5". Pour un humain, c’est très lisible. Mais imaginons qu’on veuille ensuite calculer l’écart entre le maximum et le minimum. Il faudrait fouiller dans le texte pour retrouver les chiffres, puis les convertir en nombres. On a fabriqué une phrase alors qu’on voulait deux nombres.
Le vrai problème est le suivant : une instruction return met fin à la fonction. On ne peut donc pas écrire deux return à la suite en espérant récupérer deux résultats. Faisons une expérience.
Recopier la fonction suivante dans la partie principale de l’éditeur Thonny :
- Appeler
min_max(9, 4)dans la console. Qu’affiche-t-elle ? - Saisir ensuite
resultat = min_max(9, 4), puistype(resultat). Combien d’objets la fonction a-t-elle retournés ?
On n’a donc pas contourné la règle : une fonction renvoie toujours une seule valeur. On a simplement rangé les deux nombres dans une même boîte, et c’est la boîte qu’on renvoie.
Un tuple (le programme dit aussi p-uplet) est une suite ordonnée de valeurs. On l’écrit en séparant les valeurs par des virgules, le plus souvent entre parenthèses : (4, 9).
Le tuple est un type construit : il est fabriqué à partir de valeurs de types de base (int, float, str, bool).
Une fonction ne retourne qu’une seule valeur. Pour retourner plusieurs résultats, elle les regroupe dans un tuple : return a, b.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Avec la fonction min_max du cours, que vaut type(min_max(9, 4)) ?
return a, b regroupe les deux nombres dans un seul objet, un tuple.
Combien d’objets une fonction qui exécute return a, b retourne-t-elle ?
Une fonction retourne toujours un seul objet ; pour transmettre plusieurs résultats, on les regroupe dans un tuple.
Créer un tuple et lire ses éléments
C’est la virgule qui fait le tuple
Pour chacune des expressions suivantes, prévoir le type de la valeur obtenue, puis vérifier avec la fonction type dans la console :
Le deuxième essai provoque une erreur. Pourquoi, à votre avis ? Comment écrire un tuple qui ne contient qu’un seul élément ?
Les éléments d’un tuple ne sont pas forcément du même type. Une ville peut être décrite par son nom, sa latitude et sa longitude :
Ce tuple n’a de sens que parce qu’on s’est mis d’accord sur l’ordre : d’abord le nom, ensuite la latitude, enfin la longitude. Si on écrivait (48.86, "Paris", 2.35), Python ne protesterait pas, mais un programme qui attend le nom en premier serait trompé.
Repérer un élément par son indice
Chaque élément d’un tuple occupe une position, appelée indice. En Python, les indices commencent à 0. Cela paraît étrange au début. Une façon de s’en souvenir : l’indice indique combien de pas il faut faire depuis le début pour atteindre l’élément. Le premier élément est à zéro pas du début.
| indice | 0 | 1 | 2 |
|---|---|---|---|
élément de t |
3 | 7 | 12 |
On lit l’élément d’indice i du tuple t en écrivant t[i]. La fonction len, déjà rencontrée avec les chaînes de caractères, donne le nombre d’éléments du tuple.
Saisir t = (3, 7, 12) dans la console. Prévoir le résultat de chacune des instructions suivantes, puis vérifier :
Quel est l’indice du dernier élément d’un tuple qui contient n éléments ?
Python accepte aussi des indices négatifs, qui comptent à partir de la fin : t[-1] est le dernier élément, t[-2] l’avant-dernier. Avec t = (3, 7, 12), t[-1] vaut 12, exactement comme t[len(t) - 1].
Avec ville = ("Paris", 48.86, 2.35), écrire une instruction qui affiche, à l’aide d’une f-string et des indices :
Les éléments d’un tuple t sont repérés par leur indice, qui commence à 0. On lit l’élément d’indice i avec t[i].
len(t) donne le nombre d’éléments de t. Les indices valides vont donc de 0 à len(t) - 1. Un indice en dehors de ces limites provoque une erreur IndexError.
Un tuple d’un seul élément s’écrit avec une virgule : (5,). Le tuple vide s’écrit ().
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Que vaut type((5)) ?
Les parenthèses seules ne font qu’entourer l’expression 5. Pour un tuple d’un seul élément, il faut une virgule : (5,).
Avec t = (3, 7, 12), que produit t[3] ?
Le tuple contient 3 éléments, d’indices 0, 1 et 2 : l’indice 3 n’existe pas.
Un tuple t contient n éléments. Quelles expressions donnent son dernier élément ?
Les indices vont de 0 à len(t) - 1. L’indice négatif -1 compte à partir de la fin. t[len(t)] et t[n] sont hors limites.
Un tuple ne peut pas être modifié
Toujours avec t = (3, 7, 12), essayer de remplacer le premier élément par 4 :
Que se passe-t-il ?
Un tuple, une fois créé, ne change plus. On dit qu’il est non mutable (ou immuable). Est-ce gênant ? Pas vraiment, car on peut toujours fabriquer un nouveau tuple.
Prévoir, puis vérifier, le contenu de t et de u après chacune des instructions suivantes :
L’opérateur + a-t-il modifié t ? La dernière affectation a-t-elle modifié le tuple (3, 7, 12) ?
Prévoir puis vérifier le résultat de 7 in t et de 8 in t, avec t = (4, 7, 12). De quel type est la valeur obtenue ?
Pourquoi Python propose-t-il un objet qu’on ne peut pas modifier ? Parce que c’est une garantie. Les coordonnées de Paris ne vont pas changer pendant l’exécution du programme. Si on les range dans un tuple et qu’on les confie à une fonction, on est certain de les retrouver intactes, quelle que soit la façon dont cette fonction a été écrite.
Un tuple est non mutable : on ne peut pas modifier ses éléments. L’instruction t[0] = 4 provoque une erreur TypeError.
On peut en revanche construire un nouveau tuple, par exemple par concaténation avec l’opérateur + : (3, 7) + (12,) vaut (3, 7, 12).
valeur in t vaut True si valeur est un élément de t, False sinon.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Avec t = (3, 7, 12), que produit l’instruction t[0] = 4 ?
Un tuple est non mutable : on ne peut pas affecter une nouvelle valeur à l’un de ses éléments.
Après t = (3, 7, 12) puis u = t + (20,), que vaut t ?
La concaténation fabrique un nouveau tuple, rangé dans u. Le tuple t n’est pas modifié.
Avec t = (4, 7, 12), que vaut 8 in t ?
in teste la présence d’une valeur et donne un booléen : 8 n’est pas un élément de t.
Parcourir un tuple
Un tuple est un objet itérable, au même titre que ce que produit range (voir Doc. 2,4). On peut donc le parcourir avec une boucle for. Il y a deux façons de le faire.
Recopier les deux fonctions suivantes dans l’éditeur :
- Tester
somme((3, 7, 12))etsomme_2((3, 7, 12)). - Dans chaque fonction, quelles valeurs prend successivement la variable de boucle (
voui) ? - L’annotation
tuple[float, ...]signifie « tuple de nombres flottants, de longueur quelconque ». Pourquoi ne pas avoir écrittuple[float, float, float]?
La première écriture est plus courte. La seconde n’est utile que lorsqu’on a besoin de connaître la position des éléments, comme dans la question suivante.
Écrire la fonction indice_max dont la spécification est :
Indication. On suppose d’abord que le plus grand élément est celui d’indice 0, puis on compare cet élément à chacun des suivants.
On parcourt un tuple t de deux façons :
for element in t:donne directement les éléments, un par un ;for i in range(len(t)):donne les indices, et on lit l’élément avect[i]. On utilise cette écriture lorsque la position de l’élément compte.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Avec t = (3, 7, 12), quelles valeurs la variable v prend-elle dans for v in t: ?
Cette écriture parcourt directement les éléments du tuple.
Pour écrire la fonction indice_max, quel parcours faut-il choisir ?
La fonction doit retourner un indice : il faut connaître la position de chaque élément, donc parcourir les indices.
Déballer un tuple
L’affectation multiple
Quand un tuple contient peu d’éléments, il est souvent plus clair de donner un nom à chacun d’eux. Python permet de le faire en une seule ligne.
Saisir les instructions suivantes dans la console, en prévoyant le résultat avant chaque validation :
Expliquer le message d’erreur obtenu à la dernière ligne.
Reprendre la fonction min_max de la première partie. Écrire dans la console une instruction qui range le résultat de min_max(9, 4) dans deux variables petit et grand, puis calculer l’écart entre ces deux nombres.
Retour sur l’échange de deux variables
Dans le Doc. 2,2, on a vu que la séquence a = b puis b = a n’échange pas les valeurs de deux variables, et qu’il fallait passer par une variable tmp. Avec les tuples, Python propose une écriture bien plus courte.
Saisir les instructions suivantes dans la console :
- Les valeurs ont-elles été échangées ?
- La séquence
a = bpuisb = aéchouait parce que la valeur deaétait écrasée avant d’avoir été recopiée. Expliquer, en décrivant ce que fait Python dans l’ordre, pourquoi ce problème ne se pose pas ici.
Pour l’épreuve écrite. Sans utiliser Python, compléter le tableau d’état de la séquence suivante, puis vérifier dans la console.
| Instruction | a | b |
|---|---|---|
a, b = 3, 8 |
||
a, b = b, a + b |
||
a, b = b - a, a |
Dans le Doc. 2,4, la fonction fibo utilisait une troisième variable w pour calculer le terme suivant de la suite de Fibonacci. Réécrire cette fonction sans la variable w, à l’aide d’une affectation multiple. Vérifier que fibo(10) retourne '1 1 2 3 5 8 13 21 34 55 '.
L’affectation multiple x, y = point déballe un tuple : chaque variable de gauche reçoit l’élément de même position. Il doit y avoir autant de variables que d’éléments, sinon Python signale une erreur ValueError.
Dans a, b = b, a, Python évalue d’abord tout le membre de droite, qui forme un tuple, puis affecte les variables. C’est pourquoi cette instruction échange les valeurs de a et de b.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Après point = (2, 5) puis x, y = point, que vaut y ?
Chaque variable de gauche reçoit l’élément de même position : x vaut 2 et y vaut 5.
Que produit a, b = (1, 2, 3) ?
Il doit y avoir autant de variables que d’éléments dans le tuple.
Que valent a et b après a, b = 2, 5 puis a, b = b, a + b ?
Le membre de droite est entièrement évalué avec les anciennes valeurs : il forme le tuple (5, 7), puis les deux variables sont affectées.
Écrire une fonction qui renvoie un tuple
Pour annoncer qu’une fonction retourne un tuple, on indique dans sa signature le type de chaque élément, dans l’ordre : -> tuple[int, int] signifie « retourne un tuple de deux entiers ». Pour un tuple de longueur quelconque dont tous les éléments ont le même type, on écrit tuple[float, ...].
Écrire chaque fonction dans la partie principale de l’éditeur, avec sa spécification complète (signature et documentation). Tester ensuite chacun des exemples de la documentation dans la console.
Division euclidienne. Écrire la fonction division_euclidienne dont la spécification est :
Comparer avec le résultat de la fonction divmod(17, 5), fournie par Python.
Convertir une durée. Une course de fond a duré 3725 s. On veut exprimer cette durée en heures, minutes et secondes.
- Sans ordinateur, effectuer la conversion à la main, en détaillant le calcul.
- Écrire la fonction
convertir_dureedont la spécification est :
Milieu d’un segment. Dans un repère, un point est représenté par le tuple (x, y) de ses coordonnées. Écrire la fonction milieu dont la spécification est :
Indication. Commencer par déballer chacun des deux tuples.
Distance entre deux points. Dans le Doc. 2,1, la fonction distance recevait quatre arguments x1, y1, x2, y2. Avec des tuples, deux arguments suffisent. On veut de plus que la fonction marche aussi dans l’espace, avec des points à trois coordonnées. Dans un repère orthonormé de l’espace, la distance entre et est :
- Écrire la fonction
distancedont la spécification est :
- Que devrait faire la fonction si on l’appelle avec
distance((0, 0), (1, 1, 1))? Ajouter au début du corps de la fonction l’instruction :
puis tester à nouveau cet appel.
L’instruction assert condition, "message" vérifie qu’une condition est vraie. Si elle est fausse, le programme s’arrête avec une erreur AssertionError et affiche le message.
On s’en sert pour vérifier une précondition, c’est-à-dire une condition que les arguments doivent respecter pour que la fonction ait un sens. Mieux vaut un programme qui s’arrête en expliquant pourquoi qu’un programme qui retourne un résultat faux sans prévenir.
Plus petit et plus grand élément. Écrire la fonction min_max_tuple dont la spécification est :
Les fonctions min et max de Python ne doivent pas être utilisées. Vérifier la précondition par une assertion.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Que retourne division_euclidienne(17, 5) ?
: le quotient vaut 3 et le reste 2, dans cet ordre.
Que se passe-t-il à l’exécution de assert len(valeurs) > 0, "valeurs ne doit pas être vide" lorsque valeurs vaut () ?
La condition est fausse : assert arrête le programme en expliquant pourquoi, au lieu de laisser la fonction produire un résultat faux.
Quelle annotation de type, écrite comme dans le cours, convient à une fonction qui retourne une durée sous la forme (heures, minutes, secondes), trois entiers ?
On indique le type de chacun des éléments du tuple retourné.
Exercices de synthèse
Équation du second degré. On cherche les solutions réelles de l’équation , avec . On note le discriminant.
- Si , il y a deux solutions : et .
- Si , il y a une seule solution : .
- Si , il n’y a pas de solution réelle.
Le nombre de solutions change d’une équation à l’autre. Un tuple convient bien : il peut contenir deux, un ou zéro élément. Écrire la fonction racines dont la spécification est :
Comparer deux dates. Une date est représentée par un tuple (jour, mois, annee). Écrire la fonction est_avant dont la spécification est :
Indication. Comparer d’abord les années. Si elles sont égales, comparer les mois, et ainsi de suite.
Bilan
- créer un tuple, y compris un tuple d’un seul élément
(5,)et le tuple vide(); - lire un élément d’un tuple grâce à son indice, en sachant que les indices vont de
0àlen(t) - 1; - expliquer pourquoi
t[0] = 4provoque une erreur, et construire un nouveau tuple à la place ; - tester la présence d’une valeur dans un tuple avec
in; - parcourir un tuple par ses éléments ou par ses indices, et choisir l’écriture adaptée ;
- déballer un tuple par une affectation multiple, et expliquer pourquoi
a, b = b, aéchange deux valeurs ; - écrire une fonction qui renvoie un tuple de valeurs, avec une signature du type
-> tuple[int, int]; - vérifier une précondition à l’aide d’une assertion.