Problème de script - séquence protéique

Version imprimable

Bonjour,

J'essaye de réaliser un programme qui depuis un fichier .pdb (fichier contenant une multitude d'info. sur une protéine) me sélectionne les info que je souhaite. J'ai préalablement sélectionner les lignes commençant par SEQRES: Voici un échantillon que j'ai appelé seq0
Code:

1 2 3 ['SEQRES 1 A 215 MET GLU ARG ASN LYS LEU ALA ARG GLN ILE ILE ASP THR \n', 'SEQRES 2 B 215 CYS LEU GLU MET THR ARG LEU GLY LEU ASN GLN GLY THR \n', 'SEQRES 3 C 215 ALA GLY ASN VAL SER VAL ARG TYR GLN ASP GLY MET LEU \n',
Les lettres A B et C correspondent à la chaine polypeptidique à laquelle correspond la séquence qui suit (MET GLU ARG etc.)

J'ai écrit un script qui me permet de print la séquence des chaines polypeptidique sous forme de chaine de caractère avec ce script:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 codeA="" codeB="" codeC="" dico={"VAL":"V","ILE":"I","LEU":"L","MET":"M","PHE":"F","GLY":"G","ALA":"A","PRO":"P","TRP":"W","TYR":"Y","SER":"S","THR":"T","CYS":"C","ASN":"N","GLN":"Q","ARG":"R","LYS":"K","HIS":"H","ASP":"D","GLU":"E"} for i in seq0: seq1=i.split() for j in seq1[4:int(len(seq1))]: if seq1[2]=="A": codeA=codeA+dico[j] if seq1[2]=="B": codeB=codeB+dico[j] if seq1[2]=="C": print "sequence A:",codeA print "sequence B:",codeB print "sequence C:",codeC résultat: séquence A: MERNKLAR..... séquence B: CLEMTR.... séquence C: AGNVSV.....
Ce script fonctionne bien, mais mon problème c'est qu'il n'est pas viable. Imaginons que la protéine en question comporte 100 chaines polypeptidiques, ce serait stupide d'écrire à chaque fois "if seq1[2]=="X": codeX=codeX+dico[j]"

Du coup, je n'arrive pas à trouver un script qui me print la séquence de toutes les chaines polypeptidiques présentes sans avoir à écrire des centaines de lignes.

Pouvez vous m'aidez svp ?

Merci d'avance

Salut,

Tu peux le faire dans une boucle.

Un exemple:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
seq0 = ['SEQRES   1 A  215  MET GLU ARG ASN LYS LEU ALA ARG GLN ILE ILE ASP THR          \n',
 'SEQRES   2 B  215  CYS LEU GLU MET THR ARG LEU GLY LEU ASN GLN GLY THR          \n',
 'SEQRES   3 C 215  ALA GLY ASN VAL SER VAL ARG TYR GLN ASP GLY MET LEU          \n']
dico = {"VAL":"V","ILE":"I","LEU":"L","MET":"M","PHE":"F","GLY":"G","ALA":"A",
        "PRO":"P","TRP":"W","TYR":"Y","SER":"S",  "THR":"T","CYS":"C","ASN":"N",
        "GLN":"Q","ARG":"R","LYS":"K","HIS":"H","ASP":"D","GLU":"E"}
prot = {}
for i in seq0:
    seq = i.strip().split()
    prot[seq[2]] = ''.join([dico[x] for x in seq[4:]])
 
for key in prot:
    print key, prot[key]

qui donne:

Code:

1
2
3
4
 
A MERNKLARQIIDT
C AGNVSVRYQDGML
B CLEMTRLGLNQGT

Salut VinsS,

Oui ton script semble fonctionner pourtant quand je l'applique à mon fichier entier ça ne me donne pas le résultat escompté.
Je débute en python, j'arrive pas à voir d'où vient le problème:

Voilà le script exact que j'utilise:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 import urllib iput=raw_input("Code of the protein (ex: 4S18) : ") url=urllib.urlopen("http://www.rcsb.org/pdb/download/downloadFile.do?fileFormat=pdb&compression=NO&structureId="+str(iput)) pdbfile=url.readlines() dico={"VAL":"V","ILE":"I","LEU":"L","MET":"M","PHE":"F","GLY":"G","ALA":"A","PRO":"P","TRP":"W","TYR":"Y","SER":"S","THR":"T","CYS":"C","ASN":"N","GLN":"Q","ARG":"R","LYS":"K","HIS":"H","ASP":"D","GLU":"E"} seq0=[] for i in range(len(pdbfile)): if pdbfile[i][0:6]=="SEQRES": seq0.append(pdbfile[i]) prot ={} for i in seq0: seq = i.strip().split() prot[seq[2]] = ''.join([dico[x] for x in seq[4:]]) for key in prot: print key, prot[key]
l'input me permet juste de choisir des protéines grâce à leur code (numéro d'identité) sans avoir à changer le script.
Avec ce script j'obtiens ce résultat, alors que je suis sensé obtenir pour chaque chaine A et B 124 résidus, là j'en ai 7.
Code:

