SCRIPT PERMETTANT DE DÉCODER LA STRUCTURE SECONDAIRE D'UNE PROTÉINE À PARTIR D'UNE SOURCE FASTA

# -*- coding: utf-8 -*-

# dictionnaires des degrés d'affinité de chaque acide aminé avec les hélices alpha, feuillets bétas et coudes
Pa={'E':1.51, 'M':1.45, 'A':1.42, 'L':1.21, 'K':1.16, 'F':1.13, 'Q':1.11, 'W':1.08, 'I':1.08, 'V':1.06, 'D':1.01, 'H':1, 'R':0.98, 'T':0.83, 'S':0.77, 'C':0.7, 'Y':0.69, 'N':0.67, 'P':0.57, 'G':0.57}
Pb={'V':1.7, 'I':1.6, 'Y':1.47, 'F':1.38, 'W':1.37, 'L':1.3, 'C':1.19, 'T':1.19, 'Q':1.1, 'M':1.05, 'R':0.93, 'N':0.89, 'H':0.87, 'A':0.83, 'S':0.75, 'G':0.75, 'K':0.74, 'P':0.55, 'D':0.54, 'E':0.37}
Pc={'N':1.56, 'G':1.56, 'P':1.52, 'D':1.46, 'S':1.43, 'C':1.19, 'Y':1.14, 'K':1.01, 'Q':0.98, 'T':0.96, 'W':0.96, 'R':0.95, 'H':0.95, 'E':0.74, 'A':0.66, 'M':0.6, 'F':0.6, 'L':0.59, 'V':0.5, 'I':0.47}

# fonction qui copie la suite de caractères de la séquence dans une seule string en enlevant les \n; on obtient ainsi une string avec la suite d'acides aminés.
def copyseq():
    nblignes = len(sequence) # compte le nombre de caractères dans la séquence d'origine
    sequence2 = "" # crée une string vide afin de pouvoir rajouter les caractères voulus un par un
    for lignes in range(nblignes):
        for char in sequence[lignes]: # controle tous les caractères dans la séquence ...
            if char != "\n": # ... pour vérifier si ce n'est pas un retour à la ligne ...
                sequence2 += char # ... et rajoute tous ceux qui ne sont pas "\n" dans une nouvelle string
    return sequence2

# Fonction qui calcule les scores (alpha, béta et coude) de chaque acide aminé comme expliqué dans la méthode Chou-Fassman, en tenant compte des deux acides aminés qui suivent.
# !!! NE PREND PAS EN COMPTE LES 2 DERNIERS ACIDES AMINES car ils n'ont pas deux autres a.a. qui les suivent. Ce script ne tiendra donc pas compte de la structure des deux derniers a.a. Ceci dit, les derniers a.a. sont rarement dans une structure définie !!!
def scores():
    global SCa # scores alpha pour chaque acide aminé de la séquence
    global SCb # scores beta pour chaque acide aminé de la séquence
    global SCc # scores coude pour chaque acide aminé de la séquence
    SCa, SCb, SCc = [], [], []
    for n in range(len(sequence2)-3):# le -3 évite de tenir compte des 2 derniers acides aminé qui n'ont pas de scores, afin de ne pas sortir du cadre de lecture
        SCa.append(Pa[sequence2[n]]+Pa[sequence2[n+1]]+Pa[sequence2[n+2]]+Pa[sequence2[n+3]])
        SCb.append(Pb[sequence2[n]]+Pb[sequence2[n+1]]+Pb[sequence2[n+2]]+Pb[sequence2[n+3]])
        SCc.append(Pc[sequence2[n]]+Pc[sequence2[n+1]]+Pc[sequence2[n+2]]+Pc[sequence2[n+3]])

