Auteur : Hélène Passelande

Objectifs :¶

réutiliser les fonctions
savoir lire et utiliser une documentation de fonction

Le scénario :¶

Un utilisateur souhaite construire un mot de passe fort pour sécuriser un document.

Construire un mot de passe assez fort et facilement mémorisable.¶

Description¶

Pour construire un mot de passe assez fort et facilement mémorisable, une technique consiste à retenir les initiales des mots d'une phrase de passe.
Par exemple : J'adore passer mes vacances à réaliser des devoirs maison.
Donne : Japmvàrddm
Pour augmenter la sécurité du mot de passe, on peut décider de mettre aléatoirement certaines lettres en majuscules. Attention pour que le mot de passe reste facile à écrire au clavier, on n'aura pas de majuscules accentuées !
Cela donne : JApMvARDdm
Pour augmenter encore la sécurité, on décide de mettre un chiffre au hasard dans le mot de passe.
Ca donne : JAp5MvARDdm

Les étapes de construction¶

Un utilisateur saisit un chiffre et une phrase de passe.

• On vérifie que le chiffre est bien un entier entre 0 et 9.
• On transforme les apostrophes et les signes de ponctuation en espace
• On vérifie qu'il y a plus de 8 mots séparés par des espaces

Pour obtenir le mot de passe :

• on récupère la première lettre de chaque mot
• on convertit les lettres accentuées en lettres non accentuées
• si la lettre est minuscule, on la convertit au hasard en minuscule ou majuscule
• on ajoute au hasard le chiffre quelque part dans la chaine de caractères.

Au travail !¶

Compléter la fonction convertir_ponctuation qui convertit les apostrophes et les signes de ponctuation de la phrase en espaces.

In [ ]:

def convertir_ponctuation(phrase) :
    """
    convertir les apostrophes et les signes de ponctuation de la phrase en espaces
    PARAM
    -----
    phrase(str) : phrase saisie par l'utilisateur
    
    RETURN
    ------
    (str) : phrase saisie par l'utilisateur avec des espaces à la place des apostrophes et des signes de ponctuation
    
    EXAMPLES 
    --------
    >>> convertir_ponctuation("J'adore passer mes vacances à réaliser des devoirs maison.")
    "J adore passer mes vacances à réaliser des devoirs maison"
    
    >>> convertir_ponctuation("J''aime avec une faute de frappe")
    "J  aime avec une faute de frappe"

    >>> convertir_ponctuation("Voilà : écoute, ce que je te dis !")
    "Voilà   écoute  ce que je te dis  "
    """
    phrase_sans_ponctuation = ""
    for i in range(len(phrase)) :
        if phrase[i] in ["'",":",",",";","!",".","?"] :
            phrase_sans_ponctuation = # à compléter
        #à compléter

def convertir_ponctuation(phrase) : """ convertir les apostrophes et les signes de ponctuation de la phrase en espaces PARAM ----- phrase(str) : phrase saisie par l'utilisateur RETURN ------ (str) : phrase saisie par l'utilisateur avec des espaces à la place des apostrophes et des signes de ponctuation EXAMPLES -------- >>> convertir_ponctuation("J'adore passer mes vacances à réaliser des devoirs maison.") "J adore passer mes vacances à réaliser des devoirs maison" >>> convertir_ponctuation("J''aime avec une faute de frappe") "J aime avec une faute de frappe" >>> convertir_ponctuation("Voilà : écoute, ce que je te dis !") "Voilà écoute ce que je te dis " """ phrase_sans_ponctuation = "" for i in range(len(phrase)) : if phrase[i] in ["'",":",",",";","!",".","?"] : phrase_sans_ponctuation = # à compléter #à compléter

Pour chaque fonction, vous devez tester les exemples proposés avant de poursuivre en ajoutant des cellules de test.

In [ ]:

# tester les trois exemples proposés
convertir_ponctuation("J'adore passer mes vacances à réaliser des devoirs maison.")

# tester les trois exemples proposés convertir_ponctuation("J'adore passer mes vacances à réaliser des devoirs maison.")

In [ ]:

Il faut maintenant vérifier que la phrase contient plus de 8 mots.
Pour compter le nombre de mots, on va compter le nombre de fois où on trouve un caractère qui est un espace suivi d'un caractère qui n'est pas un espace.
Dans ce cas, pour détecter le premier mot, il faut ajouter un espace au début de la phrase s'il n'y en a pas.

En suivant cette règle, compléter la fonction verifier_plus_de_huit_mots.

In [ ]:

def verifier_plus_de_huit_mots(phrase) :
    """
    vérifier que la phrase contient plus de 8 mots
    PARAM
    -----
    phrase(str) : phrase saisie par l'utilisateur où il n'y a plus de ponctuation et 
                  chaque mot est séparé par des espaces
    
    RETURN
    ------
    (bool) : vrai si la phrase contient plus de 8 mots
    
    EXAMPLES 
    --------
    >>> verifier_plus_de_huit_mots("C est trop court")
    False
    >>> verifier_plus_de_huit_mots("C est trop         court")
    False
    >>> verifier_plus_de_huit_mots("J adore passer mes vacances à réaliser des devoirs maison")
    True
    """
    # on ajoute un espace pour premier caractère s'il n'y en pas pas
    if phrase[0] != ' ':
        # à compléter
        
    nb_mots = 0
    
    # pour compter le nombre de mots, on cherche le début de chaque mot
    # en testant chaque caractère de la phrase,
    # on détecte le début d'un mot parce qu'il contient un espace suivi d'une lettre 
    for i in range(len(phrase)-1):
        if phrase[i] == ' ' and phrase[i+1] != ' ' :
            # à compléter
            
            
    if nb_mots < 8 :
        # à compléter

def verifier_plus_de_huit_mots(phrase) : """ vérifier que la phrase contient plus de 8 mots PARAM ----- phrase(str) : phrase saisie par l'utilisateur où il n'y a plus de ponctuation et chaque mot est séparé par des espaces RETURN ------ (bool) : vrai si la phrase contient plus de 8 mots EXAMPLES -------- >>> verifier_plus_de_huit_mots("C est trop court") False >>> verifier_plus_de_huit_mots("C est trop court") False >>> verifier_plus_de_huit_mots("J adore passer mes vacances à réaliser des devoirs maison") True """ # on ajoute un espace pour premier caractère s'il n'y en pas pas if phrase[0] != ' ': # à compléter nb_mots = 0 # pour compter le nombre de mots, on cherche le début de chaque mot # en testant chaque caractère de la phrase, # on détecte le début d'un mot parce qu'il contient un espace suivi d'une lettre for i in range(len(phrase)-1): if phrase[i] == ' ' and phrase[i+1] != ' ' : # à compléter if nb_mots < 8 : # à compléter

On vérifie que le chiffre est bien un entier entre 0 et 9.
Compléter la fonction verifier_chiffre.

In [ ]:

def verifier_chiffre(chiffre) :
    """
    vérifier que le chiffre est bien un entier entre 0 et 9.
    PARAM
    -----
    chiffre(int) : chiffre saisi par l'utilisateur
    
    RETURN
    ------
    (bool) : vrai si le chiffre est bien un entier entre 0 et 9.
    
    EXAMPLES 
    --------
    >>> verifier_chiffre(5.3)
    AssertionError: Il faut donner un nombre entier !
    >>> verifier_chiffre(7)
    True
    >>> verifier_chiffre(10)
    AssertionError: Il faut nombre entier entre 0 et 9 !
    """
    # à compléter

def verifier_chiffre(chiffre) : """ vérifier que le chiffre est bien un entier entre 0 et 9. PARAM ----- chiffre(int) : chiffre saisi par l'utilisateur RETURN ------ (bool) : vrai si le chiffre est bien un entier entre 0 et 9. EXAMPLES -------- >>> verifier_chiffre(5.3) AssertionError: Il faut donner un nombre entier ! >>> verifier_chiffre(7) True >>> verifier_chiffre(10) AssertionError: Il faut nombre entier entre 0 et 9 ! """ # à compléter

Il faut maintenant récupérer les initiales de chaque mot pour créer la première version du mot de passe.
On détecte la première lettre de chaque mot de la même façon que pour la fonction verifier_plus_de_huit_mots.
Puis, on crée un algorithme de cumul qui concatène les premières lettres de chaque mot.

