Projet NSI

<> ▼

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)

def Binaire(Chaine):
    ListeASCII = []
    for k in Chaine:
        New = [str(ord(k))]
        ListeASCII += New
    print("ListeASCII : ", ListeASCII, "\n")
    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, "\n")
        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))

def Binaire(Chaine):
    ListeASCII = []
    for k in Chaine:
        New = [str(ord(k))]
        ListeASCII += New
    print("ListeASCII : ", ListeASCII, "\n")
    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, "\n")
        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)

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)

Réponse 1 = 010011100101001101001001
Ré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 

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

def Binaire(Chaine):
    ListeASCII = []
    for k in Chaine:
        New = [str(ord(k))]
        ListeASCII += New
    print("ListeASCII : ", ListeASCII, "\n")
    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, "\n")
        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 ("\n")
ChaineSeparee = Separation(ChaineBin)
print (ChaineSeparee)
print ("\n")
ChaineRajout = Rajout(ChaineSeparee)
print (ChaineRajout)
print ("\n")
ChaineInversee = Inversion(ChaineRajout)
print (ChaineInversee)

a='AA'
b='BBBB'
e=a+b+'CC' 

def Binaire(Chaine):
    ListeASCII = []
    for k in Chaine:
        New = [str(ord(k))]
        ListeASCII += New
    print("ListeASCII : ", ListeASCII, "\n")
    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, "\n")
        for p in reversed(reste):
            ChaineBinaire += p
    print ("Chaine binaire finale : ")
    return ChaineBinaire


Chaine = input("Chaîne à coder : ")
ChaineBin = (Binaire(Chaine))
print(ChaineBin)

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)

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))

## 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()