Analyse appréciations – Bac théorique – Section informatique – 2026
Sujet (Algo et programmation - Bac 2026)
Dans le but d'améliorer la qualité de ses produits, une entreprise souhaite réaliser une enquête afin do cellecter et d analyser les appréciations de ses adhérents. Le nombre total d'adhérents est inférieur ou éqal à 1000.
Les informations d'accès des adhérents (login et mot de passe) sont stockées dans un fichier texte flemme 'LoginPassword.txt" Les mots de passe sont cryptes afin d'assurer la confidentialité des comptes.
Chaque ligne du fichier contient
- un lopin constitué exactement de 8 chiffres
- suivi du caractère #
- suivi d'un mot de passe d'au moins 4 caractères crypte sous forme d une séquence chaque caractère est représenté sur un octet (8 bits)
Peur exploiter ce fichier, on dort procéder au décryptage des mots de passe.
Le decr)ptage d'un mot de passe se fait comme suit
Pour chaque octet du mot de passe :
- Etape 1 : Convertir octet de la base 2 vers la base 16
- Etape 2 : Permuter les deux chiffres du nombre obtenu dans I étape 1
- Etape 3 : Convertir le nombre hexadécimal obtenu dans I étape 2 vers la base 10
- Etape 4 : Determiner le caractère dont le code ASCII est le nombre obtenu dans I étape 3
Travail demandé :
1) Ecrire un algorithme d'une procédure Decryptage(TLP , NE) qui permet de remplir un tableau d'enregistrements TLP, à partir du fichier "LoginPassword.txt", par les logins des adhérents ainsi que leurs mots de passe décryptés comme décrit précédemment. Chaque enregistrement du tableau TLP est composé des deux champs suivants :
- Login : le login d'un adérant
- Pwd : le mot de passe de t adhérent decnipté selon le principe décrit précédemment
NB:
- NE représente le nombre d enregistrements dans le tableau TLP
- Le fichier "LoginPassword.txt" est déjà rempli et enregistré dans le dossier "D:\Analyse"
2) Ecrire un algorithme d une procédure Romplir(TLP NE) qui saisit le nombre N de participants à l'enquête (avec 10 <= N <= NE), puis permet pour chaque participant :
a) L'authentification
- Saisir le login et le mol de passe non cryptes
- Vérifier que ce couple (logon, mot de passe) existe dans le table.su TLP
• Si le couple n'existe pas. afficher le message "Vous n'ôtes pas un adhérent
• Sinon. passer à l'étape b)
b) La saisie de l'appréciation
- Si l'adhérent n'existe pas dans le fichier "Notes.dat, lui demander de saisir une note d'appréciation de l'intervalle [1,5] et ajouter ensuite un nouvel enregistrement dans le fichier "Notes.dat". Chaque enregistrement du fichier "Notes.dat" est composé des deux champs suivants :
• Login : le login de l'adhérent
• Note : la note attribuée par l'adhérent
- Si l'adhérent existe déjà dans le fichier "Notes.dat", afficher un message indiquant eu il a déjà attribué une note
NB:
- Le fichier "Notes.dat" est déjà créé dans le dossier "D:\Analyse"
- On pourra utiliser la fonction Chercher(Login), qui retourne Vrai si un enregistrement du fichier "Notes.dat" contient le login de l'adhérent (Login) et retourne Faux dans le cas contraire, que le candidat n'est pas appelé à la développer.
3) Ecrire un algorithme d'une procédure Statistique(Moy P) qui permet de calculer :
- La moyenne des notes Moy.
- Le pourcentage P des notes supérieures ou égales à 4. sachant que
P = (nombre de notes >= 4) * 100 / N
4) Ecrire un algorithme du programme principal qui fait appel aux trois procédures Decryptage. Remplir et Statistique pour collecter les appréciations des adhérents et afficher la moyenne aes notes et le pourcentage des notes supérieures ou égales à 4.
Solution Algorithmique
Dans cet algorithme, On va utiliser six fonctions et six procédures :
- la fonction saisie
- la fonction convertir_binaire_8bits
- la procédure remplir_LoginPassword
- la fonction binaire_vers_hexa
- la fonction hexa_vers_decimal
- la fonction convertir
- la fonction decrypter_motpasse
- la procédure decryptage
- la procédure remplir_fichier_notes
- la procédure recherche
- la procédure remplir
- la procédure statistique
Algorithme du programme Principal
Le programme principal assure le déroulement complet de l'application. Il commence par demander le nombre d'enregistrements à traiter, puis génère le fichier contenant les identifiants et les mots de passe des adhérents. Ensuite, il décrypte les mots de passe et charge les informations dans un tableau en mémoire. Après l'authentification des utilisateurs, il permet la saisie des notes correspondantes. Enfin, il calcule et affiche les statistiques finales relatives aux notes enregistrées.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Algorithme analyse_appréciations Debut # Saisie du nombre d'adhérents ne <- saisie(10, 1000, "Donner le nombre d'enregistrements: ") # Génération du fichier LoginPassword.txt remplir_LoginPassword(ne) # Décryptage des mots de passe et chargement dans le tableau decryptage(tlp, ne) # Authentification et saisie des notes remplir(tlp, ne) # Affichage des statistiques finales statistique() Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ne | entier |
| tle | tableau des enregistrements |
La fonction saisie
La fonction saisie() permet de garantir qu'une valeur entière saisie par l'utilisateur appartient à un intervalle donné. Elle affiche un message invitant l'utilisateur à entrer un nombre compris entre une borne inférieure (inf) et une borne supérieure (sup). Si la valeur saisie est en dehors de cet intervalle, la fonction redemande une nouvelle saisie jusqu'à ce qu'une valeur valide soit fournie. Enfin, elle retourne l'entier valide saisi par l'utilisateur.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction saisie__elt(inf:entier, sup:entier):entier # Demander à l'utilisateur de saisir une valeur Ecrire(message , inf , " et " , sup , " ") Lire(n) # Répéter la saisie tant que la valeur est hors intervalle Tant que non (inf <= n <= sup) faire Ecrire(message , inf , " et " , sup , " ") Lire(n) Fin tant que # Retourner la valeur valide retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction convertir_binaire_8bits
La fonction convertir_binaire_8bits() permet de convertir un nombre entier décimal en sa représentation binaire sur 8 bits. Elle effectue la conversion en utilisant les divisions successives par 2 et construit progressivement la chaîne de caractères représentant le nombre binaire. Ensuite, elle complète cette représentation avec des zéros à gauche jusqu'à obtenir exactement 8 bits. Enfin, elle retourne la valeur binaire sous forme d'une chaîne de caractères.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction convertir_binaire_8bits(n:entier):chaîne binaire <- '' Tant que n > 0 faire reste <- n mod 2 binaire <- Convch(reste) + binaire n <- n div 2 Fin tant que # Compléter avec des zéros à gauche Tant que long(binaire) < 8 faire binaire <- "0" + binaire Fin Tant que retourner binaire Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| binaire | chaîne des caractères |
La procédure remplir_LoginPassword
La procédure remplir_LoginPassword() permet de générer et d'enregistrer automatiquement les identifiants et les mots de passe cryptés de plusieurs utilisateurs dans un fichier texte nommé LoginPassword.txt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
Procédure remplir_LoginPassword(n) Ouvrir("LoginPassword.txt", f ,"w") Pour i de 0 à n-1 faire # Génération d'un login de 8 chiffres login <- Convch(Aléa(10000000, 99999999)) # Longueur aléatoire du mot de passe nbr_caractères <- Aléa(4, 10) motpassecrypte <- '' # Génération du mot de passe crypté Pour j de 0 à nbr_caractères-1 faire # Caractère ASCII imprimable code_ascii <- Aléa(32, 126) # Conversion du caractère en binaire octet <- convertir_binaire_8bits(code_ascii) motpassecrypte <- motpassecrypte + octet Fin pour # Enregistrement dans le fichier texte Ecrire(f, login + '#' + motpassecrypte + '\n') Fin pour Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier texte |
| login | chaîne |
| nbr_caractères | entier |
| motpassecrypte | chaîne |
| j | entier |
| code_ascii | entier |
| octet | chaîne |
La fonction binaire_vers_hexa
La fonction binaire_vers_hexa() permet de convertir deux groupes de bits représentant un octet binaire en une valeur sous forme hexadécimale. Elle prend en entrée deux chaînes binaires (b1 et b2) correspondant généralement aux deux demi-octets d'un octet.
La fonction commence par convertir le premier groupe binaire b1 en une valeur décimale. Si cette valeur est inférieure à 10, elle est conservée sous forme de chiffre ; sinon, elle est convertie en caractère hexadécimal (A à F). Ensuite, elle convertit le deuxième groupe binaire b2 en valeur décimale.
Enfin, elle retourne la représentation hexadécimale obtenue en combinant la valeur du deuxième groupe avec le caractère correspondant au premier groupe. Cette fonction est utilisée pour transformer une donnée binaire en une écriture hexadécimale plus compacte et plus lisible.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Fonction binaire_vers_hexa(b1:chaîne, b2:chaîne):chaîne val1 <- 0 Pour i de 0 long(b1)-1 faire val1 <- val1 * 2 + Valeur(b1[i]) Fin pour Si val1 < 10 alors v <- str(val1) Sinon v <- chr(ord('A') + val1 - 10) Fin si val2 <- 0 Pour i de 0 à long(b2)-1 faire val2 <- val2 * 2 + int(b2[i]) Fin pour retourner Convch(val2)+v Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| val1 | entier |
| i | entier |
| v | chaîne |
| val2 | entier |
La fonction hexa_vers_decimal
Cette fonction permet de convertir un nombre écrit en hexadécimal (base 16) en son équivalent décimal (base 10).
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction hexa_vers_decimal(hexa:chaîne):entier decimal <- 0 Pour i de 0 à long(hexa)-1 faire Si '0' <= hexa[i] <= '9' alors valeur <- ord(hexa[i]) - ord('0') Sinon valeur = ord(hexa[i]) - ord('A') + 10 Fin si decimal <- decimal * 16 + valeur Fin pour retourner decimal Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| decimal | entier |
| i | entier |
La fonction convertir
Cette fonction permet de convertir un octet représenté en binaire (8 bits) en sa valeur décimale.
|
1 2 3 4 5 6 7 8 |
Fonction convertir(octet:chaîne):entier # Découpage de l'octet en deux demi-octets b1 <- Sous_chaine(octet, 0, 4) b2 <- Sous_chaine(octet, 4, 8) hexa <- binaire_vers_hexa(b1, b2) decimal <- hexa_vers_decimal(hexa) retourner decimal Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| b1 | chaîne des caractères |
| b2 | chaîne des caractères |
| hexa | chaîne des caractères |
| decimal | entier |
La fonction decrypter_motpasse(ch)
Cette procédure permet de déchiffrer un mot de passe codé sous forme d'une chaîne binaire en le convertissant en une chaîne de caractères ASCII.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction decrypter_motpasse(ch:chaîne):chaîne decrypter <- '' Tant que ch != '' faire # Extraction d'un octet octet <- Sous_chaine(ch,0,8) # Conversion en caractère ASCII caractere <- chr(convertir(octet)) decrypter <- decrypter + caractere # Suppression de l'octet traité ch <- Sous_chaine(ch,8,long(ch)] Fin tant que retourner decrypter Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| decrypter | chaîne des caractères |
| octet | chaîne des caractères |
| caractere | chaîne des caractères |
La procédure decryptage
Cette procédure permet de lire le fichier LoginPassword.txt, de déchiffrer les mots de passe qui y sont stockés sous forme binaire et de les enregistrer avec les logins dans le tableau tlp.
|
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 |
Procédure decryptage(tlp:tableau, ne:entier) Ouvrir("LoginPassword.txt", f ,"r") Lire_ligne (f , ligne) i <- 0 Tant que ligne != "" faire ligne <- ligne.strip('\n') adherent: enregistrement login:chaîne pwd:chaîne # Extraction du login adherent['login'] <- Sous_chaine(ligne, 0 ,8] # Décryptage du mot de passe adherent['pwd'] <- decrypter_motpasse(Sous_chaine(ligne , 9 , long(ligne)]) tlp[i] <- adherent i = i*1 Lire_ligne (f , ligne) Fin tant que Fermer(f) Ecrire("*** Contenu du tableau TLP ***") Pour i de 0 à ne-1 Ecrire(tlp[i]['login'], tlp[i]['pwd']) Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier texte |
| i | entier |
| adherent | enregistrment |
La procédure remplir_fichier_notes
Cette procédure permet d'ajouter un enregistrement contenant un login et une note dans le fichier binaire notes.dat.
|
1 2 3 4 5 6 7 8 |
Procédure remplir_fichier_notes(login:entier, note:entier) Ecrire("Ajout appreciation dans notes.dat") Ouvrir("notes.dat", f ,"ab") appreciation['login'] <- login appreciation['note'] <- note Ecrire (f , appreciation) Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier binaire |
| appreciation | enregistrment |
La fonction recherche
Cette fonction vérifie si un login existe dans le fichier binaire notes.dat en parcourant les enregistrements sauvegardés.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Fonction recherche(login:chaîne):booléen Ouvrir("notes.dat", f ,"rb") trouver <- Faux Tant que trouver = Faux faire essayer: Lire (f , appreciation) Si appreciation['login'] = login alors trouver <- Vrai Fin si En cas d'erreur: Sortir Fin tant que Fermer(f) retourner trouver Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier binaire |
| trouver | booléen |
| appreciation | enregistrment |
La procédure remplir
Cette procédure permet de gérer la participation des adhérents en vérifiant leur authentification, en contrôlant s'ils ont déjà voté, puis en enregistrant leur note dans le fichier binaire notes.dat.
|
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 |
Procédure remplir(tlp:tableau, ne:entier) n <- saisie(10, ne, 'donner nombre participants entre ') Pour i de 0 à n-1 faire Ecrire("Saisir login : ") Lire(login) Ecrire("Saisir mot de passe : ") Lire(motpasse) # Recherche du login et du mot de passe j <- 0 Tant que (j < ne - 1) et (tlp[j]["login"] != login) et (tlp[j]["pwd"] != motpasse) faire j <- j + 1 Fin tant que # Vérification de l'authentification Si (tlp[j]["login"] != login) ou (tlp[j]["pwd"] != motpasse) alors Ecrire("Vous n etes pas un adhérent") Sinon # Vérifier si l'adhérent a déjà voté Si recherche(login) alors Ecrire("Cet adherent a déjà attribué une note !") Sinon note <- saisie(1, 5, 'donner note entre ') remplir_fichier_notes(login, note) Fin si Fin si Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
| i | entier |
| login | chaîne des caractères |
| motpasse | chaîne des caractères |
| j | entier |
| note | entier |
La procédure statistique
Cette procédure permet de lire le fichier binaire notes.dat, d'afficher les notes enregistrées et de calculer des statistiques sur les appréciations des adhérents.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
Procédure statistique() Ouvrir(f "notes.dat", f ,"rb") moy <- 0 n <- 0 p <- 0 Ecrire("*** Contenu du fichier notes.dat ***") Tant que Vrai faire essayer: Lire(f,appreciation) Ecrire(appreciation['login'], appreciation['note']) moy <- moy + appreciation['note'] Si appreciation['note'] >= 4 alors p <- p+1 Fin si n <- n + 1 En cas d'erreur: Sortir Fin tant que Fermer(f) Ecrire("Moyenne des notes :", moy / n) Ecrire("Le pourcentage des notes >=4 :", (p * 100) / n) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier binaire |
| moy | entier |
| n | entier |
| p | entier |
| j | entier |
| appreciation | enregistrement |
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 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 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 |
# ============================================================ # Importation des bibliothèques nécessaires # ============================================================ import random # Génération de nombres aléatoires from pickle import load, dump # Lecture et écriture dans un fichier binaire from numpy import array # Création d'un tableau NumPy # ============================================================ # Création d'un tableau pouvant contenir jusqu'à 1000 adhérents # Chaque case contient un dictionnaire (login, mot de passe) # ============================================================ tlp = array([{}] * 100) # ============================================================ # Création (ou écrasement) du fichier binaire des notes # ============================================================ with open("notes.dat", "wb") as fichier: pass print("Fichier notes créé.") # ============================================================ # Structure d'un enregistrement du fichier notes.dat # login : identifiant de l'adhérent # note : note attribuée # ============================================================ appreciation = dict( login=str(), note=int() ) # ============================================================ # Saisie contrôlée d'un entier compris entre deux bornes # ============================================================ def saisie(inf, sup, message): n = int(input(message + str(inf) + " et " + str(sup) + " ")) while not (inf <= n <= sup): n = int(input(message + str(inf) + " et " + str(sup) + " ")) return n # ============================================================ # Conversion d'un entier décimal en une chaîne binaire de 8 bits # ============================================================ def convertir_binaire_8bits(n): binaire = '' while n > 0: reste = n % 2 binaire = str(reste) + binaire n = n // 2 # Compléter avec des zéros à gauche while len(binaire) < 8: binaire = "0" + binaire return binaire # ============================================================ # Génération d'un fichier texte contenant : # login#motdepassecrypté # # Le mot de passe est constitué de caractères ASCII convertis # en binaire (8 bits par caractère) # ============================================================ def remplir_LoginPassword(n): f = open("LoginPassword.txt", "w") for i in range(n): # Génération d'un login de 8 chiffres login = str(random.randint(10000000, 99999999)) # Longueur aléatoire du mot de passe nbr_caractères = random.randint(4, 10) motpassecrypte = '' # Génération du mot de passe crypté for j in range(nbr_caractères): # Caractère ASCII imprimable code_ascii = random.randint(32, 126) # Conversion du caractère en binaire octet = convertir_binaire_8bits(code_ascii) motpassecrypte += octet # Enregistrement dans le fichier texte f.write(login + '#' + motpassecrypte + '\n') f.close() # ============================================================ # Conversion de deux groupes de 4 bits vers une représentation # hexadécimale particulière # ============================================================ def binaire_vers_hexa(b1, b2): val1 = 0 for i in range(len(b1)): val1 = val1 * 2 + int(b1[i]) if val1 < 10: v = str(val1) else: v = chr(ord('A') + val1 - 10) val2 = 0 for i in range(len(b2)): val2 = val2 * 2 + int(b2[i]) return str(val2) + v # ============================================================ # Conversion d'une chaîne hexadécimale en entier décimal # ============================================================ def hexa_vers_decimal(hexa): decimal = 0 for i in range(len(hexa)): if '0' <= hexa[i] <= '9': valeur = ord(hexa[i]) - ord('0') else: valeur = ord(hexa[i]) - ord('A') + 10 decimal = decimal * 16 + valeur return decimal # ============================================================ # Conversion d'un octet binaire en code ASCII décimal # ============================================================ def convertir(octet): # Découpage de l'octet en deux demi-octets b1 = octet[0:4] b2 = octet[4:8] hexa = binaire_vers_hexa(b1, b2) decimal = hexa_vers_decimal(hexa) return decimal # ============================================================ # Décryptage d'un mot de passe codé en binaire # ============================================================ def decrypter_motpasse(ch): decrypter = '' while ch != '': # Extraction d'un octet octet = ch[0:8] # Conversion en caractère ASCII caractere = chr(convertir(octet)) decrypter += caractere # Suppression de l'octet traité ch = ch[8:len(ch)] return decrypter # ============================================================ # Lecture du fichier LoginPassword.txt # Décryptage des mots de passe # Remplissage du tableau TLP # ============================================================ def decryptage(tlp, ne): f = open("LoginPassword.txt", "r") ligne = f.readline() i = 0 while ligne != "": ligne = ligne.strip('\n') adherent = dict( login=str(), pwd=str() ) # Extraction du login adherent['login'] = ligne[0:8] # Décryptage du mot de passe adherent['pwd'] = decrypter_motpasse(ligne[9:len(ligne)]) tlp[i] = adherent i += 1 ligne = f.readline() f.close() print("*** Contenu du tableau TLP ***") for i in range(ne): print(tlp[i]['login'], tlp[i]['pwd']) # ============================================================ # Ajout d'une appréciation dans le fichier binaire notes.dat # ============================================================ def remplir_fichier_notes(login, note): print("Ajout appreciation dans notes.dat") f = open("notes.dat", "ab") appreciation['login'] = login appreciation['note'] = note dump(appreciation, f) f.close() # ============================================================ # Vérifie si un adhérent a déjà attribué une note # ============================================================ def recherche(login): f = open("notes.dat", "rb") trouver = False while trouver == False: try: appreciation = load(f) if appreciation['login'] == login: trouver = True except EOFError: break f.close() return trouver # ============================================================ # Authentification des adhérents puis saisie de leur note # ============================================================ def remplir(tlp, ne): n = saisie(10, ne, 'donner nombre participants entre ') for i in range(n): login = input("Saisir login : ") motpasse = input("Saisir mot de passe : ") # Recherche du login et du mot de passe j = 0 while (j < ne - 1) and (tlp[j]["login"] != login) and (tlp[j]["pwd"] != motpasse): j += 1 # Vérification de l'authentification if (tlp[j]["login"] != login) or (tlp[j]["pwd"] != motpasse): print("Vous n etes pas un adhérent") else: # Vérifier si l'adhérent a déjà voté if recherche(login): print("Cet adherent a déjà attribué une note !") else: note = saisie(1, 5, 'donner note entre ') remplir_fichier_notes(login, note) # ============================================================ # Calcul des statistiques : # - affichage des notes # - moyenne # - pourcentage des notes >= 4 # ============================================================ def statistique(): f = open("notes.dat", "rb") moy = 0 n = 0 p = 0 print("*** Contenu du fichier notes.dat ***") while True: try: appreciation = load(f) print(appreciation['login'], appreciation['note']) moy += appreciation['note'] if appreciation['note'] >= 4: p += 1 n += 1 except EOFError: break f.close() print("Moyenne des notes :", moy / n) print("Le pourcentage des notes >=4 :", (p * 100) / n) # ============================================================ # Programme principal # ============================================================ # Saisie du nombre d'adhérents ne = saisie(10, 1000, "Donner le nombre d'enregistrements: ") # Génération du fichier LoginPassword.txt remplir_LoginPassword(ne) # Décryptage des mots de passe et chargement dans le tableau decryptage(tlp, ne) # Authentification et saisie des notes remplir(tlp, ne) # Affichage des statistiques finales statistique() |
Exécution du programme
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