#-------- ALPHA -------- ALPHA -------- ALPHA -------- ALPHA -------- ALPHA -------- ALPHA -------- ALPHA -------- ALPHA -------- ALPHA -------- ALPHA --------
# Fonction qui détecte les initiateurs d'hélices alpha, selon la méthode Chou-Fassman
def initiateurs_alpha():
    global initiators # tous les a.a. initiateurs
    global initiators_debut # uniquement les premiers a.a. de chaque groupe d'initiateurs
    global initiators_fin # uniquement les derniers a.a. de chaque groupe d'initiateurs
    global initiators_seul # uniquement les a.a. des initiateurs seuls qui ne sont pas dans des groupes
    scores() # appelle la fonction scores définie plus haut
    initiators=[]
    for n in range(len(sequence2)-8): # Le -8 évite que les sequences se trouvent en dehors du carde de lecture, compte tenu du fait que les 2 derniers a.a. n'aient pas de scores.
        helice = 0 # crée un compteur initialisé à zéro
        for x in range(n,n+6): # scanne tous les a.a. par fanêtre de 6 a.a.
            if SCa[x]>SCb[x] and SCa[x]>SCc[x]: # Teste les a.a. de la fenêtre et si un a.a. à un score alpha plus grand que son score beta...
                helice += 1 # ... on rajoute 1 au compteur
        if helice >= 4: # Si 4 a.a. ou plus sur les 6 suivent cette règle ...
            initiators.append(n) # ... on les ajoute en tant qu'initeurs alpha
            
    initiators_debut, initiators_fin, initiators_seul = [], [], []
    
    if initiators[0]==initiators[1]-1: # pour le premier acide aminé des initiateurs, si il fait partie d'une suite d'initiateurs ... 
        initiators_debut.append(initiators[0]) # ... le programme va garder uniquement le premier de la liste et le mettra dans la string initiateur debut ...
    else:
        initiators_seul.append(initiators[0]) # ... sinon il le mettra dans la string initiateur seul
        
    for q in range(1,len(initiators)-1): # pour les initiateurs sauf le premier et le dernier ...
        if initiators[q]==initiators[q+1]-1 and initiators[q]!=initiators[q-1]+1: # ... regarde si un initiateur a un intiateur qui le suit a sa droite et pas d initiateur a sa gauche ...
            initiators_debut.append(initiators[q]) # ... et le rajoute dans la string initiateur début
        elif initiators[q]!=initiators[q+1]-1 and initiators[q]==initiators[q-1]+1: # regarde si un initiateur a un initiateur a sa gauche et pas d initiateur a sa droite ...
            initiators_fin.append(initiators[q]) # ... si tel est le cas, il le rajoute dans la string initiateur fin
        elif initiators[q]!=initiators[q+1]-1 and initiators[q]!=initiators[q-1]+1: # si l'initaiteur n'a pas de voisin du tout ...
            initiators_seul.append(initiators[q]) # ... il le rajoute dans initiateur seul
            
    if initiators[len(initiators)-1]==initiators[len(initiators)-2]+1: # pour le premier acide aminé des initiateurs, si il fait partie d'une suite d'initiateurs ...
        initiators_fin.append(initiators[len(initiators)-1])  # ... le programme va garder uniquement le dernier de la liste et le mettra dans la string initiateur fin ...
    else:
        initiators_seul.append(initiators[len(initiators)-1]) # ... sinon il le mettra dans la string initiateur seul

    return initiators, initiators_debut, initiators_fin, initiators_seul

