Evaluation des mots de passes – Bac théorique – Section informatique – 2015
Sujet (Algo et programmation - Bac 2015)
Un administrateur d'un site web veut assurer un maximum de sécurité pour les utilisateurs du site. Pour ceci il décide de réaliser une application qui évalue la force des mots de passe des différents utilisateurs du site, sachant qu'un mot de passe est une chaîne de caractères qui ne comporte pas d'espaces et de lettres accentuées.
La force d'un mot de passe varie, selon la valeur d'un score calculé, de "Très faible" jusqu'à "Très fort" :
- Si le score < 20, la force du mot de passe est "Très faible" - Sinon si le score < 40, la force du mot de passe est "Faible" - Sinon si le score < 60, la force du mot de passe est "Moyen" - Sinon si le score < 80, la force du mot de passe est "Fort" - Sinon la force du mot de passe est "Très fort" Le score se calcule en additionnant des bonus et en retranchant des pénalités. Les bonus attribués sont : - Nombre total de caractères * 4 - (Nombre total de caractères --nombre de lettres majuscules) * 2 - (Nombre total de caractères — nombre de lettres minuscules) * 3 - Nombre de caractères non alphabétiques * 5 Les pénalités imposées sont : - La longueur de la plus longue séquence de lettres minuscules * 2 - La longueur de la plus longue séquence de lettres majuscules * 2
Pour le mot de passe "B@cSI_ juin2015", le score se calcule comme suit :
La somme des bonus = 14*4 (14-3)*2 + (14-5)*3 + 6*5 135
Car :
le nombre total de caractères = 14
le nombre de lettres majuscules = 3
le nombre de lettres minuscules = 5
le nombre de caractères non alphabétiques = 6
La somme des pénalités = 4*2 + 2*2 = 12
Car :
la longueur de la plus longue séquence de lettres minuscules ("juin") = 4
la longueur de la plus longue séquence de lettres majuscules ("SI") = 2
Le score final = 135 — 12 = 123 ; puisque 123 ? 80 alors le mot de passe est considéré comme "Très fort".
En disposant d'un fichier texte "Motspass.txt", situé sur la racine du disque C, dont chaque ligne contient un mot de passe, on se propose de :
- Générer un fichier d'enregistrements "ForceMDP.dat" où chaque enregistrement comporte le mot de passe lui-même, son score et sa force. i
- Générer un fichier texte "MDPfort.txt" par la liste les mots de passe ayant une force égale à "Très fort" suivis de la liste des mots de passe ayant une force égale à "Fort" à raison d'un mot de passe par ligne, tout en séparant les deux listes par une ligne vide.
N.B : L'élève n'est pas appelé à remplir le fichier "Motspass.txt".
Travail demandé
- Analyser le problème en le décomposant en modules.
- Analyser chacun des modules envisagés.
Solution Algorithmique
Dans cet algorithme, On va utiliser six fonctions et trois procédures :
- la fonction saisie()
- la fonction test_motpasse()
- la fonction saisie_motpasse()
- la fonction calcul_bonus()
- la fonction calcul_penalites()
- la fonction force_motpasse()
- la procédure remplir_fichier_motspass()
- la procédure remplir_fichier_forcemdp()
- la procédure remplir_fichier_mdpfort()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 |
Algorithme evaluation_mots_passe Debut n <- saisie(0, 101) remplir_fichier_motspass(n) remplir_fichier_forcemdp() remplir_fichier_mdpfort() Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction saisie
Le rôle de cette fonction est de permettre à l’utilisateur de saisir un entier n compris strictement entre deux bornes inf et sup.
1- La fonction saisie(inf, sup) demande à l’utilisateur d’entrer un entier n.
2- Elle vérifie que n appartient à l’intervalle ouvert ] inf , sup [ (c’est-à-dire inf < n < sup). 3- Tant que la valeur saisie n’est pas valide (n ≤ inf ou n ≥ sup), la fonction redemande la saisie. 4- Une fois une valeur correcte entrée, la fonction retourne n.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Fonction saisie(inf:entier, sup:entier):entier # Première saisie de n Ecrire('donner n tel que ', inf , '< n < ' , sup, ': ')) Lire(n) # Tant que n n’appartient pas à l’intervalle ]inf , sup[ # on redemande la saisie Tant que (n <= inf) ou (n >= sup) faire Ecrire('donner n tel que ', inf , '< n < ' , sup, ': ')) Lire(n) Fin tant que # Retourne la valeur valide retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction test_motpasse
La fonction test_motpasse vérifie qu’un mot de passe n’est pas vide et qu’il ne contient ni caractères accentués ni espace, puis retourne Vrai s’il est valide et Faux sinon.
1- Test de non-vacuité
Si la longueur du mot de passe est nulle (len(motpasse) == 0), la fonction retourne Faux.
2- Parcours du mot de passe caractère par caractère
La variable i permet de parcourir la chaîne.
La boucle tant que continue tant que : on n’a pas atteint la fin du mot de passe et le caractère courant n’est ni accentué ni un espace.
3- Vérification finale
Si un caractère interdit est rencontré, la fonction retourne Faux.
Si tous les caractères sont autorisés, la fonction retourne Vrai.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction test_motpasse(motpasse:chaine):booleen # Vérifier que le mot de passe n'est pas vide Si long(motpasse) != 0 alors i <- 0 # Parcours des caractères du mot de passe Tant que (i < long(motpasse)-1) et (Non (motpasse[i] dans ['é','è','ê','à','â','î','ô',' '])) faire i = i + 1 Fin tant que # Retourne True si le caractère courant est autorisé retourner Non (motpasse[i] dans ['é','è','ê','à','â','î','ô',' ']) Sinon retourner Faux Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction saisie_motpasse
Cette fonction permet de saisir un mot de passe valide en obligeant l’utilisateur à recommencer la saisie tant que le mot de passe ne respecte pas les règles de validité définies par la fonction test_motpasse.
1- Saisie du mot de passe
L’utilisateur saisit un mot de passe au clavier.
2- Vérification de la validité
La fonction appelle test_motpasse(motpasse) pour vérifier si le mot de passe est valide.
3- Répétition de la saisie
Tant que le mot de passe est invalide (test_motpasse retourne False), l’utilisateur est invité à saisir un nouveau mot de passe.
4- Retour du résultat
Une fois un mot de passe valide saisi, la fonction le retourne.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction saisie_motpasse():chaine # Saisie du mot de passe Ecrire('donner un mot de passe valide : ') Lire(motpasse) # Tant que le mot de passe n'est pas valide, on redemande la saisie Tant que Non(test_motpasse(motpasse)) faire Ecrire('donner un mot de passe valide : ') Lire(motpasse) Fin tant que # Retourner le mot de passe valide retourner motpasse Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| motpasse | chaîne |
La fonction calcul_bonus
Cette fonction calcule le bonus de sécurité d’un mot de passe en attribuant des points selon sa longueur et la diversité des caractères qu’il contient (minuscules, majuscules et caractères non alphabétiques).
1- Initialisation des compteurs
nbr_minuscule : nombre de lettres minuscules
nbr_majuscule : nombre de lettres majuscules
nbr_non_alphabetique : nombre de caractères autres que des lettres
2- Parcours du mot de passe
Chaque caractère est analysé :
s’il est entre 'a' et 'z', il est compté comme minuscule ;
s’il est entre 'A' et 'Z', il est compté comme majuscule ;
sinon, il est compté comme caractère non alphabétique.
3- Calcul du bonus
Le bonus est calculé à partir de la longueur du mot de passe, la présence de majuscules et de minuscules et la présence de caractères non alphabétiques (chiffres, symboles).
4- Retour du résultat
La fonction retourne la valeur du bonus calculé.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Fonction calcul_bonus(motpasse:chaine):entier nbr_minuscule <- 0 nbr_majuscule <- 0 nbr_non_alphabetique <- 0 # Parcours du mot de passe Pour i de 0 à long(motpasse))-1 faire Si 'a' <= motpasse[i] <= 'z' alors nbr_minuscule <- nbr_minuscule + 1 Sinon si 'A' <= motpasse[i] <= 'Z' alors nbr_majuscule <- nbr_majuscule + 1 Sinon nbr_non_alphabetique <- nbr_non_alphabetique + 1 Fin si Fin pour # Calcul du bonus total bonus <- (long(motpasse)*4 + (long(motpasse)-nbr_majuscule)*2 +(len(motpasse) - nbr_minuscule)*3 + nbr_non_alphabetique*5) retourner bonus Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| nbr_minuscule | entier |
| nbr_majuscule | entier |
| nbr_non_alphabetique | entier |
| i | entier |
| bonus | entier |
La fonction calcul_penalites
Cette fonction calcule les pénalités de sécurité d’un mot de passe en fonction de la présence de longues suites consécutives de lettres : en minuscules et en majuscules.
Plus ces suites sont longues, plus le mot de passe est considéré comme faible, donc plus la pénalité est élevée.
1- Initialisation
sequences_minuscules et sequences_majuscules servent à compter la longueur de la suite courante.
max_sequences_minuscules et max_sequences_majuscules mémorisent la plus longue suite trouvée.
2- Parcours du mot de passe
Le mot de passe est parcouru caractère par caractère.
Si deux caractères consécutifs sont tous les deux :
des minuscules → on augmente la suite de minuscules ;
des majuscules → on augmente la suite de majuscules.
Sinon, on compare la suite courante avec le maximum et on réinitialise la suite.
3- Calcul des pénalités
La pénalité est proportionnelle à la longueur maximale des suites détectées.
Chaque caractère d’une suite contribue à une pénalité de 2 points.
4- Retour du résultat
La fonction retourne la valeur totale des pénalités.
|
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 |
Fonction calcul_penalites(motpasse:chaine):entier max_sequences_minuscules <- 0 max_sequences_majuscules <- 0 sequences_minuscules <- 1 sequences_majuscules <- 1 # Parcours du mot de passe Pour i de 0 à long(motpasse)-1 faire # Détection de suites de minuscules Si ('a' <= motpasse[i] <= 'z') et ('a' <= motpasse[i+1] <= 'z') alors sequences_minuscules <- sequences_minuscules + 1 Sinon Si max_sequences_minuscules < sequences_minuscules alors max_sequences_minuscules <- sequences_minuscules Fin si sequences_minuscules <- 1 Fin si # Détection de suites de majuscules Si ('A' <= motpasse[i] <= 'Z') et ('A' <= motpasse[i+1] <= 'Z') alors sequences_majuscules <- sequences_majuscules + 1 Sinon Si max_sequences_majuscules < sequences_majuscules alors max_sequences_majuscules <- sequences_majuscules Fin si sequences_majuscules <- 1 Fin si Fin pour # Calcul des pénalités penalites <- max_sequences_minuscules * 2 + max_sequences_majuscules * 2 retourner penalites Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| max_sequences_minuscules | entier |
| max_sequences_majuscules | entier |
| sequences_minuscules | entier |
| sequences_majuscules | entier |
| i | entier |
| penalites | entier |
La fonction force_motpasse
Cette fonction détermine le niveau de sécurité (force) d’un mot de passe à partir de son score.
1- La fonction reçoit en paramètre un score numérique.
2- Elle compare ce score à plusieurs seuils.
3- Selon l’intervalle dans lequel se situe le score, elle retourne un texte décrivant la force du mot de passe.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction force_motpasse(score:entier):chaine Si score < 20 alors retourner 'Très faible' Sinon Si score < 40 alors retourner 'Faible' Sinon Si score < 60 alors retourner 'Moyen' Sinon Si score < 80 alors retourner 'Fort' Sinon retourner 'Tres Fort' Fin si Fin |
La procédure remplir_fichier_motspass
Cette procédure permet de créer et de remplir le fichier texte Motspass.txt avec n mots de passe valides saisis par l’utilisateur.
1- Affichage d’un message
Indique à l’utilisateur que le fichier des mots de passe est en cours de remplissage.
2- Ouverture du fichier
Le fichier Motspass.txt est ouvert en mode écriture ("w"). S’il existe déjà, son contenu est écrasé.
3- Saisie des mots de passe
La procédure exécute une boucle for de 0 à n-1.
À chaque itération :
- un mot de passe valide est saisi grâce à la fonction saisie_motpasse() ;
- le mot de passe est écrit dans le fichier, suivi d’un saut de ligne.
4- Fermeture du fichier
Le fichier est fermé après l’écriture de tous les mots de passe.
|
1 2 3 4 5 6 7 8 9 |
Procedure remplir_fichier_motspass(n:entier) Ecrire('*** Remplir le fichier Motspass.txt ***') Ouvrir(f , "Motspass.txt", "w") Pour i de 0 à n-1 faire motpasse <- saisie_motpasse() Ecrire(f, motpasse + '\n') Fin pour Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| motpasse | chaîne |
La procédure remplir_fichier_forcemdp
Cette procédure crée et remplit le fichier binaire ForceMDP.dat en y enregistrant, pour chaque mot de passe, le mot de passe lui-même, son score de sécurité et sa force.
1- Affichage d’un message
Indique que le fichier binaire ForceMDP.dat est en cours de création/remplissage.
2- Ouverture des fichiers
Motspass.txt est ouvert en lecture pour récupérer les mots de passe.
ForceMDP.dat est ouvert en écriture binaire ("wb") pour stocker les données.
3- Lecture des mots de passe
Tous les mots de passe sont lus dans une liste (motspasses), chaque élément correspondant à une ligne du fichier.
Traitement de chaque mot de passe
Suppression du caractère de fin de ligne \n.
4- Calcul du score
score = bonus − pénalités.
Détermination de la force du mot de passe à partir du score.
Stockage des informations dans un enregistrement (enregistrement_motpasse).
Enregistrement binaire
L'enregistrement est sauvegardé dans le fichier ForceMDP.dat à l’aide de pickle.dump.
5- Affichage
Pour chaque mot de passe, le mot de passe, son score et sa force sont affichés à l’écran.
6- Fermeture des fichiers
Les deux fichiers sont fermés correctement.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
Procedure remplir_fichier_forcemdp() Ecrire('*** Contenu du fichier ForceMDP.dat ***') Ouvrir(f_passe , "Motspass.txt", "r") Ouvrir(f_fort , "ForceMDP.dat", "wb") motspasses <- Lire_lignes(f_passe) Pour motpasse dans motspasses faire motpasse <- motpasse.strip('\n') score <- calcul_bonus(motpasse) - calcul_penalites(motpasse) enregistrement_motpasse[' motpasse'] <- motpasse enregistrement_motpasse['score'] <- score enregistrement_motpasse['force'] <- force_motpasse(score) # Enregistrement dans le fichier binaire Ecrire(f_fort , enregistrement_motpasse) Ecrire(' motpasse=', motpasse, ', score=', score, ', force=', force_motpasse(score)) Fermer(f_passe) Fermer(f_fort) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_passe | fichier |
| f_fort | fichier |
| motspasses | chaîne |
| motpasse | chaîne |
| score | entier |
| enregistrement_motpasse | enregistrement |
La procédure remplir_fichier_mdpfort
Cette procédure lit le fichier binaire ForceMDP.dat et extrait les mots de passe ayant une force “Très fort” et “Fort”, puis les enregistre dans le fichier texte MDPforce.txt en respectant l’ordre et la présentation demandés.
1- Ouverture des fichiers
ForceMDP.dat est ouvert en lecture binaire pour accéder aux enregistrements.
MDPforce.txt est ouvert en écriture pour stocker le résultat.
2- Lecture du fichier binaire
Les enregistrements (dictionnaires) sont lus un par un à l’aide de pickle.load.
La lecture continue jusqu’à la fin du fichier (EOFError).
3- Sélection des mots de passe
Si la force est « Très fort », le mot de passe est ajouté à la liste correspondante.
Si la force est « Fort », le mot de passe est ajouté à sa liste.
4- Affichage
Les deux listes sont affichées à l’écran (pour vérification).
5- Écriture dans le fichier texte
Les mots de passe Très fort sont écrits en premier.
Une ligne vide sépare les deux listes.
Les mots de passe Fort sont écrits ensuite, un par ligne.
6- Fermeture des fichiers
Les fichiers sont fermés correctement.
|
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 |
Procedure remplir_fichier_mdpfort() Ecrire('*** Contenu du fichier MDPforce.txt ***') Ouvrir(f_fort , "ForceMDP.dat", "rb") Ouvri(f_mdp , "MDPforce.txt", "w") liste_tresfort <- '' liste_fort <- '' # Lecture du fichier binaire jusqu'à la fin Tant que Vrai Essayer enregistrement_motpasse <- Lire(f_fort) Si enregistrement_motpasse['force'] = 'Tres Fort' alors liste_tresfort = liste_tresfort + enregistrement_motpasse[' motpasse'] + '\n' Fin si Si enregistrement_motpasse['force'] = 'Fort' alors liste_fort = liste_fort + enregistrement_motpasse[' motpasse'] + '\n' Fin si En cas de fin fichier : sortir Fin tant que Ecrire(liste_tresfort) Ecrire() Ecrire(liste_fort) Ecrire(f_mdp, liste_tresfort + '\n\n') Ecrire(f_mdp , liste_fort + '\n') Fermer(f_mdp) Fermer(f_fort) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_fort | fichier |
| f_mdp | fichier |
| liste_tresfort | chaîne |
| liste_fort | chaîne |
| enregistrement_motpasse | 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 |
# -------------------------------------------------- # Importation du module pickle # pickle permet d'enregistrer et de relire des objets Python dans des fichiers binaires # -------------------------------------------------- import pickle from pickle import load, dump # -------------------------------------------------- # Dictionnaire représentant un enregistrement de mot de passe # - motpasse : le mot de passe # - score : score de sécurité calculé # - force : niveau de sécurité du mot de passe # -------------------------------------------------- enregistrement_motpasse = dict( motpasse=str(), score=int(), force=int() ) # -------------------------------------------------- # Fonction qui permet de saisir un entier n # strictement compris entre inf et sup # -------------------------------------------------- def saisie(inf, sup): # Saisie d'un entier par l'utilisateur n = int(input('donner n tel que ' + str(inf) + '< n < ' + str(sup) + ': ')) # Tant que n n'appartient pas à l'intervalle ]inf, sup[ while (n <= inf) or (n >= sup): n = int(input('donner n tel que ' + str(inf) + '< n < ' + str(sup) + ': ')) # Retourner la valeur valide return n # -------------------------------------------------- # Fonction qui vérifie si un mot de passe est valide # Le mot de passe ne doit pas contenir : # - caractères accentués # - espace # -------------------------------------------------- def test_motpasse(motpasse): # Vérifier que le mot de passe n'est pas vide if len(motpasse) != 0: i = 0 # Parcours des caractères du mot de passe while (i < len(motpasse)-1) and (not (motpasse[i] in ['é','è','ê','à','â','î','ô',' '])): i = i + 1 # Retourne True si le caractère courant est autorisé return not (motpasse[i] in ['é','è','ê','à','â','î','ô',' ']) else: return False # -------------------------------------------------- # Fonction qui permet la saisie d'un mot de passe valide # -------------------------------------------------- def saisie_motpasse(): # Saisie du mot de passe motpasse = input('donner un mot de passe valide : ') # Tant que le mot de passe n'est pas valide, on redemande la saisie while not(test_motpasse(motpasse)): motpasse = input('donner un mot de passe valide : ') # Retourner le mot de passe valide return motpasse # -------------------------------------------------- # Fonction qui calcule le bonus de sécurité d'un mot de passe # Le bonus dépend : # - de la longueur # - du nombre de minuscules # - du nombre de majuscules # - du nombre de caractères non alphabétiques # -------------------------------------------------- def calcul_bonus(motpasse): nbr_minuscule = 0 nbr_majuscule = 0 nbr_non_alphabetique = 0 # Parcours du mot de passe for i in range(len(motpasse)): if 'a' <= motpasse[i] <= 'z': nbr_minuscule = nbr_minuscule + 1 elif 'A' <= motpasse[i] <= 'Z': nbr_majuscule = nbr_majuscule + 1 else: nbr_non_alphabetique = nbr_non_alphabetique + 1 # Calcul du bonus total bonus = (len(motpasse) * 4 + (len(motpasse) - nbr_majuscule) * 2 + (len(motpasse) - nbr_minuscule) * 3 + nbr_non_alphabetique * 5) return bonus # -------------------------------------------------- # Fonction qui calcule les pénalités d'un mot de passe # Les pénalités sont dues aux longues suites : # - de minuscules # - de majuscules # -------------------------------------------------- def calcul_penalites(motpasse): max_sequences_minuscules = 0 max_sequences_majuscules = 0 sequences_minuscules = 1 sequences_majuscules = 1 # Parcours du mot de passe for i in range(len(motpasse)-1): # Détection de suites de minuscules if ('a' <= motpasse[i] <= 'z') and ('a' <= motpasse[i+1] <= 'z'): sequences_minuscules = sequences_minuscules + 1 else: if max_sequences_minuscules < sequences_minuscules: max_sequences_minuscules = sequences_minuscules sequences_minuscules = 1 # Détection de suites de majuscules if ('A' <= motpasse[i] <= 'Z') and ('A' <= motpasse[i+1] <= 'Z'): sequences_majuscules = sequences_majuscules + 1 else: if max_sequences_majuscules < sequences_majuscules: max_sequences_majuscules = sequences_majuscules sequences_majuscules = 1 # Calcul des pénalités penalites = max_sequences_minuscules * 2 + max_sequences_majuscules * 2 return penalites # -------------------------------------------------- # Fonction qui détermine la force du mot de passe # en fonction du score # -------------------------------------------------- def force_motpasse(score): if score < 20: return 'Très faible' elif score < 40: return 'Faible' elif score < 60: return 'Moyen' elif score < 80: return 'Fort' else: return 'Tres Fort' # -------------------------------------------------- # Procedure qui remplit le fichier Motspass.txt # avec n mots de passe saisis # -------------------------------------------------- def remplir_fichier_motspass(n): print('*** Remplir le fichier Motspass.txt ***') f = open("Motspass.txt", "w") for i in range(n): motpasse = saisie_motpasse() f.write(motpasse + '\n') f.close() # -------------------------------------------------- # Procedure qui crée le fichier binaire ForceMDP.dat # contenant les mots de passe avec leur score et force # -------------------------------------------------- def remplir_fichier_forcemdp(): print('*** Contenu du fichier ForceMDP.dat ***') f_passe = open("Motspass.txt", "r") f_fort = open("ForceMDP.dat", "wb") motspasses = f_passe.readlines() for motpasse in motspasses: motpasse = motpasse.strip('\n') score = calcul_bonus(motpasse) - calcul_penalites(motpasse) enregistrement_motpasse[' motpasse'] = motpasse enregistrement_motpasse['score'] = score enregistrement_motpasse['force'] = force_motpasse(score) # Enregistrement dans le fichier binaire dump(enregistrement_motpasse, f_fort) print(' motpasse=', motpasse, ', score=', score, ', force=', force_motpasse(score)) f_passe.close() f_fort.close() # -------------------------------------------------- # Procedure qui extrait les mots de passe Fort et Très Fort # dans le fichier texte MDPforce.txt # -------------------------------------------------- def remplir_fichier_mdpfort(): print('*** Contenu du fichier MDPforce.txt ***') f_fort = open("ForceMDP.dat", "rb") f_mdp = open("MDPforce.txt", "w") liste_tresfort = '' liste_fort = '' # Lecture du fichier binaire jusqu'à la fin while True: try: enregistrement_motpasse = pickle.load(f_fort) if enregistrement_motpasse['force'] == 'Tres Fort': liste_tresfort += enregistrement_motpasse[' motpasse'] + '\n' if enregistrement_motpasse['force'] == 'Fort': liste_fort += enregistrement_motpasse[' motpasse'] + '\n' except EOFError: break print(liste_tresfort) print() print(liste_fort) f_mdp.write(liste_tresfort + '\n\n') f_mdp.write(liste_fort + '\n') f_mdp.close() f_fort.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- n = saisie(0, 101) remplir_fichier_motspass(n) remplir_fichier_forcemdp() remplir_fichier_mdpfort() |
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
