Laboratoire boucles - solution

But

• Maîtriser les boucles.

• Consolider la matière vue précédemment.

• Continuer à utiliser les fonctions.

Énoncé

Pour chaque exercice, vous devez également :

• Créer le pseudo code ou l'organigramme avant de le traduire en code Python.

• Créer un plan de tests et bien tester son programme.

• Utiliser le débogueur au besoin.

Exercice 1

Il s'agit de faire un jeu à 2 joueurs pour deviner un nombre. Le premier joueur devra entrer le nombre à faire deviner et le second tentera de trouver le nombre. Pour aider, le programme devra indiquer s'il faut monter ou descendre. Le pointage final équivaut au nombre de tentatives.

Suggestion :

Pour faire "disparaître" le nombre choisi par le premier joueur, effectuer 100 print vide après avoir obtenu le nombre.

Solution

#################### Pseudo code - fonction deviner_nombre ####################
# Paramètres d'entrée de la fonction : nomre_a_deviner
# Sortie : aucun (on affiche le résultat)
##############################################################################
#Demander au joueur de proposer un nombre 
#Tant que nombre != nombre_a_deviner#  
#    Si le nombre proposé == nombre à deviner
#         On a trouvé le nombre, donc on sort de la boucle (break)
#    Sinon
#         Si le nombre proposé est < nombre à deviner
#             Dire à l'utilisateur de proposer un nombre plus grand
#         Sinon
#             Dire à l'utilisateur de proposer un nombre plus petit.
#
#    Demander au joueur de proposer un nombre
#
# Afficher le Bravo, avec la bonne réponse et le score
###############################################################################


########################## Pseudo-code programme principal ##########################
Demander à l'utilisateur le nombre à faire deviner et le mettre dans la variable nombre_gagnant. 
Laisser 100 lignes vides.
Appeler la fonction : deviner_nombre(nombre_gagnant)
###############################################################################

def deviner_nombre(nombre_a_deviner:int):
    """
    Fonction qui permet de guider l'utilisateur
    à deviner un nombre passé en paramètres.
    :param nombre_a_deviner: Le nombre à deviner.
    :return: Aucun
    """

    score = 0
    trouve = False

    while not trouve:
        score += 1

        nombre_propose = int(input(f"Tentative {score}: Quel nombre tentez-vous? "))

        if nombre_propose == nombre_gagnant:
            trouve = True
        else:
            if nombre_propose < nombre_a_deviner:
                print("Le nombre est plus haut")
            else:
                print("Le nombre est plus petit")

    print("*******************************")
    print(f"Bravo! La bonne réponse était {nombre_gagnant}")
    print(f"Votre score est de {score}")


if __name__ == "__main__":
    nombre_gagnant = int(input("Quel est le nombre à faire deviner? "))
    print("\n" * 100)

    deviner_nombre(nombre_gagnant)

Exercice 2

Imaginez que vous développez un programme pour une application de gestion de prêts. Vous devez développer un programme qui aidera les utilisateurs à suivre le remboursement de leurs dettes. Le remboursement de la dette peut-être fait en plusieurs fois. L'utilisateur doit fournir des montants de remboursement jusqu'à ce que la dette soit entièrement payée ou que l'utilisateur entre une valeur non numérique.

À la fin du processus, le programme doit afficher le nombre total de paiements effectués.

Résultat attendu :

Quel est le montant de la dette? 4000
Dette: 4000.0$. Combien voulez-vous rembourser? 2500
Dette: 1500.0$. Combien voulez-vous rembourser? 1000
Dette: 500.0$. Combien voulez-vous rembourser? 500
Dernier remboursement de 500.0 $ effectué
********************
Nombre de paiements:     3
Montant total remboursé: 4000.0 $
********************

Solution

################################## pseudo-code fonction remboursements_dette #########################################
# paramètres d'entrée : dette
# Valeur de retour (sortie) : aucun (affichage)
######################################################################################################################
# nb_remboursement = 0
# total_remboursements = dette
#
# Tant que la dette n'est pas totalement remboursée (dette > 0) ou que utilisateur entre une valeur non numérique ()
#       Demander montant de remboursement à l'utilisateur : remboursement
#       Si remboursement < 0 alors
#           Afficher qu'il est impossible de faire le remboursement.
#           On ignore la suite des instruction et on re-boucle
#       Sinon si remboursement >= dette, alors
#           dette = 0
#           Incrémenter le nombre de remboursement : nb_remboursement = nb_remboursement + 1
#       Sinon
#           Mettre à jour la dette avec le montant remboursé : dette = dette - remboursement
#           Incrémenter le nombre de remboursement : nb_remboursement = nb_remboursement + 1
#
######################################################################################################################
############################ programme principal #####################################################################
# Lire le montant de la dette
# Appeler la fonction remboursements_dette(dette)
######################################################################################################################

