Script permettant de décoder la structure secondaire d'une protéine à partir d'une source fasta
Description
Ceci est un petit script d'ordre biologique basé sur la méthode de Chou-Fasman (pour les personnes intéressées, j'ai inséré dans le zip un document expliquant cette méthode, c'est d'ailleurs sur la base de ce document que le script a été effectué)
Ce code est en cours de finition, et il est possible qu'il contienne quelques petites erreurs... Pour l'instant il ressort les indexes des acides aminés d'une faisant partie d'une hélice alpha, ou ceux faisant partie d'un feuillet beta (les hélices alpha peuvent être appelée par "alpha5" et les feuillets beta "beta4"). Ce sont les deux dernières listes de listes qui s'affichent à l'exécution du script (les premières lignes sont des lignes de contrôle pendant l'exécution du script et disparaitront une fois le script terminé)
Le zip contient le fichier en lui-même (alpha-beta) ainsi que deux exemples de fichier fasta (trouvables pour presque toutes les protéines séquencées sur le site http://www.pdb.org), ainsi que le document expliquant la méthode Chou-Fasman et ses dérivées.
ATTENTION: à l'exécution du script, il faut entrer le nom complet du fichier avec l'extension fasta pour que ça fonctionne, exemple : 3G8I.fasta
Voilà, j'accepte toutes sortes de commentaires ^^
Ce code est en cours de finition, et il est possible qu'il contienne quelques petites erreurs... Pour l'instant il ressort les indexes des acides aminés d'une faisant partie d'une hélice alpha, ou ceux faisant partie d'un feuillet beta (les hélices alpha peuvent être appelée par "alpha5" et les feuillets beta "beta4"). Ce sont les deux dernières listes de listes qui s'affichent à l'exécution du script (les premières lignes sont des lignes de contrôle pendant l'exécution du script et disparaitront une fois le script terminé)
Le zip contient le fichier en lui-même (alpha-beta) ainsi que deux exemples de fichier fasta (trouvables pour presque toutes les protéines séquencées sur le site http://www.pdb.org), ainsi que le document expliquant la méthode Chou-Fasman et ses dérivées.
ATTENTION: à l'exécution du script, il faut entrer le nom complet du fichier avec l'extension fasta pour que ça fonctionne, exemple : 3G8I.fasta
Source / Exemple :
# -*- 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"
Conclusion :
Voilà, j'accepte toutes sortes de commentaires ^^
Codes Sources
A voir également
- Script permettant de décoder la structure secondaire d'une protéine à partir d'une source fasta
- Un source ou une source - Forum C / C++ / C++.NET
- Creer pdf a partir jpg - Forum Visual Basic 6
- Source tree - Conseils pratiques -[Fiches pratiques]
- Sha1 decoder - Forum PHP
- Vb.net structure ✓ - Forum VB.NET
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.