Evaluation et consultation – Bac pratique – Section informatique – 2025

Bac Info 27-01-26

19 0

Sujet (Python et Qt Designer - Bac 2025)

Dans le but de faciliter l’évaluation automatique en programmation, on se propose de concevoir une application intégrant deux interfaces graphiques :

"Interface_Candidat.ui" (voir la figure Fig.1 de l’annexe) : destinée aux candidats et permet de tester leurs compétences en programmation. Les réponses des candidats sont enregistrées dans un fichier d’enregistrements nommé "Reponses.dat". Chaque enregistrement de ce fichier est formé des champs suivants :

- NCIN : Le numéro de la carte d’identité nationale d’un candidat qui doit être formé de 8 chiffres et commence obligatoirement par 0 ou 1.

- NomPrenom : Le nom et le prénom d’un candidat doit être une chaine de caractères non vide composée uniquement de lettres et d’espaces.

- Score : Le score obtenu par un candidat.

"Interface_Consultation.ui" (voir la figure Fig.2 de l’annexe) : destinée aux évaluateurs et permet de consulter les scores réalisés par les candidats.

Travail demandé :

1- En se basant sur la figure 1 de l’annexe, compléter l’interface graphique "Interface_Candidat.ui" par les éléments "Line Edit" et "Label" manquants.

2- Apporter les modifications nécessaires au fichier "py" afin de réaliser les actions suivantes :

a) Développer le module "Verif" qui permet de tester la validité des informations saisies et d’afficher un message d’erreur (voir les figures 3 et Fig.4 de l’annexe) selon les contraintes indiquées dans le tableau suivant :

b) Développer le module "Ajouter" qui s’exécute suite au clic sur le bouton "Valider" et qui permet :

- de récupérer le NCIN et le NomPrenom d’un candidat et de faire appel au module "Verif" pour les valider,

- de calculer et d’afficher, dans le label dédié à l’affichage, le Score obtenu par le candidat (voir la figure Fig.5 de l’annexe),

- d’ajouter les informations du candidat (NCIN, NomPrenom et Score) dans le fichier "Reponses.dat".

NB : Le score d’un candidat est obtenu en additionnant les notes attribuées aux réponses du candidat selon le barème indiqué pour chaque question (voir la figure Fig.1 de l’annexe), sachant que :

- pour la question 1, les cases "Décimal" et "Hexadécimal" doivent être cochées

- pour la question 2, la première proposition doit être cochée

- pour la question 3, la réponse correcte est "40"

c) Compléter le programme principal par le nom de l’interface, les noms du bouton et du module adéquats.

- En se basant sur la figure 2 de l’annexe, compléter l’interface graphique "Interface_Consultation.ui" par les éléments manquants.

- Apporter les modifications nécessaires au fichier "py" afin de développer le module "Afficher" qui s’exécute suite au clic sur le bouton "Afficher" et qui permet d’afficher dans l’objet "Table Widget" la liste des candidats admis dans l’ordre croissant du Score, sachant qu’un candidat est déclaré admis si son Score est supérieur ou égal à 3. Pour chaque candidat admis, on affiche le NCIN, le NomPrenom et le Score (voir la figure Fig.6 de l’annexe).

Annexe :

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é "cin" pour saisir l'identificateur de l'élève.

- QLineEdit : nommé "nom_prenom" pour saisir le nom et le prénom de l'élève.

- QCheckBox : case intitulé "cb1" contenant la première proposition de la question N°1.

- QCheckBox : case intitulé "cb2" contenant la deuxième proposition de la question N°1.

- QCheckBox : case intitulé "cb3" contenant la troisième proposition de la question N°1.

- QCheckBox : case intitulé "rb1" contenant la première proposition de la question N°2.

- QCheckBox : case intitulé "rb2" contenant la deuxième proposition de la question N°2.

- QLabel nommé "lapExp" contenant l'opération mathématique.

- QPushButton : nommé "Valider" pour lancer la validation de la réponse de l'élève.

- QLabel nommé "lapScore" contenant le score.

Contenu du fichier Candidat.py

# Importation des composants graphiques PyQt5
from PyQt5.QtWidgets import *
from PyQt5.uic import *

# Importation des fonctions de sauvegarde et de lecture binaire
from pickle import dump, load

# Importation du type tableau (non utilisé ici, mais souvent demandé)
from numpy import array


# --------------------------------------------------
# Déclaration de l'enregistrement candidat
# Il contient :
# - NCIN       : numéro de carte d’identité
# - NomPrenom  : nom et prénom du candidat
# - Score      : score obtenu
# --------------------------------------------------
candidat = dict(
        NCIN=str(),
        NomPrenom=str(),
        Score=int()
        )


