Evaluation et consultation – Bac pratique – Section informatique – 2024
Sujet (Python et Qt Designer- Bac 2024)
Dans le cadre d'une initiative visant à renforcer les compétences en calcul mental des jeunes élèves, on envisage de développer un système composé de deux interfaces graphiques :
~ "Interface_Evaluation" (voir Fig1 de l’annexe) : destinée aux élèves, elle leur permet de tester leurs compétences dans le calcul d’expressions arithmétiques. Les réponses sont enregistrées dans un fichier d’enregistrements nommé "Evaluations.dat". Chaque enregistrement de ce fichier est formé des champs suivants :
id : Identifiant de l'élève.
exp : Expression arithmétique à résoudre.
rep : Réponse soumise par l'élève.
valid : Validité de la réponse (vrai/faux).
~ "Interface_Consultation" (voir Fig2 de l’annexe) : destinée aux enseignants, elle permet de faire le suivi des progrès des élèves. Elle affiche, pour le type d'opérateur sélectionné (+, -, *), les identifiants des élèves, les expressions évaluées relatives à cet opérateur, les réponses fournies et les résultats obtenus. Ces informations sont extraites du fichier "Evaluations.dat".
Les expressions arithmétiques à évaluer sont enregistrées dans un fichier texte nommé "Expressions.txt", à raison d’une expression par ligne. Chaque expression comporte un ou plusieurs opérateurs de même type.
Travail demandé :
1- En se basant sur la figure Fig1 de l’annexe, compléter l'interface graphique "ui" par les éléments manquants.
2- Apporter les modifications nécessaires au fichier "py" afin de réaliser les actions ci-après sachant que le module afficher, déjà développé, permet de vérifier la validité de l’identifiant (formé par 8 chiffres) puis d’afficher dans le label nommé labExp, une expression générée aléatoirement à partir du fichier "Expressions.txt".
a- Développer la fonction evaluer (ch) qui permet de retourner le résultat de calcul de l’expression ch. Cette dernière est une chaine de caractères représentant une expression arithmétique bien formatée, comportant uniquement des nombres et un seul type d'opérateur (+, -, *). Exemples : pour ch = "12+2000+100" ~ evaluer(ch) retourne 2112
pour ch = "200-5-50-100" ~ evaluer(ch) retourne 45
pour ch = "2*15" ~ evaluer(ch) retourne 30
NB : il est interdit d’utiliser les fonctions intégrées eval, exec et toute autre fonction équivalente.
b- Développer le module valide qui permet :
~ d’afficher un message d’erreur, conformément à la figure Fig3 de l’annexe, dans le cas où l'identifiant saisi est invalide ;
Ou bien
~ d’afficher un message d’erreur, conformément à la figure Fig4 de l’annexe, dans le cas où l’élève n’a pas fournie de réponse ;
Ou bien
- d’afficher dans le label nommé labRes le message "Réponse correcte" ou "Réponse erronée" en fonction de la validité de la réponse fournie (voir la figure Fig5 de l’annexe). La validité est obtenue en comparant la réponse fournie avec le résultat retourné par la fonction evaluer appliquée à l’expression à calculer ;
- d’ajouter à la fin du fichier "dat" l’enregistrement formé par l'identifiant saisi (id), l'expression affichée (exp), la réponse fournie par l’élève (rep) et sa validité (valid).
- En se basant sur la figure Fig2 de l’annexe, compléter l'interface graphique "ui" par les éléments manquants.
- Apporter les modifications nécessaires au fichier "py" afin de réaliser les actions suivantes :
- a) Compléter le programme principal (partie exploitation de l’interface graphique) par les noms des objets graphiques et des modules adéquats afin :
- de charger l’interface graphique depuis le fichier "ui" ;
- d’appeler le module nommé consulter suite au clic sur le bouton intitulé "Afficher".
- b) Développer le module consulter qui permet :
- de remplir l’objet "table Widget" par les enregistrements du fichier "dat" dont le champ exp contient l'opérateur sélectionné dans la liste déroulante. Pour la colonne Résultat, afficher "réponse correcte" ou "réponse erronée" selon la valeur du champ "valid" (voir Fig6 de l’annexe).
NB : On pourra utiliser les méthodes suivantes :
- setRowCount(nbrelignes)
- insertRow(numligne)
- setItem(numligne, numcolonne, QTableWidgetItem("valeur"))
- d’afficher dans le label nommé labNb le nombre de réponses correctes relatives à l’opérateur sélectionné dans la liste déroulante (voir Fig6 de l’annexe).
L'interface graphique avec Qt Designer
a- Ouvrez Qt Designer et créez un nouveau fichier de type Main Window.
b- Ajoutez ces widgets :
- QLabel contenant le texte "Donner la valeur de x :".
- QLineEdit : zone de saisie pour saisir une valeur de x.
- QPushButton : bouton intitulé "Ajouter".
- QPushButton : bouton intitulé "Afficher Racines".
- QTableWidget : table widget contenant deux colonnes "Nombre" et "Racine carrée" pour afficher le contenu du fichier "Approchee.dat".
Solution en Python
|
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 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 |
from PyQt5.QtWidgets import * from PyQt5.uic import * from pickle import dump, load # -------------------------------------------------- # Dictionnaire représentant un enregistrement # contenant : # - x : la valeur saisie # - racine : la racine carrée approchée de x # -------------------------------------------------- enregistrement = dict( x=int(), racine=float() ) # -------------------------------------------------- # Fonction qui détermine un entier p tel que : # p² ≤ x < (p+1)² # (estimation initiale pour le calcul de la racine) # -------------------------------------------------- def determiner_p(x): p = 2 while p * p <= x: p = p + 1 return p - 1 # -------------------------------------------------- # Fonction qui calcule une valeur approchée # de la racine carrée de x par la méthode de Héron # (méthode de Newton) # -------------------------------------------------- def calcul_racine(x, p, epsilon): u0 = p # Valeur initiale u1 = 0.5 * (u0 + x / u0) # Première approximation # Amélioration de l'approximation jusqu'à précision epsilon while abs(u1 - u0) > epsilon: u0 = u1 u1 = 0.5 * (u0 + x / u0) return u1 # -------------------------------------------------- # Procédure qui : # - vérifie la validité de la saisie # - calcule la racine approchée # - enregistre les résultats dans le fichier Approchee.dat # -------------------------------------------------- def remplir_fichier_approchee(): # Vérifier si le champ x est vide if w.x.text() == "": QMessageBox.critical(w, "Erreur", "Veuillez saisir une valeur pour x") # Vérifier si x est dans l'intervalle [2, 200] elif not (2 <= float(w.x.text()) <= 200): QMessageBox.critical(w, "Erreur", "Veuillez saisir une valeur entre 2 et 200") else: # Ouverture du fichier en mode ajout binaire f_approchee = open("Approchee.dat", "ab") # Récupération de la valeur saisie x = float(w.x.text()) # Détermination de p et calcul de la racine p = determiner_p(x) racine = calcul_racine(x, p, 0.00001) # Remplissage de l'enregistrement enregistrement["x"] = x enregistrement["racine"] = racine # Écriture dans le fichier dump(enregistrement, f_approchee) # Fermeture du fichier f_approchee.close() # -------------------------------------------------- # Procédure qui lit le fichier Approchee.dat # et affiche son contenu dans un QTableWidget # -------------------------------------------------- def afficher_fichier_approchee(): # Ouverture du fichier en lecture binaire f_approchee = open("Approchee.dat", "rb") row_index = 0 # Lecture séquentielle du fichier while True: try: # Lecture d'un enregistrement enregistrement = load(f_approchee) # Ajout d'une nouvelle ligne dans le tableau w.racine_widget.setRowCount(row_index + 1) # Affichage des valeurs dans le tableau w.racine_widget.setItem(row_index, 0, QTableWidgetItem(str(enregistrement["x"]))) w.racine_widget.setItem(row_index, 1, QTableWidgetItem(str(enregistrement["racine"]))) row_index = row_index + 1 except EOFError: # Fin du fichier atteinte break # Fermeture du fichier f_approchee.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- # Création de l'application Qt app = QApplication([]) # Chargement de l'interface graphique w = loadUi("interface_racine.ui") w.show() # Association des boutons aux procédures w.ajouter.clicked.connect(remplir_fichier_approchee) w.afficher.clicked.connect(afficher_fichier_approchee) # Lancement de l'application app.exec() |
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
