Aller au contenu

Une course☘

Après une course, on dispose d'un tuple constitué de tuples. Chaque tuple est de la forme (numéro de dossard, nom, prénom, (heure, minute, seconde)) où le tuple (heure, minute, seconde) correspond au temps mis par ce candidat pour finir la course.

Par exemple:

une_course = ( (1, 'Labrosse', 'Adam', (3,45, 23)), 
(2, 'Gemlamorte', 'Adèle', (4, 12, 29)), 
(4, 'Etpan', 'Ahmed', (3, 32, 43)), 
(5, 'Térieur', 'Alain', (4, 21, 55)), 
(3, 'Auboisdormant', 'Abel', (2, 5, 12)),
(7, 'Tanrien', 'Jean', (3, 42, 10)),
(8, 'Ouzi', 'Jacques', (3, 32, 9)),
(9, 'Deuf', 'John', (5, 40, 7)),
(10, 'Provist', 'Alain', (3,45, 33)),
(6, 'Térieur', 'Alex', (2, 34, 49))
)

Comprendre l'objet ci-dessus☘

Question☘

Quelle est la valeur de une_course[1] ?

Solution

Il s'agit de l'élément d'indice 1 du tuple une_course. Cet élément d'indice 1 est lui-même un tuple:

(2, 'Gemlamorte', 'Adèle', (4, 12, 29))

Question☘

Comment récupérer le numéro de dossard et le nom du coureur ayant l'indice 2 dans le tuple une_course ?

Solution

On récupère le coureur concerné:

>>> coureur = une_course[2]
>>> coureur
(4, 'Etpan', 'Ahmed', (3, 32, 43))

On peut ensuite par exemple définir le couple (numéro de dossard, nom) de ce coureur comme suit:

>>> dossard, nom = coureur[0], coureur[1]
>>> dossard, nom
(4, 'Etpan')

On peut procéder en une seule étape:

>>> dossard, nom = (une_course[2][0], une_course[2][1])
>>> dossard, nom
(4, 'Etpan')

Question☘

Comment récupérer la partie "minutes" du temps mis par le coureur d'indice 0 dans le tuple une_course ?

Solution

On récupère d'abord le tuple d'indice 0:

>>> t = une_course[0]
(1, 'Labrosse', 'Adam', (3, 45, 23))

Ensuite on récupère dans ce tuple t le triplet correspondant au temps:

>>> t = une_course[0]
>>> temps = t[3]
>>> temps
(3, 45, 23)

On peut maintenant récupérer la partie minutes:

>>> t = une_course[0]
>>> temps = t[3]
>>> minutes = temps[1]
>>> minutes
45

On peut bien sûr procéder en une seule étape:

>>> une_course[0][3][1]
45

Question☘

Comment récupérer le nom du coureur ayant le dossard 3 dans une_course ?

Solution

Cette fois, le coureur est identifié par son dossard et non par son indice dans le tuple. On n'a donc pas d'accès direct. On va donc parcourir le tuple une_course jusqu'à "tomber" sur le coureur de dossard 3 et on récupèrera alors son nom.

for c in une_course:
    if c[0] == 3:
        coureur = c
nom = coureur[1]