In [ ]:

def obtenir_premieres_lettres(phrase):
    """
    créer un mot constitué des premières lettres de chaque mot de la phrase
    PARAM
    -----
    phrase(str) : phrase saisie par l'utilisateur où chaque mot est séparé par des espaces
    
    RETURN
    ------
    (str) : mot constitué des premières lettres de chaque mot de la phrase
    
    EXAMPLES 
    --------
    >>> obtenir_premieres_lettres("J adore passer mes vacances à réaliser des devoirs maison")
    Japmvàrddm
    >>> obtenir_premieres_lettres("Le petit chien s appelle            Idéfix")
    LpcsaI
    """
    # on ajoute un espace pour premier caractère s'il n'y en pas pas
    if phrase[0] != ' ':
        # à compléter
        
    
    mot_de_passe = ""
    
    # en testant chaque caractère de la phrase,
    # on détecte le début d'un mot parce qu'il contient un espace suivi d'une lettre 
    # dans ce cas, on concatène les premières lettres pour créer le mot de passe
    for i in range(len(phrase)-1):
        if phrase[i] == ' ' and phrase[i+1] != ' ' :
            # à compléter
                
    return mot_de_passe

def obtenir_premieres_lettres(phrase): """ créer un mot constitué des premières lettres de chaque mot de la phrase PARAM ----- phrase(str) : phrase saisie par l'utilisateur où chaque mot est séparé par des espaces RETURN ------ (str) : mot constitué des premières lettres de chaque mot de la phrase EXAMPLES -------- >>> obtenir_premieres_lettres("J adore passer mes vacances à réaliser des devoirs maison") Japmvàrddm >>> obtenir_premieres_lettres("Le petit chien s appelle Idéfix") LpcsaI """ # on ajoute un espace pour premier caractère s'il n'y en pas pas if phrase[0] != ' ': # à compléter mot_de_passe = "" # en testant chaque caractère de la phrase, # on détecte le début d'un mot parce qu'il contient un espace suivi d'une lettre # dans ce cas, on concatène les premières lettres pour créer le mot de passe for i in range(len(phrase)-1): if phrase[i] == ' ' and phrase[i+1] != ' ' : # à compléter return mot_de_passe

On suppose que l'utilisateur n'a pas utilisé de majuscule accentuée.
Pour convertir les minuscules accentuées en en leur équivalent non accentué :

1. Chercher toutes les minuscules accentuées possibles en français pour compléter la fonction convertir_sans_accent.
2. Dans cette fonction, on itère sur chaque caractère de mot.
   1. Si le caractère est une minuscule accentuée, on attribue à la variable nv_caractère l'équivalent non accentué du caractère.
   2. Si le caractère n'est pas une minuscule accentuée, on attribue à la variable nv_caractère ce caractère.

In [ ]:

def convertir_sans_accent(mot):
    """
    convertir les lettres accentuées du mot en leur équivalent non accentué"
    PARAM
    -----
    mot(str) : une chaine de caractères
    
    RETURN
    ------
    (str) : la même chaine de caractères sans les accents
    
    EXAMPLES 
    --------
    >>> convertir_sans_accent("Japmvàrddm")
    Japmvarddm
    >>> convertir_sans_accent("àêïôù")
    aeiou
    """
    mot_sans_accent = ""
    for caractere in mot :
        # on étudie tous les cas possibles
        if caractere in ['à','â']:
            nv_caractere = 'a'
        elif  # à compléter
        
            
            
            
            
            
            
            
            
            
            
            
        #dans tous le cas, on ajoute le nouveau caractère à `mot_sans_accent`
        mot_sans_accent = mot_sans_accent + nv_caractere
    return mot_sans_accent

def convertir_sans_accent(mot): """ convertir les lettres accentuées du mot en leur équivalent non accentué" PARAM ----- mot(str) : une chaine de caractères RETURN ------ (str) : la même chaine de caractères sans les accents EXAMPLES -------- >>> convertir_sans_accent("Japmvàrddm") Japmvarddm >>> convertir_sans_accent("àêïôù") aeiou """ mot_sans_accent = "" for caractere in mot : # on étudie tous les cas possibles if caractere in ['à','â']: nv_caractere = 'a' elif # à compléter #dans tous le cas, on ajoute le nouveau caractère à `mot_sans_accent` mot_sans_accent = mot_sans_accent + nv_caractere return mot_sans_accent