# Fonction qui rallonge les bouts des initiateurs alpha
def rallonge_alpha():
    global rallonge_debut # rallonge des initiateurs à gauche d'un groupe d'initiateurs
    global rallonge_fin # rallonge des initiateurs à droite d'un groupe d'initiateurs
    global rallonge_seul # rallonge des initiateurs des deux côtés d'un initiateur seul, ne faisant pas partie d'un groupe
    rallonge_debut=[]
    for x in range(len(initiators_debut)): # parmis les premiers a.a. de chaque groupe d'initiateurs, on teste les a.a. du côté gauche jusqu'à ce que Pa ne soit plus > 1 ...
        y=1
        while Pa[sequence2[initiators_debut[x]-y]] >1.00: # !!!! puisque tous les scores SCa sont > 1, on a pris les Pa !!!! Si le Pa de l'a.a. est > 1 ...
            if initiators_debut[x]-y==-1 or initiators_debut[x]-y in initiators: # ... on teste les conditions de fin de boucle ...
                break # ... et on arrête la boucle si fin de boucle
            rallonge_debut.append(initiators_debut[x]-y)  # ... si on n'est pas en fin de boucle, on rajoute l'a.a. dans la rallonge
            y+=1 # on incrémente y de 1 pour que la boucle reteste avec l'a.a. à côté
    rallonge_fin=[]
    for x in range(len(initiators_fin)): # parmis les derniers a.a. de chaque groupe d'initiateurs, on teste les a.a. du côté droite jusqu'à ce que Pa ne soit plus > 1 ...
        y=1
        while Pa[sequence2[initiators_fin[x]+y]] >1.00: # !!!! puisque tous les scores SCa sont > 1, on a pris les Pa !!!!
            if initiators_fin[x]+y==len(sequence2) or initiators_fin[x]+y in initiators or initiators_fin[x]+y in rallonge_debut:
                break
            rallonge_fin.append(initiators_fin[x]+y)
            y+=1
    rallonge_seul=[]
    for x in range(len(initiators_seul)): # parmis les a.a. des initiateurs seuls, on teste les a.a. des deux côtés jusqu'à ce que Pa ne soit plus > 1 ...
        y=1
        while Pa[sequence2[initiators_seul[x]-y]] >1.00:# !!!! puisque tous les scores SCa sont > 1, on a pris les Pa !!!!
            if initiators_seul[x]-y==-1 or initiators_seul[x]-y in initiators or initiators_seul[x]-y in rallonge_debut or initiators_seul[x]-y in rallonge_fin:
                break
            rallonge_seul.append(initiators_seul[x]-y)
            y+=1
        y=1
        while Pa[sequence2[initiators_seul[x]+y]] >1.00: # !!!! puisque tous les scores SCa sont > 1, on a pris les Pa !!!!
            if initiators_seul[x]+y==len(sequence2) or initiators_seul[x]+y in initiators or initiators_seul[x]+y in rallonge_debut or initiators_seul[x]+y in rallonge_fin or initiators_seul[x]+y in rallonge_seul:
                break
            rallonge_seul.append(initiators_seul[x]+y)
            y+=1
    return rallonge_debut, rallonge_fin, rallonge_seul

# Fonction qui teste les conditions des hélices alpha, et retourne les vraies hélices
def alpha():
    global alpha3 # indexes des acides aminés faisant partie d'une hélice alpha calssés par listes
    global alpha4 # indexes des acides aminés faisant partie d'une hélice alpha calssés par listes après avoir enlevé les hélices dont le segment étendu est inférieur à 4
    global alpha5 # indexes des acides aminés faisant partie d'une hélice alpha calssés par listes après avoir éliminé toutes les autres hélices selon les critères de Chou Fassman
    alpha=initiators+rallonge_debut+rallonge_fin+rallonge_seul # crée une liste avec tous les a.a. faisant partie d'une hélice alpha (initiateurs + rallonges)
    alpha.sort() # classe les initiateurs dans l'ordre des indexes
    for k in range(len(alpha)): # boucle qui supprime les prolines des chaines alpha
        if sequence2[alpha[k]]=="P":
            alpha[k]="P"
    for p in range(alpha.count("P")):
        alpha.remove("P")
    alpha2=[]
    alpha3=[]
    for q in range(len(alpha)): # boucle qui met des listes différentes pour chaque hélices dans une grande liste nommée alpha3
        if q==len(alpha)-1:
            alpha2.append(alpha[q])
            alpha3.append(alpha2)
            break
        if alpha[q+1]==alpha[q]+1:
            alpha2.append(alpha[q])
        else:
            alpha2.append(alpha[q])
            alpha3.append(alpha2)
            alpha2=[]
    alpha4=[]
    for x in range(len(alpha3)): # boucle qui enlève les hélices alpha dont le segment étendu est inférieur à 4 (et pas 6 comme mentionné dans la méthode) et crée une nouvelle liste sans ces segments nommée alpha4
        if len(alpha3[x])>4:
            alpha4.append(alpha3[x])
    Pa_helice=[]
    Pa_helice2=[]
    Pb_helice=[]
    Pb_helice2=[]
    SCa_helice=[]
    SCa_helice2=[]
    SCb_helice=[]
    SCb_helice2=[]
    for x in range(len(alpha4)): # boucle qui crée des listes des Pa (Pa_helice2), Pb (Pb_helice2), SCa (SCa_helice2) et SCb (SCb_helice2) de chaque acide aminé pour chaque hélice
        for y in range(len(alpha4[x])):
            if y==len(alpha4[x])-1:
                Pa_helice.append(Pa[sequence2[alpha4[x][y]]])
                Pa_helice2.append(Pa_helice)
                Pa_helice=[]
                Pb_helice.append(Pb[sequence2[alpha4[x][y]]])
                Pb_helice2.append(Pb_helice)
                Pb_helice=[]
                SCa_helice.append(SCa[alpha4[x][y]])
                SCa_helice2.append(SCa_helice)
                SCa_helice=[]
                SCb_helice.append(SCb[alpha4[x][y]])
                SCb_helice2.append(SCb_helice)
                SCb_helice=[]
                break
            Pa_helice.append(Pa[sequence2[alpha4[x][y]]])
            Pb_helice.append(Pb[sequence2[alpha4[x][y]]])
            SCa_helice.append(SCa[alpha4[x][y]])
            SCb_helice.append(SCb[alpha4[x][y]])
    alpha5=[]
    for x in range(len(alpha4)): # boucle qui vérifie la moyenne des Pa (!! et non les SCa comme mentionné dans la méthode !!) pour chaque hélice et qui vérifie que la moyenne des SCa soit plus grande que la moyenne des SCb pour chaque hélice
        if (sum(Pa_helice2[x])/len(Pa_helice2[x]))>1.03 and (sum(SCa_helice2[x])/len(SCa_helice2[x]))>(sum(SCb_helice2[x])/len(SCb_helice2[x])):
            alpha5.append(alpha4[x]) # la liste alpha5 est donc la liste finale contenant tous les a.a. après toutes les vérifications
    return alpha, alpha2, alpha3, alpha4, alpha5