On vérifie alors que la variable nom désigne la valeur 'Auboisdormant' (en l'affichant par exemple).

Des longueurs☘

Quelles sont les valeurs de len(une_course), de len(une_course[0]), de len(une_course[0][1]), de len(une_course[0][3]) ?

Solution
  • len(une_course) est le nombre d'éléments dans le tuple une_course, il y en a 10.
  • len(une_course[0]) est la longueur du tuple (1, 'Labrosse', 'Adam', (3,45, 23)), c'est à dire 4.
  • len(une_course[0][1]) est la longueur de la chaîne 'Labrosse' , c'est à dire 8.
  • len(une_course[0][3]) est la longueur du tuple (3,45, 23), c'est à dire 3.

Obtenir le temps en seconde☘

Ecrire un corps possible pour la fonction suivante:

def temps_en_seconde(course, dossard):
    """
    course: un tuple tel que le précédent, résultant d'une course.
    dossard: un numéro de dossard
    renvoie le temps en seconde réalisé par le coureur portant ce dossard
    """
Solution
def temps_en_seconde(course, dossard):
    """
    course: un tuple tel que le précédent, résultant d'une course.
    dossard: un numéro de dossard
    renvoie le temps en seconde réalisé par le coureur portant ce dossard
    """
    for coureur in course:
        if coureur[0] == dossard:
            heures = coureur[3][0]
            minutes = coureur[3][1]
            secondes = coureur[3][2]
    return heures*3600 + minutes*60 + secondes

Liste des noms avec temps en seconde☘

Ecrire un corps possible pour la fonction ci-dessous:

def liste_temps(course):
    """
    course: un tuple tel que le précédent, résultant d'une course.
    renvoie un tuple contenant 
    les triplets (nom, prénom, temps en seconde) 
    """
Solution
def liste_temps(course):
    """
    course: un tuple tel que le précédent, résultant d'une course.
    renvoie un tuple contenant les triplets (nom, prénom, temps en seconde) 
    """
    resultat = tuple()
    for coureur in course:
        ajout = (coureur[1], coureur[2], temps_en_seconde(course, coureur[0]))
        resultat += (ajout, )
    return resultat

Essai avec la course donnée en début de page:

liste_temps(une_course)

donne 

(('Labrosse', 'Adam', 13523),
('Gemlamorte', 'Adèle', 15149),
('Etpan', 'Ahmed', 12763),
('Térieur', 'Alain', 15715),
('Auboisdormant', 'Abel', 7512),
('Tanrien', 'Jean', 13330),
('Ouzi', 'Jacques', 12729),
('Deuf', 'John', 20407),
('Provist', 'Alain', 13533),
('Térieur', 'Alex', 9289))
En compréhension

En définissant le tuple demandé en compréhension:

def liste_temps_comp(course):
    """
    course: un tuple tel que le précédent, résultant d'une course.
    renvoie un tuple contenant les triplets (nom, prénom, temps en seconde) 
    """
    return tuple((coureur[1], coureur[2], temps_en_seconde(course, coureur[0])) for coureur in course)

Gagnant☘

Ecrire un corps possible pour la fonction ci-dessous:

def gagnant(course):
    """
    course: un tuple tel que le précédent, résultant d'une course.
    renvoie le triplet (dossard, nom, prénom) 
    du coureur ayant fait le meilleur temps. 
    """

Fonction de test:

def test_gagnant():
    une_course = ( (1, 'Labrosse', 'Adam', (3,45, 23)), 
    (2, 'Gemlamorte', 'Adèle', (4, 12, 29)), 
    (4, 'Etpan', 'Ahmed', (3, 32, 43)), 
    (5, 'Térieur', 'Alain', (4, 21, 55)), 
    (3, 'Auboisdormant', 'Abel', (2, 5, 12)),
    (7, 'Tanrien', 'Jean', (3, 42, 10)),
    (8, 'Ouzi', 'Jacques', (3, 32, 9)),
    (9, 'Deuf', 'John', (5, 40, 7)),
    (10, 'Provist', 'Alain', (3,45, 33)),
    (6, 'Térieur', 'Alex', (2, 34, 49))
    )
    assert gagnant(une_course) == (3, 'Auboisdormant', 'Abel')
Solution
def gagnant(course):
    """
    course: un tuple tel que le précédent, résultant d'une course.
    renvoie le triplet (dossard, nom, prénom) du coureur ayant fait le meilleur temps. 
    """
    meilleur_coureur = course[0]
    meilleur_temps = temps_en_seconde(course, meilleur_coureur[0])
    for coureur in course:
        if temps_en_seconde(course, coureur[0]) < meilleur_temps:
            meilleur_coureur = coureur
            meilleur_temps = temps_en_seconde(course, meilleur_coureur[0])
    return (meilleur_coureur[0], meilleur_coureur[1], meilleur_coureur[2])

Test sur la course de début de page:

gagnant(une_course)

donne:

(3, 'Auboisdormant', 'Abel')

Sélection☘

La course permettait de sélectionner les coureurs pour un championnat. Les coureurs sélectionnés sont les coureurs ayant réalisé un temps d'au plus 3h40.

Ecrire un corps possible pour la fonction ci-dessous:

def selectionner(course):
    """
    course: un tuple tel que le précédent, résultant d'une course.
    renvoie le tuple 
    constitué des uplets (nom, prénom, triplet temps) 
    des coureurs sélectionnés. 
    """

Fonction de test:

def test_selectionner():
    une_course = ( (1, 'Labrosse', 'Adam', (3,45, 23)), 
    (2, 'Gemlamorte', 'Adèle', (4, 12, 29)), 
    (4, 'Etpan', 'Ahmed', (3, 32, 43)), 
    (5, 'Térieur', 'Alain', (4, 21, 55)), 
    (3, 'Auboisdormant', 'Abel', (2, 5, 12)),
    (7, 'Tanrien', 'Jean', (3, 42, 10)),
    (8, 'Ouzi', 'Jacques', (3, 32, 9)),
    (9, 'Deuf', 'John', (5, 40, 7)),
    (10, 'Provist', 'Alain', (3,45, 33)),
    (6, 'Térieur', 'Alex', (2, 34, 49))
    )
    assert selectionner(une_course) == (('Etpan', 'Ahmed', (3, 32, 43)),
     ('Auboisdormant', 'Abel', (2, 5, 12)),
     ('Ouzi', 'Jacques', (3, 32, 9)),
     ('Térieur', 'Alex', (2, 34, 49)))
Solution
def selectionner(course):
    """
    course: un tuple tel que le précédent, résultant d'une course.
    renvoie le tuple 
    constitué des uplets (nom, prénom, triplet temps) 
    des coureurs sélectionnés. 
    """
    couperet = 3*3600 + 40*60
    selection = tuple()
    for coureur in course:
        temps = temps_en_seconde(course, coureur[0])
        if temps <= couperet:
            ajout = (coureur[1], coureur[2],  coureur[3])
            selection += (ajout, )
    return selection

Test avec la course de début de page:

selectionner(une_course)

donne: 

(('Etpan', 'Ahmed', (3, 32, 43)),
 ('Auboisdormant', 'Abel', (2, 5, 12)),
 ('Ouzi', 'Jacques', (3, 32, 9)),
 ('Térieur', 'Alex', (2, 34, 49)))
En compréhension
def selectionner_comp(course):
    """
    course: un tuple tel que le précédent, résultant d'une course.
    renvoie le tuple 
    constitué des uplets (nom, prénom, triplet temps) 
    des coureurs sélectionnés. 
    """
    couperet = 3*3600 + 40*60
    return tuple((c[1], c[2], c[3]) for c in course if temps_en_seconde(course, c[0]) <= couperet)

Même prénom☘

Ecrire un corps possible pour la fonction:

def meme_prenom(course, prenom):
    """
    renvoie le tuple constitué
    des triplets (nom, prénom, dossard)
    des coureurs ayant pour prénom prenom.
    """
Solution
def meme_prenom(course, prenom):
    """
    renvoie le tuple constitué
    des triplets (nom, prénom, dossard)
    des coureurs ayant pour prénom prenom.
    """
    resultat = tuple()
    for c in course:
        if c[2] == prenom:
            ajout = (c[1], c[2], c[0])
            resultat += (ajout,)
    return resultat

>>> meme_prenom(une_course, "Alain")
(('Térieur', 'Alain', 5), ('Provist', 'Alain', 10))
En compréhension

En définissant le tuple demandé en compréhension:

def meme_prenom_comp(course, prenom):
    """
    renvoie le tuple constitué
    des triplets (nom, prénom, dossard)
    des coureurs ayant pour prénom prenom.
    """
    return tuple((c[1], c[2], c[0]) for c in course if c[2] == prenom)

L'ensemble☘

Vous trouverez l'ensemble des fonctions de cette page dans cette feuille ipynb (à ouvrir, rappelons le, avec jupyter notebook ou en ligne avec le notebook basthon).