# --------------------------------------------------
# Fonction de vérification du numéro CIN
# - doit contenir exactement 8 chiffres
# - le premier chiffre doit être 0 ou 1
# --------------------------------------------------
def verif_cin(cin):
    if (len(cin) == 8) and (cin[0] in ['0', '1']):
        i = 1
        # Vérifier que les caractères restants sont des chiffres
        while (i < len(cin) - 1) and ('0' <= cin[i] <= '9'):
            i = i + 1
        return ('0' <= cin[i] <= '9')
    else:
        return False


# --------------------------------------------------
# Fonction de vérification du nom et prénom
# - ne doit pas être vide
# - contient uniquement des lettres et des espaces
# --------------------------------------------------
def verif_nom_prenom(nom_prenom):
    if len(nom_prenom) != 0:
        i = 0
        while (i < len(nom_prenom) - 1) and (
              ('A' <= nom_prenom[i].upper() <= 'Z') or (nom_prenom[i] == ' ')):
            i = i + 1
        return (('A' <= nom_prenom[i].upper() <= 'Z') or (nom_prenom[i] == ' '))
    else:
        return False


# --------------------------------------------------
# Fonction globale de vérification
# - vérifie le CIN et le nom/prénom
# - affiche un message d’erreur si invalide
# --------------------------------------------------
def verif(cin, nom_prenom):
    if not verif_cin(cin):
        QMessageBox.critical(w, 'Erreur', "N° CIN invalide")

    if not verif_nom_prenom(nom_prenom):
        QMessageBox.critical(w, 'Erreur', "Vérifier votre nom et votre prénom")

    return verif_cin(cin) and verif_nom_prenom(nom_prenom)


# --------------------------------------------------
# Fonction exécutée lors du clic sur le bouton Valider
# --------------------------------------------------
def ajouter():
    # Récupération des données saisies
    cin = w.cin.text()
    nom_prenom = w.nom_prenom.text()

    # Vérification des données
    if verif(cin, nom_prenom):
        score = 0

        # Calcul du score selon les choix
        if w.cb1.isChecked() and w.cb2.isChecked():
            score = score + 1

        if w.rb1.isChecked():
            score = score + 2

        if w.combo1.currentText() == '40':
            score = score + 3

        # Affichage du score dans l’interface
        w.labScore.setText(str(score))

        # Ouverture du fichier binaire en ajout
        f_reponse = open("Réponses.dat", "ab")

        # Remplissage du dictionnaire candidat
        candidat['NCIN'] = cin
        candidat['NomPrenom'] = nom_prenom
        candidat['Score'] = score

        # Enregistrement du candidat dans le fichier
        dump(candidat, f_reponse)

        # Fermeture du fichier
        f_reponse.close()


# --------------------------------------------------
# Programme principal
# --------------------------------------------------
app = QApplication([])

# Chargement de l’interface graphique
w = loadUi("Interface_Candidat.ui")
w.show()

# Association du bouton Valider à la fonction ajouter
w.Valider.clicked.connect(ajouter)

# Lancement de l’application
app.exec()

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

# Importation des composants graphiques PyQt5

from PyQt5.QtWidgets import *

from PyQt5.uic import *

# Importation des fonctions de sauvegarde et de lecture binaire

from pickle import dump, load

# Importation du type tableau (non utilisé ici, mais souvent demandé)

from numpy import array

# --------------------------------------------------

# Déclaration de l'enregistrement candidat

# Il contient :

# - NCIN : numéro de carte d’identité

# - NomPrenom : nom et prénom du candidat

# - Score : score obtenu

# --------------------------------------------------

candidat = dict(

NCIN=str(),

NomPrenom=str(),

Score=int()

)

# --------------------------------------------------

# Fonction de vérification du numéro CIN

# - doit contenir exactement 8 chiffres

# - le premier chiffre doit être 0 ou 1

# --------------------------------------------------

def verif_cin(cin):

if (len(cin) == 8) and (cin[0] in ['0', '1']):

i = 1

# Vérifier que les caractères restants sont des chiffres

while (i < len(cin) - 1) and ('0' <= cin[i] <= '9'):

i = i + 1

return ('0' <= cin[i] <= '9')

else:

return False

# --------------------------------------------------

# Fonction de vérification du nom et prénom

# - ne doit pas être vide

# - contient uniquement des lettres et des espaces

# --------------------------------------------------

def verif_nom_prenom(nom_prenom):

if len(nom_prenom) != 0:

i = 0

while (i < len(nom_prenom) - 1) and (

('A' <= nom_prenom[i].upper() <= 'Z') or (nom_prenom[i] == ' ')):

i = i + 1

return (('A' <= nom_prenom[i].upper() <= 'Z') or (nom_prenom[i] == ' '))

else:

return False

# --------------------------------------------------

# Fonction globale de vérification

# - vérifie le CIN et le nom/prénom

# - affiche un message d’erreur si invalide

