09 - Tuples

Les exercices se font dans Thonny, dans le fichier 09_tuples.py.

Cours associé : 10 - Tuples .

Exercice 1 : QCM – vérification des prérequis

Pour chaque question, une seule réponse est correcte.

1. Quelle est la différence fondamentale entre une liste et un tuple en Python ?

A. Un tuple ne peut contenir que des entiers
B. Un tuple est immuable (non modifiable après création)
C. Un tuple est plus lent qu’une liste
D. Un tuple ne peut pas contenir de doublons

Correction publiée après la séance.

2. Parmi les expressions suivantes, laquelle crée un tuple contenant un seul élément ?

A. (42)
B. (42,)
C. [42]
D. tuple(42)

Correction publiée après la séance.

3. Que se passe-t-il si on exécute T[0] = 5 avec T = (1, 2, 3) ?

A. Le tuple devient (5, 2, 3)
B. Python crée un nouveau tuple (5, 2, 3)
C. Python lève une erreur TypeError
D. Python lève une erreur IndexError

Correction publiée après la séance.

4. Que renvoie la fonction suivante ?

def f():
    return 3, 7

A. L’entier 3 puis l’entier 7
B. La chaîne "3, 7"
C. Le tuple (3, 7)
D. Une erreur car return ne peut renvoyer qu’une valeur

Correction publiée après la séance.

Exercice 2 : fonction qui renvoie deux valeurs

On veut une fonction division(a, b) qui renvoie à la fois le quotient et le reste de la division euclidienne de a par b.

def division(a, b):
    """Renvoie le quotient et le reste de la division de a par b.

    Paramètres :
        a (int) : dividende (>= 0)
        b (int) : diviseur (> 0)

    Retour :
        tuple : (quotient, reste)
    """
    return (..., ...)

Compléter la ligne return à l’aide des opérateurs // et %.
Indice
Le quotient de la division euclidienne s’obtient avec l’opérateur //, le reste avec %. Par exemple, 7 // 2 vaut 3 et 7 % 2 vaut 1.
Que vaut division(17, 5) ?
Compléter les deux lignes suivantes, en remplaçant chaque ... par la bonne variable, pour qu’elles affichent 17 = 5 × 3 + 2 :
Indice
q, r = division(17, 5) range le quotient dans q et le reste dans r : ce sont ces deux variables qu’il faut afficher.

q, r = division(17, 5)
print(f"17 = 5 × {...} + {...}")

Écrire trois lignes assert qui testent la fonction : l’une avec 17 et 5, une autre où le reste vaut 0, une dernière où le quotient vaut 0.
Indice
Une ligne assert vérifie une égalité, par exemple assert division(7, 2) == (3, 1). Pour un reste nul, choisir un dividende multiple du diviseur ; pour un quotient nul, un dividende plus petit que le diviseur.

Correction publiée après la séance.

Exercice 3 : manipulations guidées

3.1 Création et accès

Prévoir le résultat de chaque instruction, puis vérifier en Python :

a = (1, 2, 3)
b = 1, 2, 3
c = (1)
d = (1,)
e = tuple([1, 2])
f = ()

Quel est le type de chacune de ces variables ?
Indice
Pour vérifier, print(type(c)) affiche le type de c. Regarder de près c et d : qu’est-ce qui les distingue ?
Que vaut a == b ?
Que vaut a[1] ? Et a[-1] ?
Indice
Les indices d’un tuple fonctionnent comme ceux d’une liste : a[0] est le premier élément et a[-1] le dernier.

Correction publiée après la séance.

3.2 Déballage

Compléter le code suivant pour afficher les coordonnées d’un point :

point = (4.5, -2.3)
___, ___ = point
print(f"x = {___}, y = {___}")

Indice

Le déballage écrit, à gauche du =, autant de noms de variables que le tuple a d’éléments, séparés par une virgule. Ces variables s’affichent ensuite dans la f-string.

Correction publiée après la séance.

Exercice 4 : tuples et géométrie (mathématiques)

On représente un point du plan par un tuple (x, y).

Écrire une fonction milieu(A, B) qui prend deux points et renvoie le tuple des coordonnées du milieu du segment $[AB]$.
Rappel : $M = \left(\dfrac{x_A + x_B}{2},;, \dfrac{y_A + y_B}{2}\right)$
Indice
Déballer chaque point pour récupérer ses coordonnées : xA, yA = A. Renvoyer ensuite le tuple des deux moyennes.
Code à copier puis compléter
```
def milieu(A, B):
    xA, yA = A
    xB, yB = ...
    return (..., ...)
```
Écrire une fonction distance(A, B) qui calcule la distance entre deux points.
Rappel : $AB = \sqrt{(x_B - x_A)^2 + (y_B - y_A)^2}$
Indice
Même déballage que pour milieu. La racine carrée s’obtient avec sqrt, après from math import sqrt, et le carré avec ** 2.
Tester avec $A(1,;, 2)$ et $B(5,;, 8)$.
Indice
Appeler chaque fonction avec les deux points écrits comme des tuples, par exemple milieu((1, 2), (5, 8)), et afficher le résultat.

Correction publiée après la séance.