• Code Python

def remboursements_dette(dette : float):
    nb_remboursements = 0
    total_remboursements = dette

    while dette > 0:
        remboursement_str = input(f"Dette: {dette}$. Combien voulez-vous rembourser? ")

        if remboursement_str.isalpha():
            break

        remboursement = float(remboursement_str)

        if remboursement < 0 :
            print("Impossible de faire le remboursement, nombre négatif!")
            continue

        elif remboursement >= dette:
            print(f"Dernier remboursement de dette ({dette}) effectué.")
            dette = 0
            nb_remboursements += 1
        else:
            dette -= remboursement
            nb_remboursements += 1

    total_remboursements = total_remboursements - dette

    print("*" * 20)
    print(f"Nombre de paiements:     {nb_remboursements}")
    print(f"Montant total remboursé: {total_remboursements} $")
    print("*" * 20)


if __name__ == "__main__":
    dette = float(input("Quel est le montant de la dette? "))
    remboursements_dette(dette)

Exercice 3

Imaginez que vous travaillez sur un projet de suivi climatique pour une station météorologique. Le programme doit permettre à l'utilisateur d'entrer des températures successivement. Lorsque l'utilisateur souhaite terminer, il devra entrer le mot "arrêt".

À la fin, le programme affichera la température la plus basse, la température la plus haute et la température moyenne parmi celles qui ont été saisies.

Entrez une température (ou 'arrêt' pour finir) : 25
Entrez une température (ou 'arrêt' pour finir) : 18
Entrez une température (ou 'arrêt' pour finir) : 22
Entrez une température (ou 'arrêt' pour finir) : arrêt

La température la plus basse est : 18
La température la plus élevée est : 25
La température moyenne est : 21.67

Solution

def calculer_min(temp_min, temperature):
    """
    Fonction qui retourne la température minimale entre la nouvelle température
    et la température minimale actuelle.

    :param temp_min: Température minimale actuelle.
    :param temperature: Nouvelle température.
    :return: La température minimale mise à jour.
    """

    if temperature < temp_min:
        temp_min = temperature

    # Notez qu'il est possible de trouver la plus petite
    # température avec la fonction min()
    # temp_min = min(temp_min, temperature)

    return temp_min

def calculer_max(temp_max, temperature):
    """
    Fonction qui retourne la température maximale entre la nouvelle température
    et la température maximale actuelle.

    :param temp_max: Température maximale actuelle.
    :param temperature: Nouvelle température.
    :return: La température maximale mise à jour.
    """

    if temperature > temp_max:
        temp_max = temperature

    # Notez qu'il est possible de trouver la plus grande
    # température avec la fonction max : max()
    # temp_max = max(temp_max, temperature)

    return temp_max

def calculer_somme(cumul_temp, temperature):
    """
    Cette fonction met à jour le cumul des températures en ajoutant une nouvelle
    valeur de température au cumul existant.

    :param cumul_temp: Le cumul actuel des températures.
    :param temperature: La nouvelle température à ajouter au cumul.
    :return: Le nouveau cumul des températures après l'ajout.
    """
    cumul_temp += temperature

    return cumul_temp

def calculer_moyenne(total, nb_valeurs):
    """
    Fonction qui calcule et retourne la moyenne des températures.

    :param total: La somme des températures.
    :param count: Le nombre total de températures.
    :return: La moyenne des températures.
    """

    moyenne = total / nb_valeurs
    return moyenne


def afficher_statistiques(temp_min, temp_max, temp_moyenne):
    """
    Fonction qui affiche les statistiques des températures.

    :param temp_min: Température minimale.
    :param temp_max: Température maximale.
    :param temp_moyenne: Température moyenne.
    """
    print(f"Température minimum : {temp_min}")
    print(f"Température maximum : {temp_max}")
    print(f"Température moyenne : {temp_moyenne}")


if __name__ == "__main__":
    temp_min = float('inf')
    temp_max = float('-inf')
    total_temp = 0
    compteur = 0

    temperature_str = input("Veuillez entrer une température : ")

    while temperature_str != "arrêt" :

        temperature = float(temperature_str)

        temp_min = calculer_min(temp_min, temperature)
        temp_max = calculer_max(temp_max, temperature)
        total_temp = calculer_somme(total_temp, temperature)
        compteur += 1

        temperature_str = input("Veuillez entrer une température : ")


    temp_moyenne = calculer_moyenne(total_temp, compteur)
    afficher_statistiques(temp_min, temp_max, temp_moyenne)