#-------- BETA -------- BETA -------- BETA -------- BETA -------- BETA -------- BETA -------- BETA -------- BETA -------- BETA -------- BETA -------- BETA --------
# Toutes les fonctions pour les feuillets beta sont comparables à celles pour les hélices alpha à quelques exceptions près (en rapport à la méthode). Puisque les principes sont les mêmes, nous n'allons pas les détailler à nouveau
# Fonction qui détecte les initieurs de feuillet beta
def initiateurs_beta():
    global initiators2 # tous les a.a. initiateurs
    global initiators2_debut # uniquement les premiers a.a. de chaque groupe d'initiateurs
    global initiators2_fin # uniquement les derniers a.a. de chaque groupe d'initiateurs
    global initiators2_seul # uniquement les a.a. des initiateurs seuls qui ne sont pas dans des groupes
    scores()
    initiators2=[]
    for n in range(len(sequence2)-8):
        beta=0
        for y in range(n,n+5): # pour les feuillets béta, il faut 3 a.a. favorisant les feuillets sur une fenêtre de 5 a.a. pour définir les initiateurs
            if SCb[y]>SCa[y] and SCb[y]>SCc[y]:
                beta+=1
        if beta>=3:
            initiators2.append(n)

    initiators2_debut,initiators2_fin,initiators2_seul = [],[],[]

    if initiators2[0]==initiators2[1]-1:
        initiators2_debut.append(initiators2[0])
    else:
        initiators2_seul.append(initiators2[0])
        
    for q in range(1,len(initiators2)-1):
        if initiators2[q]==initiators2[q+1]-1 and initiators2[q]!=initiators2[q-1]+1:
            initiators2_debut.append(initiators2[q])
        elif initiators2[q]!=initiators2[q+1]-1 and initiators2[q]==initiators2[q-1]+1:
            initiators2_fin.append(initiators2[q])
        elif initiators2[q]!=initiators2[q+1]-1 and initiators2[q]!=initiators2[q-1]+1:
            initiators2_seul.append(initiators2[q])
            
    if initiators2[len(initiators2)-1]==initiators2[len(initiators2)-2]+1:
        initiators2_fin.append(initiators2[len(initiators2)-1])
    else:
        initiators2_seul.append(initiators2[len(initiators2)-1])

    return initiators2, initiators2_debut, initiators2_fin, initiators2_seul