Exercice 5 : tuples et données structurées (sport)

On représente les résultats d’une compétition de natation par une liste de tuples (nom, temps_en_secondes) :

resultats = [
    ("Alice", 28.4),
    ("Bob", 25.1),
    ("Clara", 27.8),
    ("David", 24.9),
    ("Eva", 26.3),
]

Écrire une fonction gagnant(resultats) qui renvoie le nom du nageur ayant le meilleur temps (le plus petit).
Indice
Parcourir la liste en déballant chaque couple : for nom, temps in resultats:. Garder en mémoire le meilleur couple rencontré, celui qui a le plus petit temps, puis renvoyer son nom.
Code à copier puis compléter
```
def gagnant(resultats):
    meilleur = resultats[0]
    for nom, temps in resultats:
        if temps < ...:
            meilleur = (nom, temps)
    return ...
```
Écrire une fonction podium(resultats) qui renvoie un tuple de trois noms (premier, deuxième, troisième) correspondant aux trois meilleurs temps. Indication : construire la liste des couples (temps, nom), puis la trier avec sort(). Python compare deux tuples d’abord sur leur premier élément (ici le temps), puis sur le deuxième en cas d’égalité : la liste triée commence donc par le meilleur temps. Il reste à extraire les trois premiers noms.
Code à copier puis compléter
```
def podium(resultats):
    couples = []
    for nom, temps in resultats:
        couples.append((..., ...))
    couples.sort()
    return (couples[0][1], ..., ...)
```
Écrire une fonction ecart(resultats) qui renvoie l’écart en secondes entre le meilleur et le pire temps.
Indice
Chercher le plus petit et le plus grand temps en un seul parcours, comme dans gagnant, avec deux variables temps_min et temps_max qui partent du premier temps. L’écart est leur différence.

Correction publiée après la séance.

Exercice 6 : synthèse – statistiques sportives

On enregistre les performances de plusieurs athlètes lors d’un championnat d’athlétisme sous forme d’une liste de tuples (nom, épreuve, performance). La performance est en secondes pour les courses et en mètres pour les lancers.

courses = [
    ("Léa", "100m", 12.4),
    ("Karim", "100m", 11.8),
    ("Inès", "100m", 12.1),
    ("Théo", "100m", 11.5),
    ("Salma", "100m", 12.7),
]

Écrire une fonction classement(resultats) qui prend cette liste et renvoie une nouvelle liste de tuples (rang, nom, performance) triée par performance croissante (le meilleur temps en premier). Pour trier, construire la liste des couples (performance, nom) et la trier avec sort() : Python compare deux tuples d’abord sur leur premier élément, ici la performance. Numéroter ensuite les athlètes dans l’ordre obtenu.
Code à copier puis compléter
```
def classement(resultats):
    couples = []
    for nom, epreuve, perf in resultats:
        couples.append((..., ...))
    couples.sort()
    cl = []
    for i in range(len(couples)):
        perf, nom = couples[i]
        cl.append((..., ..., ...))
    return cl
```
Écrire une fonction ecart_premier(resultats) qui renvoie un tuple (nom_dernier, ecart) contenant le nom du dernier classé et son écart en secondes avec le premier.
Indice
Réutiliser classement : son premier tuple est celui du premier, son dernier (indice -1) celui du dernier. Chaque tuple contient (rang, nom, performance).
Écrire une fonction resume(resultats) qui affiche un tableau récapitulatif formaté avec le rang, le nom et le temps de chaque athlète, ainsi que l’écart avec le premier.
Indice
Parcourir le résultat de classement en déballant chaque tuple (rang, nom, perf) et afficher une ligne par athlète avec une f-string. L’écart vaut perf moins la performance du premier.

Correction publiée après la séance.

Exercice 7 : bulletin scolaire

On modélise les notes d’un élève par une liste de tuples (matière, note, coefficient).

notes = [
    ("Maths", 14, 7),
    ("NSI", 16, 6),
    ("Français", 12, 5),
    ("Anglais", 15, 3),
    ("EPS", 17, 2),
]

Écrire une fonction moyenne_ponderee(notes) qui calcule la moyenne pondérée, arrondie au centième.
Indice
La moyenne pondérée est la somme des produits note × coefficient, divisée par la somme des coefficients. Deux accumulateurs suffisent ; round(x, 2) arrondit au centième.
Code à copier puis compléter
```
def moyenne_ponderee(notes):
    total = 0
    total_coef = 0
    for matiere, note, coef in notes:
        total = total + ...
        total_coef = ...
    return round(..., 2)
```
Écrire une fonction meilleure_matiere(notes) qui renvoie le nom de la matière ayant la meilleure note.
Indice
Même principe que gagnant de l’exercice 5, avec la plus grande note au lieu du plus petit temps.
Écrire une fonction bulletin(notes) qui affiche une ligne par matière, puis la moyenne et la meilleure matière.
Indice
Une boucle affiche chaque matière avec sa note et son coefficient. Après la boucle, appeler moyenne_ponderee et meilleure_matiere pour les deux dernières lignes.

Correction publiée après la séance.

08 - Listes 10 - Tranches