Les dictionnaires et le cryptage.¶

Nous allons envoyer des messages cryptés pour que personne ne puisse les intercepter. Et nous allons les décoder.
Pour cela nous allons avoir besoin d'un type structuré de variable, les dictionnaires.
Un dictionnaire est un conteneur mutable, c'est à dire que l'on peut ajouter, supprimer ou modifier son contenu.
Il se présente sous la forme d'une liste de deux éléments, le premier est la clé, le second est la valeur.

exemple et notation:
        {clé1:val1, clé2:val2, ...}

Les étapes du cryptage sont les suivantes:
1/ Créer un dictionnaire permettant d'établir un lien : lettre de l'alphabet, valeur de 0 à 25.
2/ Convertir le message en nombre.
3/ Utiliser une formule pour associer à un nombre entre 0 et 25 un autre nombre entre 0 et 25.
4/ Créer un dictionnaire permettant d'établir un lien : valeur de 0 à 25, lettre de l'alphabet.
5/ Et enfin, il faudra penser au décryptage.

Comme vous le comprenez, nous allons utiliser plusieurs fonctions.

Activité 1¶

Créez le dictionnaire établissant le lien lettre et nombre: lien_L_N

Deux méthodes :¶

Méthode 1 :¶

   Créer le dictionnaire à la main, c'est à dire, tapez:
   lien_L_N={'a':0,'b':1,......}
   Pas amusant.

Méthode 2¶

   Construire un programme qui remplisse le dictionnaire pour nous.
   Créez undictionnaire vide : lien_L_N={}
   Initialiser une variable j à 0 que nous incrémenterons pour aller de 0 à 25
   Céez une variable alphabet qui sera égale à une chaine de caractère contenant l'alphabet
   Créez une boucle avec une variable i qui va prendre les valeurs du conteneur alphabet.
   Remplir notre dictionnaire : lien_L_N[i]=j
   Incrémenter j
   Afficher dictionnaire.
In [ ]:
lien_L_N={}
j=0
alphabet='abcdefghijklmnopqrstuvwxyz'
for i in alphabet:   
    lien_L_N[i]=j
    j=j+1
print(lien_L_N)

Activité 2¶

Transformez votre programme en fonction : dico_L_N()
Pensez à renvoyer le dictionnaire.
Afficher le dictionnaire dans le programme principale.
In [ ]:
### section des fonctions

def dico_L_N():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les lettres de l'alphabet et les nombres de 0 à 25"""
    
    lien_L_N={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_L_N[i]=j                       # Remplit le dictionnaire en établissant la correspondance lettre-nombre
        j=j+1                               # Pensez à incrémenter j
    return lien_L_N
        
### section main
    
print(dico_L_N())

Activité 3¶

Avant de poursuivre, je vous propose de construire notre second dictionnaire ayant pour clé les nombres et pour valeur les lettres.. 
Créez une fonction peremttant de remplir notre second dictionnaire : lien_N_L
Pensez à l'afficher dans le menu principal pour vérifier que cela fonctionne.
In [ ]:
### section des fonctions

def dico_L_N():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les lettres de l'alphabet et les nombres de 0 à 25."""
    
    lien_L_N={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_L_N[i]=j                       # Remplit le dictionnaire en établissant la correspondance lettre-nombre
        j=j+1                               # Pensez à incrémenter j
    return lien_L_N

def dico_N_L():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les nombres de 0 à 25 et les lettres de l'alphabet."""
    
    lien_N_L={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_N_L[j]=i                       # Remplit le dictionnaire en établissant la correspondance nombre-lettre
        j=j+1                               # Pensez à incrémenter j
    return lien_N_L
        
### section main
    
print(dico_L_N())
print(dico_N_L())

Activité 4¶

Maintenant, vous allez transformer le message 'salut' en liste de nombre que vous nommerez : liste_N
Et que vous afficherez.
In [ ]:
### section des fonctions

def dico_L_N():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les lettres de l'alphabet et les nombres de 0 à 25."""
    
    lien_L_N={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_L_N[i]=j                       # Remplit le dictionnaire en établissant la correspondance lettre-nombre
        j=j+1                               # Pensez à incrémenter j
    return lien_L_N

def dico_N_L():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les nombres de 0 à 25 et les lettres de l'alphabet."""
    
    lien_N_L={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_N_L[j]=i                       # Remplit le dictionnaire en établissant la correspondance nombre-lettre
        j=j+1                               # Pensez à incrémenter j
    return lien_N_L
                
### section main

dict_L_N=dico_L_N()
message="salut"
liste_N=[]
for i in message:
    liste_N.append(dict_L_N[i])
print(liste_N)

Activité 5¶

Vous allez transformer votre programme en fonction : trans_M_L_N()
Cette fonction appellera le dictionnaire utile et le message.
Pour remplir la liste, vous utiliserez la méthode append.
Vous penserez à afficher le résultat dans le menu principal.
In [ ]:
### section des fonctions

def dico_L_N():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les lettres de l'alphabet et les nombres de 0 à 25."""
    
    lien_L_N={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_L_N[i]=j                       # Remplit le dictionnaire en établissant la correspondance lettre-nombre
        j=j+1                               # Pensez à incrémenter j
    return lien_L_N

def dico_N_L():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les nombres de 0 à 25 et les lettres de l'alphabet."""
    
    lien_N_L={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_N_L[j]=i                       # Remplit le dictionnaire en établissant la correspondance nombre-lettre
        j=j+1                               # Pensez à incrémenter j
    return lien_N_L

def trans_M_L_N(dict_L_N,message):
    
    """Cette fontion permet de transformer un message en liste de nombres."""
    
    liste_N=[]                              # Initialise une liste vide
    for i in message:
        liste_N.append(dict_L_N[i])         # Ajoute dans la liste "liste_N" la valeur du dictionnaire dict_L_N correspondant à la clé i
    return liste_N
    
### section main

dict_L_N=dico_L_N()
message="salut"
print(trans_M_L_N(dict_L_N,message))

Activité 6¶

Ajoutez une fonction qui transformera la liste de nombre en message (lettres) trans_L_N_M.
Pensez à afficher le résultat pour voir si l'on retrouve bien "salut".
In [ ]:
### section des fonctions

def dico_L_N():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les lettres de l'alphabet et les nombres de 0 à 25."""
    
    lien_L_N={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_L_N[i]=j                       # Remplit le dictionnaire en établissant la correspondance lettre-nombre
        j=j+1                               # Pensez à incrémenter j
    return lien_L_N

def dico_N_L():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les nombres de 0 à 25 et les lettres de l'alphabet."""
    
    lien_N_L={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_N_L[j]=i                       # Remplit le dictionnaire en établissant la correspondance nombre-lettre
        j=j+1                               # Pensez à incrémenter j
    return lien_N_L

def trans_M_L_N(dict_L_N,message):
    
    """Cette fontion permet de transformer un message en liste de nombres."""
    
    liste_N=[]                              # Initialise une liste vide
    for i in message:
        liste_N.append(dict_L_N[i])         # Ajoute dans la liste "liste_N" la valeur du dictionnaire dict_L_N correspondant à la clé i
    return liste_N
    
def trans_L_N_M(dict_N_L,list_N):
    
    """Cette fonction permet de transformer une liste de nombre en message."""
    
    message_D=""                            # Initialise 
    for i in list_N:
        message_D=message_D+dict_N_L[i]     # Concatenne les lettres ue par une
    return message_D
    
### section main

dict_L_N=dico_L_N()
dict_N_L=dico_N_L()
message="salut"
list_N=trans_M_L_N(dict_L_N,message)
print(trans_L_N_M(dict_N_L,list_N))

Faisons le point, nous savons :¶

Transformer un message en liste de nombres.
Transformer une liste de nombres en message.

Il nous faut désormais :¶

crypter notre message, c'est à dire:
message -> liste de nombres -> **cryptage affine** -> liste de nombres -> message incompréhensible.

Voyons ce qu'est ce cryptage affine.¶

Vous allez utiliser la clé 9 et 5.
C'est à dire que nous allons calculer l'expression 9x+5 pour chaque valeur de la liste de nombre.
Puis nous allons en prendre le reste dans la division euclidienne par 26 :   (9x+5)%26
Nous retrouvons bien un nombre entre 0 (la division tombe juste) et 25 (le reste est forcément plus petit que 26).

Activité 7¶

Créez une fonction cryptage, qui utilisera le bon dictionnaire et la liste de nombres utiles.
Celle-ci renverra le message crypté que vous devrez afficher.
In [ ]:
### section des fonctions

def dico_L_N():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les lettres de l'alphabet et les nombres de 0 à 25."""
    
    lien_L_N={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_L_N[i]=j                       # Remplit le dictionnaire en établissant la correspondance lettre-nombre
        j=j+1                               # Pensez à incrémenter j
    return lien_L_N

def dico_N_L():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les nombres de 0 à 25 et les lettres de l'alphabet."""
    
    lien_N_L={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_N_L[j]=i                       # Remplit le dictionnaire en établissant la correspondance nombre-lettre
        j=j+1                               # Pensez à incrémenter j
    return lien_N_L

def trans_M_L_N(dict_L_N,message):
    
    """Cette fontion permet de transformer un message en liste de nombres."""
    
    liste_N=[]                              # Initialise une liste vide
    for i in message:
        liste_N.append(dict_L_N[i])         # Ajoute dans la liste "liste_N" la valeur du dictionnaire dict_L_N correspondant à la clé i
    return liste_N
    
def trans_L_N_M(dict_N_L,list_N):           # Initialise
    message_D=""
    for i in list_N:
        message_D=message_D+dict_N_L[i]     # Concatenne les lettres une par une
    return message_D
    
def cryptage(dico,liste):
    
    """Cette fonction permet de crypter un mot"""
    
    liste_C=[]
    for i in range(len(liste)):
        liste_C.append((9*liste[i]+5)%26)    # Chaque nombre est remplacé par le reste dans la division euclideienne de 9*ce nombre +5
    message_C=trans_L_N_M(dico,liste_C)
    return message_C
    
### section main

dict_L_N=dico_L_N()
dict_N_L=dico_N_L()
message="salut"
list_N=trans_M_L_N(dict_L_N,message)
print(cryptage(dict_N_L,list_N))

Activité 8¶

Il serait bon que la personne qui reçoit le message puisse le décrypter. 
La technique de décryptage est la même. Il faut connaitre la clé correspondante à la clé de cryptage.
Ici la clé de décryptage est 3 et 11.
Construire une fonction décryptage.
Remplacer le message par : lfadu
Puis décryptez le.
In [ ]:
### section des fonctions

def dico_L_N():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les lettres de l'alphabet et les nombres de 0 à 25."""
    
    lien_L_N={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_L_N[i]=j                       # Remplit le dictionnaire en établissant la correspondance lettre-nombre
        j=j+1                               # Pensez à incrémenter j
    return lien_L_N

def dico_N_L():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les nombres de 0 à 25 et les lettres de l'alphabet."""
    
    lien_N_L={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_N_L[j]=i                       # Remplit le dictionnaire en établissant la correspondance nombre-lettre
        j=j+1                               # Pensez à incrémenter j
    return lien_N_L

def trans_M_L_N(dict_L_N,message):
    
    """Cette fontion permet de transformer un message en liste de nombres."""
    
    liste_N=[]                              # Initialise une liste vide
    for i in message:
        liste_N.append(dict_L_N[i])         # Ajoute dans la liste "liste_N" la valeur du dictionnaire dict_L_N correspondant à la clé i
    return liste_N
    
def trans_L_N_M(dict_N_L,list_N):           # Initialise
    message_D=""
    for i in list_N:
        message_D=message_D+dict_N_L[i]     # Concatenne les lettres une par une
    return message_D
    
def cryptage(dico,liste):
    
    """Cette fonction permet de crypter un mot"""
    
    liste_C=[]
    for i in range(len(liste)):
        liste_C.append((9*liste[i]+5)%26)    # Chaque nombre est remplacé par le reste dans la division euclideienne de 9*ce nombre +5
    message_C=trans_L_N_M(dico,liste_C)
    return message_C

def decryptage(dico,liste):
    
    """Cette fonction permet de crypter un mot"""
    
    liste_D=[]
    for i in range(len(liste)):
        liste_D.append((3*liste[i]+11)%26)    # Chaque nombre est remplacé par le reste dans la division euclideienne de 9*ce nombre +5
    message_D=trans_L_N_M(dico,liste_D)
    return message_D

    
### section main

dict_L_N=dico_L_N()
dict_N_L=dico_N_L()
message="lfadu"
list_N=trans_M_L_N(dict_L_N,message)
# print(cryptage(dict_N_L,list_N))
print(decryptage(dict_N_L,list_N))

Activité 9¶

Vous avez presque fini. Il vous reste à demander à l'utilisateur s'il souhaite crypter ou décrypter un message. 
Puis à gérer la saisie de la chaine de caractère sur laquelle il faut travailler.
In [ ]:
### section des fonctions

def dico_L_N():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les lettres de l'alphabet et les nombres de 0 à 25."""
    
    lien_L_N={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_L_N[i]=j                       # Remplit le dictionnaire en établissant la correspondance lettre-nombre
        j=j+1                               # Pensez à incrémenter j
    return lien_L_N

def dico_N_L():
    
    """Cette fonction permet de remplir un dictionnaire de correspondance entre les nombres de 0 à 25 et les lettres de l'alphabet."""
    
    lien_N_L={}                             # Initialise un dictionnaire vide
    j=0
    alphabet='abcdefghijklmnopqrstuvwxyz'
    for i in alphabet:   
        lien_N_L[j]=i                       # Remplit le dictionnaire en établissant la correspondance nombre-lettre
        j=j+1                               # Pensez à incrémenter j
    return lien_N_L

def trans_M_L_N(dict_L_N,message):
    
    """Cette fontion permet de transformer un message en liste de nombres."""
    
    liste_N=[]                              # Initialise une liste vide
    for i in message:
        liste_N.append(dict_L_N[i])         # Ajoute dans la liste "liste_N" la valeur du dictionnaire dict_L_N correspondant à la clé i
    return liste_N
    
def trans_L_N_M(dict_N_L,list_N):           # Initialise
    message_D=""
    for i in list_N:
        message_D=message_D+dict_N_L[i]     # Concatenne les lettres une par une
    return message_D
    
def cryptage(dico,liste):
    
    """Cette fonction permet de crypter un mot"""
    
    liste_C=[]
    for i in range(len(liste)):
        liste_C.append((9*liste[i]+5)%26)    # Chaque nombre est remplacé par le reste dans la division euclideienne de 9*ce nombre +5
    message_C=trans_L_N_M(dico,liste_C)
    return message_C

def decryptage(dico,liste):
    
    """Cette fonction permet de décrypter un mot"""
    
    liste_D=[]
    for i in range(len(liste)):
        liste_D.append((3*liste[i]+11)%26)    # Chaque nombre est remplacé par le reste dans la division euclideienne de 3*ce nombre +11
    message_D=trans_L_N_M(dico,liste_D)
    return message_D

    
### section main

dict_L_N=dico_L_N()
dict_N_L=dico_N_L()
question=input('Vous souhaitez crypter ou décrypter un message.   ')
if question=='crypter':
    message=input('Entrez le message (ne mettre ni espace, ni ponctuation)   ')
    list_N=trans_M_L_N(dict_L_N,message)
    print(cryptage(dict_N_L,list_N))
elif question=='décrypter':
    message=input('Entrez la chaine de caractères (ne mettre ni espace, ni ponctuation)   ')
    list_N=trans_M_L_N(dict_L_N,message)
    print(decryptage(dict_N_L,list_N))
else:
    print("Je n'ai pas compris.")
Vous aurez constaté que nous avons eu besoin de 6 fonctions et d'un programme principal. 
Si je vous avais demandé par groupe de réaliser un tel programme.
Vous auriez du découper le programme en tâches (fonctions) et vous les répartir.