1 2 3 Code of the protein (ex: 4S18) : 4S18 A VHFDASV B VHFDASV
Quelle est mon erreur svp ?

04/12/2015, 15h06
VinsS
Peut-être y a-t-il des retours ligne dans les résidus ce qui casserait tes chaînes de texte.

vérifie avec un print
Code:

1 2 3 4 for i in seq0: print i ...

J'obtiens

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
SEQRES   1 A  124  LYS GLU THR ALA ALA ALA LYS PHE GLU ARG GLN HIS MET          
 
SEQRES   2 A  124  ASP SER SER THR SER ALA ALA SER SER SER ASN TYR CYS          
 
SEQRES   3 A  124  ASN GLN MET MET LYS SER ARG ASN LEU THR LYS ASP ARG          
 
SEQRES   4 A  124  CYS LYS PRO VAL ASN THR PHE VAL HIS GLU SER LEU ALA          
 
SEQRES   5 A  124  ASP VAL GLN ALA VAL CYS SER GLN LYS ASN VAL ALA CYS          
 
SEQRES   6 A  124  LYS ASN GLY GLN THR ASN CYS TYR GLN SER TYR SER THR          
 
SEQRES   7 A  124  MET SER ILE THR ASP CYS ARG GLU THR GLY SER SER LYS          
 
SEQRES   8 A  124  TYR PRO ASN CYS ALA TYR LYS THR THR GLN ALA ASN LYS          
 
SEQRES   9 A  124  HIS ILE ILE VAL ALA CYS GLU GLY ASN PRO TYR VAL PRO          
 
SEQRES  10 A  124  VAL HIS PHE ASP ALA SER VAL                                  
 
SEQRES   1 B  124  LYS GLU THR ALA ALA ALA LYS PHE GLU ARG GLN HIS MET          
 
SEQRES   2 B  124  ASP SER SER THR SER ALA ALA SER SER SER ASN TYR CYS          
 
SEQRES   3 B  124  ASN GLN MET MET LYS SER ARG ASN LEU THR LYS ASP ARG          
 
SEQRES   4 B  124  CYS LYS PRO VAL ASN THR PHE VAL HIS GLU SER LEU ALA          
 
SEQRES   5 B  124  ASP VAL GLN ALA VAL CYS SER GLN LYS ASN VAL ALA CYS          
 
SEQRES   6 B  124  LYS ASN GLY GLN THR ASN CYS TYR GLN SER TYR SER THR          
 
SEQRES   7 B  124  MET SER ILE THR ASP CYS ARG GLU THR GLY SER SER LYS          
 
SEQRES   8 B  124  TYR PRO ASN CYS ALA TYR LYS THR THR GLN ALA ASN LYS          
 
SEQRES   9 B  124  HIS ILE ILE VAL ALA CYS GLU GLY ASN PRO TYR VAL PRO          
 
SEQRES  10 B  124  VAL HIS PHE ASP ALA SER VAL

04/12/2015, 15h45
VinsS
Mais tu as plusieurs chaînes A et B.

Les résultats obtenus sont ceux des dernières créées pour chaque lettre A et B.

C'était pas prévu au départ ça, comment comptais-tu les différencier ?

Si tu prend le chiffre qui précède la lettre, ça convient ?

Je veux dire comme ceci:
Code:

1 2 prot[''.join(seq[1:3])] = ''.join([dico[x] .......

Ah oui je vois.

En fait, mon script de départ (qui fonctionne) est:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import urllib
iput=raw_input("Code of the protein (ex: 4S18) : ")
url=urllib.urlopen("http://www.rcsb.org/pdb/download/downloadFile.do?fileFormat=pdb&compression=NO&structureId="+str(iput))
pdbfile=url.readlines()
dico={"MSE":"M*","VAL":"V","ILE":"I","LEU":"L","MET":"M","PHE":"F","GLY":"G","ALA":"A","PRO":"P","TRP":"W","TYR":"Y","SER":"S","THR":"T","CYS":"C","ASN":"N","GLN":"Q","ARG":"R","LYS":"K","HIS":"H","ASP":"D","GLU":"E"}
codeA,codeB,codeC,codeD,codeE,codeF,codeG,codeH,codeI="","","","","","","","",""
seq0=[] 
for i in range(len(pdbfile)):
    if pdbfile[i][0:6]=="SEQRES":
        seq0.append(pdbfile[i])
print pdbfile[4][21:]
for i in seq0:
    seq1=i.split()
    for j in seq1[4:]: 
        if seq1[2]=="A":
            codeA=codeA+dico[j]
        if seq1[2]=="B":
            codeB=codeB+dico[j]
        if seq1[2]=="C":
            codeC=codeC+dico[j]
        if seq1[2]=="D":
            codeD=codeD+dico[j]
        if seq1[2]=="E":
            codeE=codeE+dico[j]
        if seq1[2]=="F":
            codeF=codeF+dico[j]
        if seq1[2]=="G":
            codeG=codeG+dico[j]
        if seq1[2]=="H":
            codeH=codeH+dico[j]
        if seq1[2]=="I":
            codeI=codeI+dico[j]
 
if codeA!="":
    print "A chain sequence (length =",len(codeA),"amino acids) :",codeA,"\n"
if codeB!="":
    print "B chain sequence (length =",len(codeB),"amino acids) :",codeB,"\n"
if codeC!="":
    print "C chain sequence (length =",len(codeC),"amino acids) :",codeC,"\n"
if codeD!="":
    print "D chain sequence (length =",len(codeD),"amino acids) :",codeD,"\n"
if codeE!="":
    print "E chain sequence (length =",len(codeE),"amino acids) :",codeE,"\n"
if codeF!="":
    print "F chain sequence (length =",len(codeF),"amino acids) :",codeF,"\n"
if codeG!="":
    print "G chain sequence (length =",len(codeG),"amino acids) :",codeG,"\n"
if codeH!="":
    print "H chain sequence (length =",len(codeH),"amino acids) :",codeH,"\n"
if codeI!="":
    print "I chain sequence (length =",len(codeI),"amino acids) :",codeI
if codeA=="":
    print "There is no proteins associated to this code"

J'obtiens par exemple pour la protéine 4S18:

Code:

1
2
3
4
5
Code of the protein (ex: 4S18) : 4S18                              
 
A chain sequence (length = 124 amino acids) : KETAAAKFERQHMDSSTSAASSSNYCNQMMKSRNLTKDRCKPVNTFVHESLADVQAVCSQKNVACKNGQTNCYQSYSTMSITDCRETGSSKYPNCAYKTTQANKHIIVACEGNPYVPVHFDASV 
 
B chain sequence (length = 124 amino acids) : KETAAAKFERQHMDSSTSAASSSNYCNQMMKSRNLTKDRCKPVNTFVHESLADVQAVCSQKNVACKNGQTNCYQSYSTMSITDCRETGSSKYPNCAYKTTQANKHIIVACEGNPYVPVHFDASV

Je me suis rendu compte ensuite que ce script pouvait convenir à certaines protéines (jusqu'à 9 chaines), mais pour celles en contenant plus, ça ne m'affichait pas les autres chaînes. D'où l'utilité d'élaborer un script plus poussé qui fait la même chose sans avoir à écrire toutes les lignes possibles.

Je n'arrive pas à le faire tourner avec le script que tu as rajouté

Je comprend, tu tiens à regrouper par lettre.

Ceci le fait chez moi:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
prot = {}
for i in seq0:
    seq = i.strip().split()
    res = ''.join([dico[x] for x in seq[4:]])
    if seq[2] in prot:
        prot[seq[2]] += res
    else:
        prot[seq[2]] = res
 
for key in prot:
    print key, prot[key]

04/12/2015, 17h09
karuzel

Oui c'est ce que je voulais faire, c'était pas très explicite c'est vrai.

Génial il marche au poil ce script ! Merci beaucoup de ton aide :mrgreen: