Projet NSI Fermé

Question

Bonjour aux personnes qui verront ça j'espère trouver de l'aide ici 
Je me retrouve face à un sujet de code et je vous avouerais que je bloque pas mal dessus.
L'énoncé est le suivant :

Coder des fonctions qui donnent à la suite les résultats suivants
Chaine à coder : NSI
#Entrer ce code donnera donc premièrement le résultat en binaire suivant :
Chaine en binaire : 010011100101001101001001
#Il faut ensuite séparer la chaîne en groupes de 4 dans une autre fonction.
=> "0100", "1110", "0101", "0011", "0100", "1001"
#Pour la prochaine fonction, il faut rajouter pour chaque groupe de 4 à gauche '01' et à droite '10' (si ce n'est pas clair j'expliquerai plus en détail) Cela donne le résultat suivant :
=> "01010010", "01111010", "01010110", "01001110", "01010010", "01100110"
Puis pour terminer dans la dernière fonction, il faudra mettre les quatre premiers bits à droite et les quatre derniers bits à gauche pour chaque groupes de bits. Cela va donner le résultat suivant :
=> "00100101", "10100111", "01100101", "11100100", "00100101", "01100110"
Une fois ce résultat, on va reconvertir chaque bit en un caractère ce qui donnera le codage suivant :  
=>Le codage de votre chaîne est : %§eä%f

J'ai déjà écrit une partie du code, mais je vais avoir besoin d'aide. Je vous met en dessous ce que j'ai déjà écrit.

Je récupère d'abord la chaîne de caractère qui ici doit être NSI et la convertit en binaire avec le procédé suivant
#Convertir un texte en binaire
#1 - Récupérer le texte suivant.
#2 - Le convertir en valeurs ASCII.
#3 - Diviser chaque nombre par 2 et garder le reste jusqu'à avoir une valeur de zéro.
#4 - Prendre votre séquence de restes de chaque division.
#5 - Inverser les séquences. (Remonter du dernier résultat vers le premier, puisque cela m'est donné à l'envers avec la technique que nous avons. (J'ai déjà ce qui me permet de renverser ceci, là n'est pas le problème)

def Binaire(Chaine):
    ListeASCII = []
    for k in Chaine:
        New = [str(ord(k))]
        ListeASCII += New
    print(ListeASCII)
    BinList = []
    for i in range (len(ListeASCII)):
        nombre = (int(ListeASCII[i]))
        print (nombre)
        for k in range (0, 8):
            juy = int(nombre)
            hak = juy%2
            BinList.append(hak)
        print (BinList)

Pour commencer, je ne comprend pas pourquoi ici le résultat de juy n'est pas compris en tant qu'entier pourriez vous m'indiquer ou est le problème et comment le résoudre ?

jee pee · Answer

Bonjour,

D'abord, pour la mise en forme des sources, au dessus de la zone d'édition de tes messages, il y a des icônes pour l'enrichissement du texte. Celle qui a cet aspect <> ▼ permet d'appliquer au code, suivant une liste de valeurs, le format correspondant à sa nature. 
Un petit tuto là : https://codes-sources.commentcamarche.net/faq/11288-les-balises-de-code 

nombre est déjà un integer, pourquoi le reconvertir dans juy ??

Je te propose plutôt pour créer la chaine binaire (on pourrait utiliser (bin() mais c'est moins fun) :
def Binaire(Chaine):
    ListeASCII = []
    for k in Chaine:
        New = [str(ord(k))]
        ListeASCII += New
    print('Liste Ascii',ListeASCII)
    BinList = ''
    for i in range (len(ListeASCII)):
        nombre = (int(ListeASCII[i]))
        res=''
        for k in range (0, 8):
           q = nombre // 2
           r = nombre % 2
           res = str(r) + res
           nombre = q
        print (res)
        BinList += res
    return(BinList)

r1=Binaire('NSI')
print('Réponse 1 =',r1)

Adrya · Answer

Bonjour, me revoila bien rapidement ^^'. J'ai passé cette après midi à essayer de coder la deuxième fonction dont j'ai besoin, celle qui sépare de 4 bits en 4 bits. Je vous joins le code ci-dessous dans les réponses à ma propre question :)

Adrya · Answer

def Binaire(Chaine):    ListeASCII = []    for k in Chaine:        New = [str(ord(k))]        ListeASCII += New    print("ListeASCII : ", ListeASCII, "
")    ChaineBinaire = ""    for i in range (len(ListeASCII)):        nombre = (int(ListeASCII[i]))        reste = ""        print ("Nombre ASCII à coder en biaire : ", nombre)        for k in range (0, 8):            juy = nombre//2            hak = nombre%2            reste += str(hak)            nombre = juy        print ("Nombre ASCII donné en binaire : ", reste, "
")        ChaineBinaire += reste    return 'Chaîne binaire finale : ', ChaineBinaire           ##Jusqu'ici c'est le code qui fonctionne pour lequel vous m'avez aidée hier, ci dessous arrive le code de la suite de l'exercice.def Separation(ChaineBin):    KevList = []    for k in range (len(ChaineBin)):        KevList += ChaineBin[k]    print (KevList)    SangList = []    ErList = []    KevListBis = KevList    for u in range (len(KevListBis)):        for i in range (4):            SangList += KevList[i]        KevList[0:4] = []    ErList += SangList    print (ErList)    print (SangList)       Chaine = input("Chaîne à coder : ")ChaineBin = (Binaire(Chaine))print (Separation(ChaineBin))

Pour l'instant, je n'arrive pas a enlever l'affichage présent qui me détaille Chaine Binaire à chaque fois. Je n'arrive pas non plus à arranger le out of range donné quand je teste la fonction seule sur un autre page.

jee pee · Answer

Voilà comment je te propose de procéder 

def Binaire(Chaine):
    ListeASCII = []
    for k in Chaine:
        New = [str(ord(k))]
        ListeASCII += New
    print("ListeASCII : ", ListeASCII, "
")
    ChaineBinaire = ""
    for i in range (len(ListeASCII)):
        nombre = (int(ListeASCII[i]))
        reste = ""
        print ("Nombre ASCII à coder en biaire : ", nombre)
        for k in range (0, 8):
            juy = nombre//2
            hak = nombre%2
            reste += str(hak)
            nombre = juy
        print ("Nombre ASCII donné en binaire : ", reste, "
")
        ChaineBinaire += reste
    return ChaineBinaire
           
##Jusqu'ici c'est le code qui fonctionne pour lequel vous m'avez aidée hier, ci dessous arrive le code de la suite de l'exercice.

def Separation(ChaineBin):
    KevList = []
    for k in range (len(ChaineBin)):
        KevList += ChaineBin[k]
    print (KevList)
    SangList = []
    ErList = []
    KevListBis = KevList
    for u in range (len(KevListBis)):
        for i in range (4):
            SangList += KevList[i]
        KevList[0:4] = []
    ErList += SangList
    print (ErList)
    print (SangList)
    
Chaine = input("Chaîne à coder : ")
ChaineBin = (Binaire(Chaine))
print(ChaineBin)
ChaineSepare=Separation(ChaineBin)
print (ChaineSepare)

c'est juste sur la forme de l'enchainement. Sans regarder ta 2ème fonction, qui devrait avoir un return pas l'afficher, car il faut recuperer le resultat pour le passer à l'étape suivante. 

J'ai pour ma part écrit un code qui répond à l'exercice. Sans dévoiler le code, voilà l'appel des fonctions : 
r1 = ch2bin('NSI')
print('Réponse 1 =',r1)
r2 = bin2qua(r1)
print('Réponse 2 =',r2)
r3 = qua2oct(r2)
print('Réponse 3 =',r3)
r4 = invqua(r3)
print('Réponse 4 =',r4)
r5 = bin2ch(r4)
print('Réponse 5 =',r5)

Et l'affichage final
Réponse 1 = 010011100101001101001001Réponse 2 = ['0100', '1110', '0101', '0011', '0100', '1001']Réponse 3 = ['01010010', '01111010', '01010110', '01001110', '01010010', '01100110']Réponse 4 = ['00100101', '10100111', '01100101', '11100100', '00100101', '01100110']Réponse 5 = %§eä%f 

La seconde fonction doit découper une chaine par groupe de 4, donc il faut soit regrouper les bits par 4, soit directement découper la chaine d'entrée 4 par 4.

Adrya · Answer

Je viens tout juste d'essayer avec cet ordre mais je me retrouve toujours avec l'erreur suivante :
SangList += KevList[i]
IndexError : list index out of range 

Je ne comprend pas comment arriver à supprimer cette erreur.

Adrya · Answer

Votre message m'a fait trouver mon erreur à ce niveau !! :)
Je mettait un range trop grand il me fallait le mettre seulement à 6 !
Je termine mes changements et je travaillerais demain sur ma troisième fonction si je ne tombe pas sur d'autres problèmes avant de commencer celle ci.
Merci encore pour votre aide !!

Adrya · Answer

Me revoici (désolée...)
Je viens de me rendre compte d'un problème dans le code de la fonction Separation que j'ai changé par illumination tout à l'heure 
Cela ne m'affiche que la première partie des séquences dont j'ai besoin :
def Separation(ChaineBin):    KevList = []    QuadrBin = ''    for u in range (6):        for k in range (1,5):            QuadrBin = ChaineBin[0:k]            ChaineBin.replace(ChaineBin[0:4], '')        KevList += [QuadrBin]    return KevList

Je pense que mon erreur est au niveau de la suppression des 4 premiers termes de ChaineBin avec .replace, mais je ne suis pas sure.

Adrya · Answer

Ah je comprend mieux (Merci d'avoir répondu, et désolée de revenir si tard, je viens d'arriver chez moi)
Je vais continuer avec la fonction que j'ai commencée ce matin, je reviendrai de nouveau vers vous si je me retrouve à nouveau face à un problème (ce qui risque d'arriver)

Adrya · Answer

Me revoila avec un nouveau besoin d'aide ...
Je vous joint ci dessous jusqu'ou j'en sui arrivée aujourd'hui 
def Binaire(Chaine):
    ListeASCII = []
    for k in Chaine:
        New = [str(ord(k))]
        ListeASCII += New
    print("ListeASCII : ", ListeASCII, "
")
    ChaineBinaire = ""
    for i in range (len(ListeASCII)):
        nombre = (int(ListeASCII[i]))
        reste = ""
        print ("Nombre ASCII à coder en biaire : ", nombre)
        for k in range (0, 8):
            juy = nombre//2
            hak = nombre%2
            reste += str(hak)
            nombre = juy
        print ("Nombre ASCII donné en binaire : ", reste, "
")
        ChaineBinaire += reste
    print ("Chaine binaire finale : ")
    return ChaineBinaire

def Separation(ChaineBin):
    KevList = []
    for u in range(len(ChaineBin)//4):
       QuadrBin = ''
       for k in range (4):
           QuadrBin += ChaineBin[u*4+k:u*4+k+1]
       KevList += [QuadrBin]
    print ("Chaine séparée par groupes de 4 bits : ")
    return KevList

def Rajout(ChaineSeparee):
    #Rajoute 01 à gauche et 10 à droite
    ChaList = []
    for u in range (6):
        ChaList += "0"
        ChaList[u] += "1"
        ChaList[u] += ChaineSeparee[u]
    for k in range (6):
        ChaList[k] += "10"
    print ("Chaine contenant le rajout : ")
    return ChaList

def Inversion(ChaineRajout):
    NewChaine = ''
    for k in range(6):
        NewChaine += ChaineRajout[k]
    NewSep = Separation(NewChaine)
    ## Jusqu'ici on a la séparation 4 par 4
    MinList = []
    for p in range (len(NewSep)):
        MinList += NewSep[p+1]
        MinList += NewSep[p]
        NewSep.remove(NewSep[p+1])
        NewSep.remove(NewSep[p])
    return MinList

Chaine = input("Chaîne à coder : ")
ChaineBin = (Binaire(Chaine))
print(ChaineBin)
print ("
")
ChaineSeparee = Separation(ChaineBin)
print (ChaineSeparee)
print ("
")
ChaineRajout = Rajout(ChaineSeparee)
print (ChaineRajout)
print ("
")
ChaineInversee = Inversion(ChaineRajout)
print (ChaineInversee)


La fonction Rajout que j'ai crée ce matin m'a l'air de fonctionner correctement pour l'instant.
Cependant, pour ma fonction Inversion, je ne comprend pas comment régler le problème qui m'est encore posé: le out of range au niveau de MinList += NewSep[p+1]

jee pee · Answer

Il faut d'abord que tu compares tes résultats à ceux donnés dans l’énoncé et c'est à faire à chaque étape, moi c'est ce que j'ai fait pour déceler mes erreurs. A l'étape 1 ta chaine binaire n'est pas bonne.

Tu concatènes les bits de l'octet de gauche à droite, alors qu'il faudrait le faire de droite à gauche.

Après, comme déjà indiqué, tu ne peux pas traiter en dur une longueur de 6 (Rajout et Inversion), il faut prendre la taille de la liste de données reçue par la fonction.

Dans Rajout tu rajoutes '10' en une fois, OK, pourquoi pas '01' aussi en une fois ? alors qu'il te faut 2 lignes.

Ta fonction Inversion il faut le revoir en totalité. Pourquoi rappeler Separation ??? Reprends de zéro. Tu reçois une liste de chaine de caractères faisant chacun 8 bits. Donc tu fais une boucle sur la taille de la liste. Pour chaque variable de 8 bits tu crées une nouvelle variable = les 4 derniers + les 4 premiers bits. Sur une chaine de 8 caractères, les 4 premiers c'est chaine[0:4] et les 4 derniers chaine[4:8]. Si pour la taille de la liste traitées, 'NSI' au départ, on gère une boucle puisque la taille est théoriquement inconnue, pour les chaines de bits, elles font 4 ou 8 bits, là on doit considérer que leur taille est fixe.  

Globalement ton code comporte trop de lignes et trop de variables. Mais c'est normal quand on débute dans la programmation. C'est en progressant que l'on voit que l'on peut faire plus court et plus simple, et aussi en connaissant les instructions, et comme ici les traitements sur les chaines de caractères.

Par exemple en Python on peut très simplement concaténer les chaines.
a='AA'
b='BBBB'
e=a+b+'CC' 
au final e vaut 'AABBBBCC'

Adrya · Answer

J'ai compris mon erreur pour la chaine Binaire, je viens de la corriger : 
def Binaire(Chaine):
    ListeASCII = []
    for k in Chaine:
        New = [str(ord(k))]
        ListeASCII += New
    print("ListeASCII : ", ListeASCII, "
")
    ChaineBinaire = ""
    for i in range (len(ListeASCII)):
        nombre = (int(ListeASCII[i]))
        reste = ""
        print ("Nombre ASCII à coder en biaire : ", nombre)
        for k in range (0, 8):
            juy = nombre//2
            hak = nombre%2
            reste += str(hak)
            nombre = juy
        print ("Nombre ASCII donné en binaire : ", reste, "
")
        for p in reversed(reste):
            ChaineBinaire += p
    print ("Chaine binaire finale : ")
    return ChaineBinaire

Chaine = input("Chaîne à coder : ")
ChaineBin = (Binaire(Chaine))
print(ChaineBin)

Je vais recommencer ma fonction Inversion

Adrya · Answer

Je comprend bien que ce n'est que pour me faire avancer, je vous remercie d'ailleurs de me faire ces remarques je saurais à quoi faire attention si je retravaille sur un projet de la sorte. Je regarderais comme les appliquer demain, puisque je viens juste de les voir.
Cependant pendant mon après midi, j'ai enfin terminé le code avec les résultats que je veux avoir et cette fois même si trop long pour le moment, il fonctionne.

def Binaire(Chaine):
    ListeASCII = []
    for k in Chaine:
        New = [str(ord(k))]
        ListeASCII += New
    ChaineBinaire = ""
    for i in range (len(ListeASCII)):
        nombre = (int(ListeASCII[i]))
        reste = ""
        for k in range (0, 8):
            juy = nombre//2
            hak = nombre%2
            reste += str(hak)
            nombre = juy
        for p in reversed(reste):
            ChaineBinaire += p
    return ChaineBinaire

def Separation(ChaineBin):
    KevList = []
    for u in range(len(ChaineBin)//4):
       QuadrBin = ''
       for k in range (4):
           QuadrBin += ChaineBin[u*4+k:u*4+k+1]
       KevList += [QuadrBin]
    return KevList

def Rajout(ChaineSeparee):
    ChaList = []
    for u in range (len(ChaineSeparee)):
        ChaList += "0"
        ChaList[u] += "1"
        ChaList[u] += ChaineSeparee[u]
    for k in range (len(ChaineSeparee)):
        ChaList[k] += "10"
    return ChaList

def Inversion(ChaineRajout):
    JisList = []
    Kyung = ''
    for m in range (len(ChaineRajout)):
        JisList += [Kyung]
        JisList[m] = ChaineRajout[m][4:8]+ChaineRajout[m][0:4]
    return JisList

def Reconversion(ChaineInversee):
    ASCIIList = []
    ASCIIChaine = ""
    NombreDec = 0
    for k in range (len(ChaineInversee)):
        NombreBin = ChaineInversee[k]
        Ana = NombreBin[::-1] 
        for m in range (8):
            NombreDec += int(Ana[m])*2**m
        ASCIIList += [NombreDec]
        NombreDec = 0
    for v in range (len(ASCIIList)):
        ASCIIChaine += chr(ASCIIList[v])
    return ASCIIChaine

Chaine = input("Chaîne à coder : ")
ChaineBin = (Binaire(Chaine))
ChaineSeparee = Separation(ChaineBin)
ChaineRajout = Rajout(ChaineSeparee)
ChaineInversee = Inversion(ChaineRajout)
ChaineCodee = Reconversion(ChaineInversee)
print("Chaîne codée : ", ChaineCodee)
 

Je dois aussi maintenant me concentrer sur l'interface à lui donner, je le ferai demain en revoyant le code principal pour raccourcir ce que j'arrive à raccourcir. 
Je pense encore revenir vers vous demain si je rencontre à nouveau des problèmes.

Adrya · Answer

Bonjour, la date pour rendre le devoir a été retardée et il me manque encore une partie du travail pour laquelle je bloque sur une fonction.
Je travaille sur le code inverse de celui sur lequel vous m'avez aidée.
Ici la fonction ou je ne comprend pas comment faire est la suivante: 
Je dois retirer le "01" et "10", mais après je dois me retrouver avec une liste triée par 8 bits et non 4 bits, je n'arrive pas à trouver comment faire.

def Retrait(ChaineRetrait):
    ChaList = []
    MangList = []
    for k in range (len(ChaineRetrait)):
        ChaList += [ChaineRetrait[k][2:6]]
        MangList += ChaList[k]+ChaList[k+1]
    return MangList

ChaineRetrait = ['01001010', '01011110', '01101010', '01110010', '01001010', '01100110']
ChaineReconvertie = Retrait(ChaineRetrait)
print (Retrait(ChaineRetrait))

Adrya · Answer

Bonjour, désolée de revenir après autant de temps, je n'avais pas vu la réponse, mais j'ai trouvé la solution à mon problème. Je reviens maintenant avec un nouveau problème au niveau de mon interface. Seule elle marche, mais une fois que j'essaye de la lier avec mon programme, celle-ci ne fonctionne plus et j'aimerais corriger mon erreur.

Le but de cette interface est de rentrer un texte dans une zone de texte, et de faire en sorte qu'avec les fonctions créées au dessus, avec le bouton cryptage on reçoive le texte crypté, et avec le bouton décryptage, qu'on reçoive le texte décrypté.

Le code que j'ai réalisé est donc le suivant : 
## INTERFACE

from tkinter import*

## Créer une fenêtre :
Window = Tk()

## Personnaliser la fenêtre
Window.title("Codage - Décodage") # Titre de la fenêtre
Window.geometry("640x460") # Taille de la fenêtre
Window.minsize(480, 360) # Taille minimale de la fenêtre
Window.config(background = "#FDB6A6") # Couleur de la fenêtre, utilisation du code hexadécimal de la couleur

##Créer la frame
frame = Frame(Window, bg = "#FDB6A6", bd = 1, relief = SUNKEN)

## Ajouter un premier texte
label_title = Label(frame, text = "Cryptage - Décryptage", font = ("Palatino", 30), bg ="#FDB6A6")
label_title.pack(expand = YES)

## Ajouter une nouvelle entrée
Chaine = Entry(frame, font = ("Palatino", 15), bg = "#FDB6A6")
Chaine.pack()

## CODAGE

class Code:
    def __init__(self):
        self.code = ''

def Binaire(self, Chaine):
    ## Cette fonction traduit la chaîne donnée en binaire
        ListeASCII = []
        for k in Chaine:
            New = [str(ord(k))] ## Chaîne de caractères du code ASCII
            ListeASCII += New
        ChaineBinaire = ""
        for i in range (len(ListeASCII)):
            nombre = (int(ListeASCII[i])) ## nombre = entier
            reste = ""
            for k in range (0, 8):
                juy = nombre//2 ## Division entière 
                hak = nombre%2 ## Reste de la division
                reste += str(hak)
                nombre = juy
            for p in reversed(reste):
                ChaineBinaire += p
        return ChaineBinaire

def Separation(self, ChaineBin):
    ## Cette fonction sépare la chaîne binaire par groupe de 4 bits
        KevList = []
        for u in range(len(ChaineBin)//4):
            QuadrBin = ''
            for k in range (4):
                QuadrBin += ChaineBin[u*4+k:u*4+k+1]
            KevList += [QuadrBin]
        return KevList

def Rajout(self, ChaineSeparee):
    ## Cette fonction rajoute "01" à gauche de chaque groupe de 4 bits
    ## puis rajoute "10" à droite de chaque groupe de 4 bits
        ChaList = []
        for u in range (len(ChaineSeparee)):
            ChaList += "0"
            ChaList[u] += "1"
            ChaList[u] += ChaineSeparee[u]
        for k in range (len(ChaineSeparee)):
            ChaList[k] += "10"
        return ChaList

def Inversion(self, ChaineRajout):
    ## Cette fonction inverse le groupe des 4 premiers bits avec le groupe des 4 derniers bits
        JisList = []
        Kyung = ''
        for m in range (len(ChaineRajout)):
            JisList += [Kyung]
            JisList[m] = ChaineRajout[m][4:8]+ChaineRajout[m][0:4]
            ## Fait passer les bits de 4 à 8 au début de la liste et les bits de 0 à 4 en fin
        return JisList

def Reconversion(self, ChaineInversee):
    ## Ctte fonction reconvertit la chaîne obtenue en chaîne de caractères
        ASCIIList = []
        ASCIIChaine = ""
        NombreDec = 0
        for k in range (len(ChaineInversee)):
            NombreBin = ChaineInversee[k]
            Ana = NombreBin[::-1] #Renverse le bit pour pouvoir le calculer.
            for m in range (8):
                NombreDec += int(Ana[m])*2**m ## Calcul pour passer du binaire au code 
            ASCIIList += [NombreDec]
            NombreDec = 0
        for v in range (len(ASCIIList)):
            ASCIIChaine += chr(ASCIIList[v]) ## Passage du code ASCII à son caractère
        return ASCIIChaine

q = Code()
ChaineBin = q.Binaire(Chaine)
ChaineSeparee = q.Separation(ChaineBin)
ChaineRajout = q.Rajout(ChaineSeparee)
ChaineInversee = q.Inversion(ChaineRajout)
ChaineCodee = q.Reconversion(ChaineInversee)

##Ajouter un premier bouton
decode_button = Button(frame, text = "Cryptage", font = ("Palatino", 25), bg = "white", fg = "#FDB6A6", command = Code())
decode_button.pack(pady = 25, fill=X)

## Ajouter une nouvelle entrée
entry = Entry(frame, font = ("Palatino", 15), bg = "#FDB6A6")
entry.pack()

## DECODAGE

class Decode():

def __init__(self):
        self.decode = ''

def Binaire(self, Chaine):
    ## Cette fonction traduit la chaîne de caractères donnée en binaire
        ListeASCII = []
        for k in Chaine:
            New = [str(ord(k))] ## Chaîne de caractères du code ASCII
            ListeASCII += New
        ChaineBinaire = ""
        for i in range (len(ListeASCII)):
            nombre = (int(ListeASCII[i])) ##nombre = entier 
            reste = ""
            for k in range (0, 8):
                juy = nombre//2 ## Division entière
                hak = nombre%2 ## Reste de la division
                reste += str(hak)
                nombre = juy
            for p in reversed(reste):
                ChaineBinaire += p
        return ChaineBinaire

def Renversement(self, ChaineRajout):
    ## Cette fonction renvoie la chaîne donnée dans l'ordre inverse
        ChiChaine = ""
        ChiChaine += ChaineRajout[::-1]
        return ChiChaine

def Separation(self, ChaineBin):
    ## Cette fonction sépare la chapine binaire par groupes de 8 bits
        KevList = []
        for u in range(len(ChaineBin)//8):
            QuadrBin = ''
            for k in range (8):
                QuadrBin += ChaineBin[u*8+k:u*8+k+1]
            KevList += [QuadrBin]
        return KevList

def NouvRenversement(self, ChaineRajout):
    ## Cette fonction inverse chaque groupe de 8 bits
        WoongList = []
        for k in range(len(ChaineRajout)//6):
            WoongList += ChaineRajout[::-1]
        return WoongList

def Inversion(self, ChaineRajout):
    ## Cette fonction inverse le groupe des 4 premiers bits avec le groupe des 4 derniers bits
        JisList = []
        Kyung = ''
        for m in range (len(ChaineRajout)):
            JisList += [Kyung]
            JisList[m] = ChaineRajout[m][4:8]+ChaineRajout[m][0:4]
            ## Fait passer les bits de 4 à 8 au début et les bits de 0 à 4 à la fin
        return JisList

def Retrait(self, ChaineRetrait):
    ## Cette fonction retire le "01" au début et le "10" à la fin de chaque groupe de 8 bits
        ChaList = []
        MangList = []
        for k in range (len(ChaineRetrait)):
            ChaList += [ChaineRetrait[k][2:6]]
        for w in range (len(ChaineRetrait)//2):
            MangList += [ChaList[1]+ChaList[0]] ## Retire les deux premiers éléments/les remplace par du vide sans espace
            ChaList[:2] = ""
        return MangList

def Reconversion(self, ChaineInversee):
    ## Cette fonction reconvertit la chaîne obtenue en chaîne de caractères
        ASCIIList = []
        ASCIIChaine = ""
        NombreDec = 0
        for k in range (len(ChaineInversee)):
            NombreBin = ChaineInversee[k]
            for m in range (8):
                NombreDec += int(NombreBin[m])*2**m ## Calcul pour passer du binaire au code
            ASCIIList += [NombreDec]
            NombreDec = 0
        if len(ASCIIList) > 6:
            for v in range (len(ASCIIList)//2):
                ASCIIChaine += chr(ASCIIList[v]) ## Passage du code ASCII à son caractère
        else:
            for v in range (len(ASCIIList)):
                ASCIIChaine += chr(ASCIIList[v]) ## Passage du code ASCII à son caractère
        return ASCIIChaine

Cryptage = ChaineCodee
p = Decode()
ChaineBin = p.Binaire(Cryptage)
ChaineRenversement = p.Renversement(ChaineBin)
ChaineRajout = p.Separation(ChaineRenversement)
ChaineSuite = p.NouvRenversement(ChaineRajout)
ChaineInver = p.Inversion(ChaineSuite)
ChaineRetrait = p.Retrait(ChaineInver)
ChaineReconvertie = p.Reconversion(ChaineRetrait)
## Avec la chaîne NSI, le codage donne : %§eä%f

##Ajouter un deuxième bouton
decode_button = Button(frame, text = "Décryptage", font = ("Palatino", 25), bg = "white", fg = "#FDB6A6", command = Decode())
decode_button.pack(pady = 25, fill=X)

# Ajouter la frame
frame.pack(expand = YES)

## Afficher
Window.mainloop()

Projet NSI

14 réponses

Discussions similaires