# Fonction qui rallonge les bouts des initiateurs béta
def rallonge_beta():
    global rallonge2_debut # rallonge des initiateurs à gauche d'un groupe d'initiateurs
    global rallonge2_fin # rallonge des initiateurs à droite d'un groupe d'initiateurs
    global rallonge2_seul # rallonge des initiateurs des deux côtés d'un initiateur seul, ne faisant pas partie d'un groupe   
    initiateurs_beta()
    rallonge2_debut=[]
    for y in range(len(initiators2_debut)):
        z=1
        while Pb[sequence2[initiators2_debut[y]-z]] >1.00: # !!!! tous les scores SCb sont > 1 (on a pris les Pb) !!!!
            if initiators2_debut[y]-z==-1 or initiators2_debut[y]-z in initiators2:
                break
            rallonge2_debut.append(initiators2_debut[y]-z)
            z+=1
    rallonge2_fin=[]
    for y in range(len(initiators2_fin)):
        z=1
        while Pb[sequence2[initiators2_fin[y]+z]] >1.00: # !!!! tous les scores SCb sont > 1 (on a pris les Pb) !!!!
            if initiators2_fin[y]+z==len(sequence2) or initiators2_fin[y]+z in initiators2 or initiators2_fin[y]+z in rallonge2_debut:
                break
            rallonge2_fin.append(initiators2_fin[y]+z)
            z+=1
    rallonge2_seul=[]
    for y in range(len(initiators2_seul)):
        z=1
        while Pb[sequence2[initiators2_seul[y]-z]] >1.00: # !!!! tous les scores SCb sont > 1 (on a pris les Pb) !!!!
            if initiators2_seul[y]-z==-1 or initiators2_seul[y]-z in initiators2 or initiators2_seul[y]-z in rallonge2_debut or initiators2_seul[y]-z in rallonge2_fin:
                break
            rallonge2_seul.append(initiators2_seul[y]-z)
            z+=1
        z=1
        while Pb[sequence2[initiators2_seul[y]+z]] >1.00: # !!!! tous les scores SCb sont > 1 (on a pris les Pb) !!!!
            if initiators2_seul[y]+z==len(sequence2) or initiators2_seul[y]+z in initiators2 or initiators2_seul[y]+z in rallonge2_debut or initiators2_seul[y]+z in rallonge2_fin or initiators2_seul[y]+z in rallonge2_seul:
                break
            rallonge2_seul.append(initiators2_seul[y]+z)
            z+=1
    return rallonge2_debut, rallonge2_fin, rallonge2_seul

# Fonction qui teste les conditions des feuillets beta, et retourne les vrais feuillets
def beta():
    global beta3 # indexes des acides aminés faisant partie d'un feuillet beta calssés par listes
    global beta4 # indexes des acides aminés faisant partie d'un feuillet beta calssés par listes après avoir éliminé tous les autres feuillets beta selon les critères de Chou Fassman    
    beta=initiators2+rallonge2_debut+rallonge2_fin+rallonge2_seul
    beta.sort()
    beta2=[]
    beta3=[]
    for q in range(len(beta)): # boucle qui met des listes différentes pour chaque feuillet dans une grande liste nommée beta3
        if q==len(beta)-1:
            beta2.append(beta[q])
            beta3.append(beta2)
            break
        if beta[q+1]==beta[q]+1:
            beta2.append(beta[q])
        else:
            beta2.append(beta[q])
            beta3.append(beta2)
            beta2=[]
    Pa_beta=[]
    Pa_beta2=[]
    Pb_beta=[]
    Pb_beta2=[]
    SCa_beta=[]
    SCa_beta2=[]
    SCb_beta=[]
    SCb_beta2=[]
    for x in range(len(beta3)): # boucle qui crée des listes des Pa, Pb, SCa et SCb de chaque acide aminé pour chaque feuillet beta
        for y in range(len(beta3[x])):
            if y==len(beta3[x])-1:
                Pa_beta.append(Pa[sequence2[beta3[x][y]]])
                Pa_beta2.append(Pa_beta)
                Pa_beta=[]
                Pb_beta.append(Pb[sequence2[beta3[x][y]]])
                Pb_beta2.append(Pb_beta)
                Pb_beta=[]
                SCa_beta.append(SCa[beta3[x][y]])
                SCa_beta2.append(SCa_beta)
                SCa_beta=[]
                SCb_beta.append(SCb[beta3[x][y]])
                SCb_beta2.append(SCb_beta)
                SCb_beta=[]
                break
            Pa_beta.append(Pa[sequence2[beta3[x][y]]])
            Pb_beta.append(Pb[sequence2[beta3[x][y]]])
            SCa_beta.append(SCa[beta3[x][y]])
            SCb_beta.append(SCb[beta3[x][y]])
    beta4=[]
    for x in range(len(beta3)): # boucle qui vérifie la moyenne des Pb (!! et non les SCb comme mentionné dans la méthode !!) pour chaque feuillet et qui vérifie que la moyenne des SCb soit plus grande que la moyenne des SCa pour chaque feuillet
        if (sum(Pb_beta2[x])/len(Pb_beta2[x]))>1.05 and (sum(SCb_beta2[x])/len(SCb_beta2[x]))>(sum(SCa_beta2[x])/len(SCa_beta2[x])):
            beta4.append(beta3[x]) # la liste beta4 est donc la liste finale contenant tous les a.a. après toutes les vérifications
    return beta, beta2, beta3, beta4

#-------- RECOUVREMENT -------- RECOUVREMENT -------- RECOUVREMENT -------- RECOUVREMENT -------- RECOUVREMENT -------- RECOUVREMENT -------- RECOUVREMENT --------
# Fonction qui teste les recouvrements alpha-béta et les attribue à la bonne structure
def recouvrement():
    global recouvrement3 # grande liste composée des différentes listes contenant chaque groupe de recouvrement
    global SCa_recouvrement2 # scores alpha des acides aminés faisant partie des recouvrements
    global SCb_recouvrement2 # scores beta des acides aminés faisant partie des recouvrements
    recouvrement=[]
    for x in range(len(sequence2)): # boucle qui cherche les recouvrements et qui les met dans une liste nommée recouvrement
        for y in range(len(alpha5)):
            for z in range(len(beta4)):
                if x in alpha5[y] and x in beta4[z]: # si l'acide aminé est présent dans les hélices alpha et les fueuillets beta ...
                    recouvrement.append(x) # ... il le rajoute dans une nouvelle liste nommée recouvrement
    recouvrement2=[]
    recouvrement3=[]
    for q in range(len(recouvrement)): # boucle qui met des listes différentes pour chaque groupe de recouvrement dans une grande liste nommée recouvrement3
        if q==len(recouvrement)-1:
            recouvrement2.append(recouvrement[q])
            recouvrement3.append(recouvrement2)
            break
        if recouvrement[q+1]==recouvrement[q]+1:
            recouvrement2.append(recouvrement[q])
        else:
            recouvrement2.append(recouvrement[q])
            recouvrement3.append(recouvrement2)
            recouvrement2=[]
    SCa_recouvrement=[]
    SCa_recouvrement2=[]
    SCb_recouvrement=[]
    SCb_recouvrement2=[]
    for x in range(len(recouvrement3)): # boucle qui crée des listes des SCa et SCb de chaque acide aminé de recouvrement
        for y in range(len(recouvrement3[x])):
            if y==len(recouvrement3[x])-1:
                SCa_recouvrement.append(SCa[recouvrement3[x][y]])
                SCa_recouvrement2.append(SCa_recouvrement)
                SCa_recouvrement=[]
                SCb_recouvrement.append(SCb[recouvrement3[x][y]])
                SCb_recouvrement2.append(SCb_recouvrement)
                SCb_recouvrement=[]
                break
            SCa_recouvrement.append(SCa[recouvrement3[x][y]])
            SCb_recouvrement.append(SCb[recouvrement3[x][y]])
    for x in range(len(recouvrement3)): # boucle qui attribue les recouvrements à la bonne structure
        if (sum(SCa_recouvrement2[x])/len(SCa_recouvrement2[x]))>(sum(SCb_recouvrement2[x])/len(SCb_recouvrement2[x])): # si la moyenne des SCa est plus grande que celle des SCb ...
            for y in range(len(recouvrement3[x])):
                for z in range(len(beta4)):
                    if recouvrement3[x][y] in beta4[z]:
                        beta4[z].remove(recouvrement3[x][y]) # ... on enlève ces acides aminés de la liste des feuillets beta
        else: # si la moyenne des SCa est plus petite que celle des SCb ...
            for y in range(len(recouvrement3[x])):
                for z in range(len(alpha5)):
                    if recouvrement3[x][y] in alpha5[z]:
                        alpha5[z].remove(recouvrement3[x][y]) # ... on enlève ces acides aminés de la liste des hélices alpha
    return recouvrement3

#-------- présentation des résultats -------- présentation des résultats -------- présentation des résultats -------- présentation des résultats --------
# Fonction qui affiche La séquence entière avec les positions des structures
def affiche_seq():
    debut = 0 # initiation du début de la première ligne d'affichage
    fin = 60 # initiation de la fin de la première ligne d'affichage
    while (debut < len(sequence2)): # tant que l'indexe du début (initialement à 0, puis additionné de 60 à chaque itération) est plus petit que le longueur de la séquence ...
        print str(debut + 10).rjust(10) + \
              str(debut + 20).rjust(10) + \
              str(debut + 30).rjust(10) + \
              str(debut + 40).rjust(10) + \
              str(debut + 50).rjust(10) + \
              str(debut + 60).rjust(10) # ... on crée une ligne de 60 caractères vides avec toutes les dixaines écrites à partir de début (initialement à 0, puis additionné de 60 à chaque itération)
        print sequence2[debut:fin] # à chaque itération, on affiche également la séquence correspondante allant de "début" à "fin" (début et fin ltant additionnés de 60 à chaque itération
        alpha6=[] # liste unique contenant tous les indexes des acides aminés des hélices alpha (on a créé une liste nommée alpha6 composée de toutes les sous-listes de alpha5)
        beta5=[] # liste unique contenant tous les indexes des acides aminés des feuillets beta (on a créé une liste nommée beta5 composée de toutes les sous-listes de beta4)
        structure="" # string vide qui va contenir la structure à laquelle appartient chaque acide aminé
        for x in range(len(alpha5)): # création de la liste alpha6
            for y in range(len(alpha5[x])):
                alpha6.append(alpha5[x][y])
        for x in range(len(beta4)): # création de la liste beta5
            for y in range(len(beta4[x])):
                beta5.append(beta4[x][y])
        for n in range(len(sequence2)): # pour tous les acides aminés de la séquence ...
            if n in alpha6: # ... si l'acide aminé fait partie d'une hélice alpha ...
                structure += "H" # ... on rajoute la lettre "H" à la string structure ...
            elif n in beta5: # ... si l'acide aminé fait partie d'un feuillet beta ...
                structure += "F" # ... on rajoute la lettre "F" à la string structure ...
            else: # ... si la structure de l'acide aminé n'a pas été prédite comme alpha ou beta ...
                structure += "-" # ... on rajoute le signe "-" à la string structure
        print structure[debut:fin] # à chaque itération, on affiche aussi la structure prédite de la séquence correspondante allant de "début" à "fin" (début et fin ltant additionnés de 60 à chaque itération
        print "" # on affiche un caractère vide afin de créer un espace entre chaque ligne d'affichage
        debut = debut + 60 # on incrémente de 60 à chaque itération
        fin = fin + 60 # on incrémente de 60 à chaque itération
    return "\n"

# Fonction qui affiche les hélices alpha
def affiche_alpha():
    for x in range(len(alpha5)):
        print "helice", x+1, ": de", alpha5[x][0], "a", alpha5[x][len(alpha5[x])-1]
    return "\n"

# Fonction qui affiche les feuillets beta
def affiche_beta():
    for x in range(len(beta4)):
        print "feuillet", x+1, ": de", beta4[x][0], "a", beta4[x][len(beta4[x])-1]
    return "\n"

#-------- corps principal -------- corps principal -------- corps principal -------- corps principal -------- corps principal -------- corps principal --------

for x in range(3): # le script donne 3 chances pour donner un nom de fichier existant
    fichier = raw_input("entrez le nom du fichier fasta à explorer avec son extention : ")
    try:
        fasta = open(fichier, "r")
        header = fasta.readline()
        sequence = fasta.readlines()
        sequence2 = copyseq()

        initiateurs_alpha()
        rallonge_alpha()
        alpha()

        initiateurs_beta()
        rallonge_beta()
        beta()

        recouvrement()

        print "Analyse de la structure secondaire selon Chou-Fasman: efficacité entre 50% et 60%\n"
        print "protéine = ", header, "\n"
        print "Cette protéine contient", len(alpha5), "hélices alpha et", len(beta4), "feuillets béta\n\n"
        print affiche_seq()
        print "hélices alpha :\n", affiche_alpha()
        print "feuillets béta :\n", affiche_beta()
        break
    except:
        if x==2: # A la troisième fois, il retourne un message d'erreur
            print "Game Over, insert coin!"
        else: # les deux premières fois, il donne la possibilité de réessayer
            print "Le fichier", fichier, "est introuvable"