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).
3- En se basant sur la figure Fig2 de l’annexe, compléter l'interface graphique "ui" par les éléments manquants.
4- 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).
Quelques captures d'écran montrant des exemples d'exécutions :
L'interface graphique "Interface_Evaluation.ui"
a- Ouvrez Qt Designer et créez un nouveau fichier de type Main Window.
b- Ajoutez ces widgets :
- QLineEdit : nommé "txid" pour saisir l'identificateur de l'élève.
- QPushButton : bouton intitulé "btnExp" pour générer l'opération mathématique.
- QLabel nommé "lapExp" contenant l'opération mathématique.
- QLineEdit : nommé "reponse" pour saisir la réponse de l'élève.
- QPushButton : nommé "btnRes" pour lancer la validation de la réponse de l'élève.
- QLabel nommé "lapRes" contenant le résultat de la comparaison entre la réponse saisie et le résultat correct.
Contenu du fichier Evaluation.py
|
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 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 |
# Importation des widgets PyQt5 (boutons, labels, zones de texte, etc.) from PyQt5.QtWidgets import * # Importation de la fonction loadUi pour charger l’interface graphique (.ui) from PyQt5.uic import * # Importation des fonctions de génération aléatoire from random import * # Importation des fonctions dump et load pour la sérialisation (pickle) from pickle import dump, load # -------------------------------------------------- # Enregistrement représentant les informations d’un élève # -------------------------------------------------- eleve = dict( id=str(), # Identifiant de l’élève exp=str(), # Expression proposée rep=int(), # Réponse saisie par l’élève valid=str() # Résultat de validation (correct / erroné) ) # -------------------------------------------------- # Fonction de vérification de l’identifiant # -------------------------------------------------- def verifid(id): ''' Cette fonction vérifie si l’identifiant saisi est composé exactement de 8 chiffres. ''' return (id.isdecimal() and len(id) == 8) # -------------------------------------------------- # Fonction de génération d’une expression arithmétique # -------------------------------------------------- def generer(): ''' Cette fonction génère aléatoirement une expression arithmétique à partir du fichier "Expressions.txt". ''' f = open("Expressions.txt", "r") n = randint(1, 20) # 20 correspond au nombre d'expressions dans le fichier # Lecture de la nième ligne du fichier for i in range(n): e = f.readline() f.close() return e # -------------------------------------------------- # Fonction d’affichage de l’expression # -------------------------------------------------- def afficher(): global e ''' Cette procédure affiche une expression arithmétique dans le label labExp si l’identifiant est valide. ''' id = fen.txtid.text() # Vérification de l’identifiant if not verifid(id): QMessageBox.critical( fen, 'Erreur', "Veuillez saisir un identifiant valide composé de 8 chiffres" ) else: e = generer() fen.labExp.setText(e) # -------------------------------------------------- # Fonction de calcul du résultat d’une expression # -------------------------------------------------- def resultat_expression(ch): ''' Cette fonction calcule le résultat d’une expression arithmétique contenant uniquement +, - ou *. ''' # Cas de l’addition if ch.find('+') != -1: somme = 0 while ch.find('+') != -1: nbr1 = ch[0:ch.find('+')] somme += int(nbr1) ch = ch[ch.find('+') + 1:] somme += int(ch) return somme # Cas de la multiplication elif ch.find('*') != -1: produit = 1 while ch.find('*') != -1: nbr1 = ch[0:ch.find('*')] produit *= int(nbr1) ch = ch[ch.find('*') + 1:] produit *= int(ch) return produit # Cas de la soustraction elif ch.find('-') != -1: nbr1 = ch[0:ch.find('-')] soustraction = int(nbr1) ch = ch[ch.find('-') + 1:] while ch.find('-') != -1: nbr1 = ch[0:ch.find('-')] soustraction -= int(nbr1) ch = ch[ch.find('-') + 1:] soustraction -= int(ch) return soustraction # -------------------------------------------------- # Procédure de validation de la réponse de l’élève # -------------------------------------------------- def valide(): ''' Cette procédure vérifie la réponse de l’élève, affiche le résultat et enregistre les données dans le fichier "Evaluation.dat". ''' e = fen.labExp.text() # Vérification de la génération de l’expression if e == '': QMessageBox.critical(fen, 'Erreur', "Veuillez générer une expression") else: reponse = fen.reponse.text() # Vérification de la saisie de la réponse if reponse == '': QMessageBox.critical(fen, 'Erreur', "Veuillez saisir une réponse") else: # Comparaison entre la réponse saisie et le résultat correct if int(reponse) == int(resultat_expression(e)): fen.labRes.setText("Réponse correcte") else: fen.labRes.setText("Réponse erronée") # Enregistrement des données dans le fichier binaire f_evaluation = open("Evaluation.dat", "ab") eleve['id'] = fen.txtid.text() eleve['exp'] = e eleve['rep'] = reponse eleve['valid'] = fen.labRes.text() dump(eleve, f_evaluation) f_evaluation.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- app = QApplication([]) # Chargement de l’interface graphique fen = loadUi("Interface_Evaluation.ui") fen.show() # Association des boutons aux fonctions fen.btnExp.clicked.connect(afficher) fen.btnRes.clicked.connect(valide) # Lancement de l’application app.exec() |
L'interface graphique "Interface_Consultation.ui"
a- Ouvrez Qt Designer et créez un nouveau fichier de type Main Window.
b- Ajoutez ces widgets :
- QQCombobox : nommé "cmbOp" pour choisir l'opération mathématique.
- QPushButton : bouton intitulé "btnAff" pour afficher les réponses des élèves.
- QTableWidget nommé "consultation_Widget" contenant les réponses des élèves.
- QLabel nommé "lapNb" contenant le nombre des réponses correctes.
Contenu du fichier Consultation.py
|
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 |
# Importation des composants graphiques PyQt5 from PyQt5.QtWidgets import * # Importation de la fonction loadUi pour charger l’interface graphique from PyQt5.uic import * # Importation de la fonction load pour lire des données depuis un fichier binaire from pickle import load # -------------------------------------------------- # Dictionnaire représentant les informations d’un élève # -------------------------------------------------- eleve = dict( id=str(), # Identifiant de l’élève exp=str(), # Expression arithmétique rep=int(), # Réponse saisie par l’élève valid=str() # Résultat (correcte / erronée) ) # -------------------------------------------------- # Fonction d’affichage des évaluations # -------------------------------------------------- def afficher(): ''' Cette procédure affiche dans le tableau graphique les évaluations correspondant à l’opération choisie dans la liste déroulante (addition, soustraction, etc.). ''' # Ouverture du fichier binaire contenant les évaluations f_evaluation = open("Evaluation.dat", "rb") # Indice de ligne du QTableWidget row_index = 0 # Récupération de l’opération sélectionnée dans le ComboBox operation = fen.cmbOp.currentText() # Lecture séquentielle du fichier jusqu’à la fin while True: try: # Lecture d’un enregistrement (dictionnaire élève) eleve = load(f_evaluation) # Vérification si l’expression contient l’opération choisie if eleve["exp"].find(operation) != -1: # Mise à jour du nombre de lignes du tableau fen.consultation_Widget.setRowCount(row_index + 1) # Remplissage des cellules du tableau fen.consultation_Widget.setItem( row_index, 0, QTableWidgetItem(eleve["id"]) ) fen.consultation_Widget.setItem( row_index, 1, QTableWidgetItem(eleve["exp"]) ) fen.consultation_Widget.setItem( row_index, 2, QTableWidgetItem(str(eleve["rep"])) ) fen.consultation_Widget.setItem( row_index, 3, QTableWidgetItem(eleve["valid"]) ) # Passage à la ligne suivante row_index = row_index + 1 except EOFError: # Fin du fichier atteinte break # Fermeture du fichier f_evaluation.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- app = QApplication([]) # Chargement de l’interface graphique fen = loadUi("Interface_Consultation.ui") fen.show() # Association du bouton à la fonction afficher fen.btnAff.clicked.connect(afficher) # 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