# --------------------------------------------------

def verif(cin, nom_prenom):

if not verif_cin(cin):

QMessageBox.critical(w, 'Erreur', "N° CIN invalide")

if not verif_nom_prenom(nom_prenom):

QMessageBox.critical(w, 'Erreur', "Vérifier votre nom et votre prénom")

return verif_cin(cin) and verif_nom_prenom(nom_prenom)

# --------------------------------------------------

# Fonction exécutée lors du clic sur le bouton Valider

# --------------------------------------------------

def ajouter():

# Récupération des données saisies

cin = w.cin.text()

nom_prenom = w.nom_prenom.text()

# Vérification des données

if verif(cin, nom_prenom):

score = 0

# Calcul du score selon les choix

if w.cb1.isChecked() and w.cb2.isChecked():

score = score + 1

if w.rb1.isChecked():

score = score + 2

if w.combo1.currentText() == '40':

score = score + 3

# Affichage du score dans l’interface

w.labScore.setText(str(score))

# Ouverture du fichier binaire en ajout

f_reponse = open("Réponses.dat", "ab")

# Remplissage du dictionnaire candidat

candidat['NCIN'] = cin

candidat['NomPrenom'] = nom_prenom

candidat['Score'] = score

# Enregistrement du candidat dans le fichier

dump(candidat, f_reponse)

# Fermeture du fichier

f_reponse.close()

# --------------------------------------------------

# Programme principal

# --------------------------------------------------

app = QApplication([])

# Chargement de l’interface graphique

w = loadUi("Interface_Candidat.ui")

w.show()

# Association du bouton Valider à la fonction ajouter

w.Valider.clicked.connect(ajouter)

# 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 :

- QPushButton : bouton intitulé "btAfficher" pour afficher la liste des candidats admis dans l’ordre croissant du Score.

- QTableWidget nommé "admis_Widget" contenant la liste des candidats admis dans l’ordre croissant du Score.

Contenu du fichier Consultation.py

# Importation des composants graphiques PyQt5
from PyQt5.QtWidgets import *
from PyQt5.uic import *

# Importation des fonctions de sauvegarde et de lecture binaire
from pickle import dump, load

# Importation du type tableau
from numpy import array


# --------------------------------------------------
# Déclaration de l'enregistremnt candidat
# Chaque candidat contient :
# - NCIN       : numéro de carte d’identité
# - NomPrenom  : nom et prénom
# - Score      : score obtenu
# --------------------------------------------------
candidat = dict(
        NCIN=str(),
        NomPrenom=str(),
        Score=int()
        )

# Tableau pouvant contenir jusqu’à 50 candidats admis
t = array([{}] * 50)


# --------------------------------------------------
# Procédure de tri du tableau t selon le score
# Tri décroissant (du plus grand score au plus petit)
# Méthode : tri par sélection
# --------------------------------------------------
def tri(t, n):
    for i in range(n - 1):
        max = i
        for j in range(i, n):
            # Recherche de l’indice du score maximum
            if t[max]['Score'] < t[j]['Score']:
                max = j

        # Échange des deux candidats si nécessaire
        if max != i:
            temp = t[i]
            t[i] = t[max]
            t[max] = temp


# --------------------------------------------------
# Procédure qui remplit le QTableWidget
# avec les candidats admis
# --------------------------------------------------
def remplir_tablewidget(t, n):
    for i in range(n):
        # Ajuster le nombre de lignes du tableau
        w.admis_Widget.setRowCount(i + 1)

        # Remplissage des colonnes
        w.admis_Widget.setItem(i, 0, QTableWidgetItem(t[i]['NCIN']))
        w.admis_Widget.setItem(i, 1, QTableWidgetItem(t[i]['NomPrenom']))
        w.admis_Widget.setItem(i, 2, QTableWidgetItem(str(t[i]['Score'])))


# --------------------------------------------------
# Fonction exécutée lors du clic sur le bouton Afficher
# --------------------------------------------------
def afficher():
    # Ouverture du fichier binaire en lecture
    f_reponses = open("Réponses.dat", "rb")
    n = 0  # Compteur de candidats admis

    while True:
        try:
            # Initialisation d’un dictionnaire candidat
            candidat = dict(
                NCIN=str(),
                NomPrenom=str(),
                Score=int()
            )

            # Lecture d’un candidat depuis le fichier
            candidat = load(f_reponses)

            # Vérifier si le candidat est admis (score ≥ 3)
            if candidat['Score'] >= 3:
                t[n] = candidat
                n = n + 1

        except EOFError:
            # Fin du fichier atteinte
            break

    # Fermeture du fichier
    f_reponses.close()

    # Tri des candidats admis par score décroissant
    tri(t, n)

    # Affichage des candidats dans le tableau
    remplir_tablewidget(t, n)