En utilisant le code ASCII, comment peut-on savoir si une lettre non accentuée est une majuscule ou une minuscule ?

• Votre réponse : ...

En regardant le code ASCII, on peut voir que le code décimal de chaque lettre majuscule et minuscule a un écart de 32.
Par exemple :
A(65) et a(97) : 97 - 65 = 32
D(68) et d(100) : 100 - 68 = 32
P(80) et p(112) : 112 - 80 = 32

On peut donc convertir une minuscule en sa majuscule en otant 32 à son code décimal en ASCII.

Utiliser cette particularité du code ASCII pour compléter la fonction convertir_majuscule_minuscule_aleatoire.

In [ ]:

from random import randint

def convertir_majuscule_minuscule_aleatoire(lettre):
    """
    convertir aléatoirement une lettre minuscule en majuscule ou minuscule
    PARAM
    -----
    lettre(str) : une lettre non accentuée de l'alphabet
    
    RETURN
    ------
    (str) : la même lettre en majuscule ou en minuscule
    
    EXAMPLES 
    --------
    >>> convertir_majuscule_minuscule_aleatoire("a")
    a
    
    ou aléatoirement
    
    >>> convertir_majuscule_minuscule_aleatoire("a")
    A
    """
    # on choisit au hasard 0 ou 1
    alea = randint(0,1)
    # si le hasard a désigné 1 alors on convertit la lettre en majuscule
        # à compléter
            
    return lettre

from random import randint def convertir_majuscule_minuscule_aleatoire(lettre): """ convertir aléatoirement une lettre minuscule en majuscule ou minuscule PARAM ----- lettre(str) : une lettre non accentuée de l'alphabet RETURN ------ (str) : la même lettre en majuscule ou en minuscule EXAMPLES -------- >>> convertir_majuscule_minuscule_aleatoire("a") a ou aléatoirement >>> convertir_majuscule_minuscule_aleatoire("a") A """ # on choisit au hasard 0 ou 1 alea = randint(0,1) # si le hasard a désigné 1 alors on convertit la lettre en majuscule # à compléter return lettre

En utilisant le code ASCII, comment peut-on savoir si une lettre non accentuée est une majuscule ou une minuscule ?

• Votre réponse : ...

Compléter la fonction modifier_mot_majuscule_minuscule(mot) qui :

• itère sur chaque lettre du mot
• appelle, si la lettre est une minuscule, la fonction convertir_majuscule_minuscule_aleatoire
• renvoie un nouveau mot de passe avec des minuscules parfois modifiées en majuscules.

In [ ]:

def modifier_mot_majuscule_minuscule(mot):
    """
    convertir aléatoirement chaque lettre minuscule d'un mot en majuscule ou minuscule, 
    ne pas la modifier si elle est en majuscule
    PARAM
    -----
    mot(str) : une chaine de caractères de lettres non accentuées
    
    RETURN
    ------
    (str) : le même mot avec des majuscules et des minuscules aléatoires
    
    EXAMPLES 
    --------
    >>> modifier_mot_majuscule_minuscule("Japmvarddm")
    JApMvARDdm
    
    ou aleatoirement
    
    >>> modifier_mot_majuscule_minuscule("Japmvarddm")
    JaPMVarDDm
    >>> modifier_mot_majuscule_minuscule("ABCDefgh")
    ABCDeFgH
    """
    nv_mot = ""
    # on itère sur chaque lettre du mot 
    # à compléter
        
        # si la lettre est une minuscule
        # on convertit aléatoirement cette lettre en majuscule ou minuscule
        # on concatène le nouveau mot et cette nouvelle lettre 
        # à compléter
        
        
        
        # sinon on concatène `nv_mot` et cette lettre
        else :
            nv_mot = nv_mot + lettre
    return nv_mot

def modifier_mot_majuscule_minuscule(mot): """ convertir aléatoirement chaque lettre minuscule d'un mot en majuscule ou minuscule, ne pas la modifier si elle est en majuscule PARAM ----- mot(str) : une chaine de caractères de lettres non accentuées RETURN ------ (str) : le même mot avec des majuscules et des minuscules aléatoires EXAMPLES -------- >>> modifier_mot_majuscule_minuscule("Japmvarddm") JApMvARDdm ou aleatoirement >>> modifier_mot_majuscule_minuscule("Japmvarddm") JaPMVarDDm >>> modifier_mot_majuscule_minuscule("ABCDefgh") ABCDeFgH """ nv_mot = "" # on itère sur chaque lettre du mot # à compléter # si la lettre est une minuscule # on convertit aléatoirement cette lettre en majuscule ou minuscule # on concatène le nouveau mot et cette nouvelle lettre # à compléter # sinon on concatène `nv_mot` et cette lettre else : nv_mot = nv_mot + lettre return nv_mot

Compléter la fonction ajouter_chiffre qui améliore la sécurité du mot de passe en ajoutant le chiffre quelque part dans le mot.

In [ ]:

def ajouter_chiffre(mot,chiffre):
    """
    ajouter un chiffre quelque part dans le mot
    PARAM
    -----
    mot(str) : une chaine de caractères
    chiffre(int) : un chiffre
    
    RETURN
    ------
    (str) : le même mot mais avec un chiffre inséré quelquepart
    
    EXAMPLES 
    --------
    >>> ajouter_chiffre("JApMvARDdm",5)
    JApM5vARDdm
    
    ou aléatoiremment 
    
    >>> ajouter_chiffre("JApMvARDdm",5)
    JApMvARDdm5
    
    >>> ajouter_chiffre("aBcdEF",9)
    a9BcdEF
    """

def ajouter_chiffre(mot,chiffre): """ ajouter un chiffre quelque part dans le mot PARAM ----- mot(str) : une chaine de caractères chiffre(int) : un chiffre RETURN ------ (str) : le même mot mais avec un chiffre inséré quelquepart EXAMPLES -------- >>> ajouter_chiffre("JApMvARDdm",5) JApM5vARDdm ou aléatoiremment >>> ajouter_chiffre("JApMvARDdm",5) JApMvARDdm5 >>> ajouter_chiffre("aBcdEF",9) a9BcdEF """

Le programme principal appelle toutes ces fonctions pour créer le mot de passe à l'aide de la saisie de l'utilisateur.

In [ ]:

###################################################
#####    PROGRAMME PRINCIPAL DE LA PHASE 1    #####
###################################################
chiffre = int(input("Saisir un chiffre (pas un nombre !) : "))
if verifier_chiffre(chiffre) :
    verif = False
    while not verif :
        phrase = input("Saisir votre phrase de code de plus de 8 mots : ")
        phrase = convertir_ponctuation(phrase)
        verif = verifier_plus_de_huit_mots(phrase)
        if not verif :
            print("Votre phrase est trop courte.")
mot_de_passe = obtenir_premieres_lettres(phrase)
mot_de_passe = convertir_sans_accent(mot_de_passe)
mot_de_passe = modifier_mot_majuscule_minuscule(mot_de_passe)
mot_de_passe = ajouter_chiffre(mot_de_passe,chiffre)
print("Votre mot de passe est : ", mot_de_passe)

################################################### ##### PROGRAMME PRINCIPAL DE LA PHASE 1 ##### ################################################### chiffre = int(input("Saisir un chiffre (pas un nombre !) : ")) if verifier_chiffre(chiffre) : verif = False while not verif : phrase = input("Saisir votre phrase de code de plus de 8 mots : ") phrase = convertir_ponctuation(phrase) verif = verifier_plus_de_huit_mots(phrase) if not verif : print("Votre phrase est trop courte.") mot_de_passe = obtenir_premieres_lettres(phrase) mot_de_passe = convertir_sans_accent(mot_de_passe) mot_de_passe = modifier_mot_majuscule_minuscule(mot_de_passe) mot_de_passe = ajouter_chiffre(mot_de_passe,chiffre) print("Votre mot de passe est : ", mot_de_passe)