# --------------------------------------------------
# Programme principal
# --------------------------------------------------
app = QApplication([])

# Chargement de l’interface graphique
w = loadUi("Interface_Consultation.ui")
w.show()

# Lier le bouton Afficher à la fonction afficher
w.btAfficher.clicked.connect(afficher)

# Lancement de l’application
app.exec()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

# Importation des composants graphiques PyQt5

from PyQt5.QtWidgets import *

from PyQt5.uic import *

# Importation des fonctions de sauvegarde et de lecture binaire

from pickle import dump, load

# Importation du type tableau

from numpy import array

# --------------------------------------------------

# Déclaration de l'enregistremnt candidat

# Chaque candidat contient :

# - NCIN : numéro de carte d’identité

# - NomPrenom : nom et prénom

# - Score : score obtenu

# --------------------------------------------------

candidat = dict(

NCIN=str(),

NomPrenom=str(),

Score=int()

)

# Tableau pouvant contenir jusqu’à 50 candidats admis

t = array([{}] * 50)

# --------------------------------------------------

# Procédure de tri du tableau t selon le score

# Tri décroissant (du plus grand score au plus petit)

# Méthode : tri par sélection

# --------------------------------------------------

def tri(t, n):

for i in range(n - 1):

max = i

for j in range(i, n):

# Recherche de l’indice du score maximum

if t[max]['Score'] < t[j]['Score']:

max = j

# Échange des deux candidats si nécessaire

if max != i:

temp = t[i]

t[i] = t[max]

t[max] = temp

# --------------------------------------------------

# Procédure qui remplit le QTableWidget

# avec les candidats admis

# --------------------------------------------------

def remplir_tablewidget(t, n):

for i in range(n):

# Ajuster le nombre de lignes du tableau

w.admis_Widget.setRowCount(i + 1)

# Remplissage des colonnes

w.admis_Widget.setItem(i, 0, QTableWidgetItem(t[i]['NCIN']))

w.admis_Widget.setItem(i, 1, QTableWidgetItem(t[i]['NomPrenom']))

w.admis_Widget.setItem(i, 2, QTableWidgetItem(str(t[i]['Score'])))

# --------------------------------------------------

# Fonction exécutée lors du clic sur le bouton Afficher

# --------------------------------------------------

def afficher():

# Ouverture du fichier binaire en lecture

f_reponses = open("Réponses.dat", "rb")

n = 0 # Compteur de candidats admis

while True:

try:

# Initialisation d’un dictionnaire candidat

candidat = dict(

NCIN=str(),

NomPrenom=str(),

Score=int()

)

# Lecture d’un candidat depuis le fichier

candidat = load(f_reponses)

# Vérifier si le candidat est admis (score ≥ 3)

if candidat['Score'] >= 3:

t[n] = candidat

n = n + 1

except EOFError:

# Fin du fichier atteinte

break

# Fermeture du fichier

f_reponses.close()

# Tri des candidats admis par score décroissant

tri(t, n)

# Affichage des candidats dans le tableau

remplir_tablewidget(t, n)

# --------------------------------------------------

# Programme principal

# --------------------------------------------------

app = QApplication([])

# Chargement de l’interface graphique

w = loadUi("Interface_Consultation.ui")

w.show()

# Lier le bouton Afficher à la fonction afficher

w.btAfficher.clicked.connect(afficher)

# Lancement de l’application

app.exec()

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Pistolet de FURY – Bac théorique – Section informatique – 2025

Bac Info 27-01-26

Segmenter Matrice – Bac théorique – Section informatique – 2025

Bac SC 27-01-26

Suite Padovan – Bac théorique – Section informatique – 2025

Bac Info 27-01-26

Evaluation et consultation – Bac pratique – Section informatique – 2025

Bac Info 27-01-26

Dissimuler une image – Bac théorique – Section informatique – 2024

Bac Info 26-01-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 11109vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 10650vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 9417vues

Allumer une LED par la carte ESP32

ESP32 9032vues

La carte Arduino UNO et l’afficheur LCD I2C 2X16

Arduino 9012vues

Construction des robots

Tutoriels plus commentés

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 28 commentaires

Premiers pas avec Micro:bit et MakeCode

Micro:bit 24 commentaires

Présentation du module capteur de lumière à LDR

Composants 20 commentaires

Piloter un servomoteur par la carte Arduino UNO

Arduino 17 commentaires

Echange des messages entre deux cartes Micro:bit via radio

Micro:bit 14 commentaires

Evaluation et consultation – Bac pratique – Section informatique – 2025

Sujet (Python et Qt Designer - Bac 2025)

L'interface graphique "Interface_Evaluation.ui"

Contenu du fichier Candidat.py

L'interface graphique "Interface_Consultation.ui"

Contenu du fichier Consultation.py

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles