Soucis d'algo chaine de caractère

**Thomas77380** · 17/05/2011, 16h32

Rebonjour,

j'ai un peu modifié votre code pour avoir un affichage qui se rapproche de la chose finale que j'aimerai obtenir, j'ai également rajouté une boucle pour insérer un symbole '|' lorsque 2 bases étaient appariées, c'est a dire plus simplement lorsque la liste du bas (liste2) était non nul, seulement malgré la boucle la condition ne fonctionne que pour le premier couple lorsque je fais tourner mon programme, ma condition est'elle éronnée ?

Le code en haut n'a aucune importance, c'est seulement un ensemble de vérifications préalables.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
seq = list(raw_input("Entrez une sequence: "))
carac = True
for k in seq:
		  if (k!= 'a') and (k!= 'u') and (k!= 'g') and (k!= 'c'):
			carac = False
 
if carac == False:
 
	print("Ceci n'est pas une sequence d'ARN valide")
	quit()
 
 
 
struct = list(raw_input("Entrez la structure: "))
 
symb = True
for l in struct:
		if (l!= '.') and (l!= '(') and (l!=')'):
			symb = False
if symb == False:			
 print "Caractere incorrecte detecte"
 quit()
 
 
 
a=0
b=0 
for l in struct:
		if l=='(':
			a=a+1
		elif l==')':
			b=b+1	
if a!=b:
	print "Vous n'avez pas entre le meme nombre de ( et de ) dans la structure...."
	print "nombre de '(' :", a
	print "nombre de ')' :", b
        quit()
 
 
resultat = []
 
 
if len(struct) != len(seq):
	 print"ERREUR LA SEQUENCE ET LA STRUCTURE DOIVENT ETRE DE MEME TAILLE"
	 quit()
 
ligne = [] 
ligne2 = []
ligne_haut = []
ligne_bas = []
while seq:
    if struct[0] == '.': #and struct[1] == '.':
        resultat.append(seq.pop(0))             
	#ligne_haut.append(seq.pop(0))
	#ligne_bas.append(seq.pop(1))
        struct.pop(0)               
	#struct.pop(1)       	
    elif struct[0] == '(':
        idx = 1
        for e,i in enumerate(struct[1:]):
            if i == '(':
                idx += 1
            elif i == ')':
                idx -= 1
            if not idx: break
        #resultat.append((seq.pop(0), seq.pop(e)))
	resultat.append(seq.pop(0))
	ligne2.append(seq.pop(e))
	for t,i in enumerate(ligne2):
		if ligne2=='':
			t+=1
		else:
		    ligne='  |'
 
 
        struct.pop(0)
        struct.pop(e)
 
 
 
#print ligne_haut
print resultat
print ligne 
print ligne2
#print ligne_bas

Si ma liste2 a la position t est vide j'avance, sinon (si n'importe quel caractère est présent) j'ajoute un '|' a ma liste (situé entre resultat et liste2).

Merci à vous

**mont29** · 17/05/2011, 19h42

Non, en effet, ça va pas

J’ai repris mon code, c’est plus clair*:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
seq = list("AUCGUCGAUC")
 
struct = list("(()).(...)")
 
l1 = []
l2 = []
l3 = []
 
while seq:
    if struct[0] == '.':
        l1.append(seq.pop(0))
        l2.append(" ")
        l3.append(" ")
        struct.pop(0)
    elif struct[0] == '(':
        idx = 1
        for e,i in enumerate(struct[1:]):
            if i == '(':
                idx += 1
            elif i == ')':
                idx -= 1
            if not idx: break
        l1.append(seq.pop(0))
        l2.append("|")
        l3.append(seq.pop(e))
        struct.pop(0)
        struct.pop(e)
 
print "".join(l1)
print "".join(l2)
print "".join(l3)
 
AUUCGAU
|| |   
GC C

**josmiley** · 17/05/2011, 20h10

si je peux me permettre ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def foo(seq,struct): 
    out = []
    while seq:
        if struct[0] == '.':
            out.append((seq.pop(0),' ',' '))
            struct.pop(0)
        elif struct[0] == '(':
            idx = 1
            for e,i in enumerate(struct[1:]):
                if i == '(':
                    idx += 1
                elif i == ')':
                    idx -= 1
                if not idx: break
            out.append((seq.pop(0),'|',seq.pop(e)))
            struct.pop(0)
            struct.pop(e)
    a,b,c = zip(*out)
    return ''.join(a)+'\n'+''.join(b)+'\n'+''.join(c)
 
seq = list("AUCGUCGAUC")
struct = list("(()).(...)")
print foo(seq,struct)

**Thomas77380** · 17/05/2011, 21h13

Merci encore à vous 2, je vois des méthodes que je ne connaissais pas je vais étudier tout ça ce soir, merci encore pour votre aide

**Thomas77380** · 18/05/2011, 11h24

J'aurais une ou deux questions de compréhension par rapport à vos codes respectifs, tout ça marche parfaitement mais il y a certaines subtilités que j'ai du mal à percevoir

je m'auto édit je viens d'enlever la ligne de code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
print "".join(l1)
print "".join(l2)
print "".join(l3)

en la remplacant par de simple print l1, effectivement niveau visibilité c'est génial

C'est à cause de cet affichage que j'avais commencé à travailler sur des chaines de caractères.

J'ai une question stupide aussi sur ces lignes de codes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 l1.append(seq.pop(0))

La fonction append permet d'ajouter un élément en fin de liste, et ici elle prend en argument la fonction pop, qui elle retourne le dernier élément de la liste avant de le supprimer, en fait j'ai du mal a "voir" comment ca se passe pas a pas quand le programme tourne

Enfin une dernière question (ça commence à faire beaucoup je sais) sur votre fonction josmiley, la méthode zip permet de parcourir plusieurs listes en même temps (d'après ce que j'ai lu sur internet), j'ai trouvé un exemple d'utilisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
TAILLE_LISTE = 100  
 
liste = list(range(TAILLE_LISTE))  
liste2 = list(range(TAILLE_LISTE))  
 for elem1, elem2 in zip(liste ,liste2):

ici je comprends bien qu'on va parcourir les 2 listes liste et list2 en même temps avec respectivement les elem1 et elem2, dans le code par contre je ne comprends pas le "*out", de même a,b et c ne sont pas définis, enfin tout marche niquel mais c'est moi qui manque de pratique

Merci encore

**mont29** · 18/05/2011, 12h17

Envoyé par Thomas77380

J'aurais une ou deux questions de compréhension par rapport à vos codes respectifs, tout ça marche parfaitement mais il y a certaines subtilités que j'ai du mal à percevoir

je m'auto édit je viens d'enlever la ligne de code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
print "".join(l1)
print "".join(l2)
print "".join(l3)

en la remplacant par de simple print l1, effectivement niveau visibilité c'est génial

C'est à cause de cet affichage que j'avais commencé à travailler sur des chaines de caractères.

Euh, je comprends pas très bien ta question ?

Envoyé par Thomas77380

J'ai une question stupide aussi sur ces lignes de codes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 l1.append(seq.pop(0))

La fonction append permet d'ajouter un élément en fin de liste, et ici elle prend en argument la fonction pop, qui elle retourne le dernier élément de la liste avant de le supprimer, en fait j'ai du mal a "voir" comment ca se passe pas a pas quand le programme tourne

Le déroulement est imbriqué :
*appel de pop() sur seq, qui enlève l’élément visé de seq et le retourne
*ajout de l’élément retourné par pop() à l1 par append()

Envoyé par Thomas77380

Enfin une dernière question (ça commence à faire beaucoup je sais) sur votre fonction josmiley, la méthode zip permet de parcourir plusieurs listes en même temps (d'après ce que j'ai lu sur internet), j'ai trouvé un exemple d'utilisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
TAILLE_LISTE = 100  
 
liste = list(range(TAILLE_LISTE))  
liste2 = list(range(TAILLE_LISTE))  
 for elem1, elem2 in zip(liste ,liste2):

ici je comprends bien qu'on va parcourir les 2 listes liste et list2 en même temps avec respectivement les elem1 et elem2, dans le code par contre je ne comprends pas le "*out", de même a,b et c ne sont pas définis, enfin tout marche niquel mais c'est moi qui manque de pratique

Merci encore

La notation *out “déplie” un iterable, donc zip(*out) est équivalent à zip(out[0], out[1], …, out[n-1], out[n])

Pour info, il existe aussi la notation **, qui elle “déplie” les paires clé/valeur d’un dict ou assimilé

Voilou

**kango** · 18/05/2011, 12h19

bonjour,

la notation avec * dans une fonction sert à ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#la fonction prend 3 paramètres
def show(a, b, c):
    print a, b, c
 
#on veut passer à la fonction les paramètres à partir d'une liste:
lst = ['un', 'deux', 'trois']
 
#on peut faire ceci:
show(lst[0], lst[1], lst[2])
 
#ou alors:
show(*lst)
 
#c'est plus court, c'est juste que Python "depack" les élements de la liste tout seul

pour l'affectation multiple, un simple exemple devrait suffire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def numbers():
    return 1, 2 # la fonction renvoie 2 valeurs (ou plus exactement un tuple de 2 valeurs)
 
a, b = numbers()
print a
#>>> 1
print b
#>>> 2
 
#et on peut faire la même chose depuis une liste:
a, b, c = lst
print a
#>>> un
print b
#>>> deux
print c
#>>> trois
 
#il s'agit en fait de la même opération que *, on "depack" une liste ou un tuple.

**Thomas77380** · 18/05/2011, 12h24

Ok merci pour vos explications c''est bien plus clair maintenant

Euh, je comprends pas très bien ta question ?

non en fait je disais juste que j'ai découvert le rôle de ces lignes en les mettant en commentaire, en effet elles permettent un affichage lisible c'est nikel

**Thomas77380** · 18/05/2011, 16h22

Une dernière condition vient d'être ajoutée à mon cahier des charges, je dois maintenant traiter les mésapariments, c'est à dire les '.', j'ai crée deux nouvelles listes, situées aux extrémités des trois premieres, c'"est ici que je vais stocker les lettres correspondants aux '.'. Pour le moment je stocke toutes les lettres correspondants aux '.' dans la liste "haut", en tenant compte des autres listes et en marquant donc des espaces pour ne pas perturber l'affichage.
J'aimerais préserver la structure générale du code que vous m'avez donné, et c'est là le problême je n'arrive pas a adapter le code en fonction de mes besoins, en fait lorsque l'on fait "struct[0]=='.'" je dois stocker la lettre dans ma liste haut, et je dois en parallèle regarder s'il y a un point a la position opposée, par exemple si je trouve un '.' à la position i je dois regarder a la position max - i s'il y a un autre point, si c'est le cas j'affiche la lettre correspondant dans ma sequence du bas "bas", sinon (c'est donc une parenthèse qu'on y trouvera) j'affiche un '_' dans la liste "bas".

Graphiquement cela doit ressembler à ca : http://www.mirbase.org/cgi-bin/mirna...?acc=MI0010516 (en face de "stem-loop).

J'aurais donc voulu savoir comment je pouvais faire pour trouver la position opposé a un '.' étant donné que l'on utilise pas d'indice lorsque l'on trouve le premier '.', je ne peux donc pas indiquer une position max - i.
J'avais commencé a faire un for entre les lignes 4 et 5 pour parcourir ma struct et déterminer le '.' opposé au premier, seulement c'est impossible car on ne récupère aucun indice quand on fait "if struct[0]=='.'.

J'ai peur de ne pas avoir été clair

je remet la partie du code gérant la structure ci dessous, pensez vous que l'objectif est réalisable en adaptant ce code ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
while seq:
    if struct[0] == '.':	    
        haut.append(seq.pop(0))           
        l2.append(" ")
        l3.append(" ") 
	l1.append(" ")
        struct.pop(0)
    elif struct[0] == '(':
        idx = 1
        for e,i in enumerate(struct[1:]):
            if i == '(':
                idx += 1
            elif i == ')':
                idx -= 1
            if not idx: break
 
	haut.append(" ")
	bas.append(" ")
        l1.append(seq.pop(0))
        l2.append("|")
        l3.append(seq.pop(e))
 
        struct.pop(0)
        struct.pop(e)
 
print "".join(haut)
print "".join(l1)             
print "".join(l2)
print "".join(l3)
print "".join(bas)

**mont29** · 18/05/2011, 18h19

En effet, il faut un peu changer les choses… et ne plus supprimer les éléments des listes avec pop(), à mon avis.

De plus, tu n’explicites pas assez le comportement en cas de caractère '.', j’ai donc choisi, dans le cas ou il n’y a pas de “vis-à-vis” à un '.', de placer la base sur la ligne du haut pendant la première moitié de la séquence, puis sur celle du bas pour la deuxième moitié… À adapter si ce n’est le comportement voulu.

J’ai aussi tenu compte du cas des séquences impaires (problème si l’élément du milieu est un '.', il se “matcherait” lui-même…)

En adaptant le code de josmiley, ça donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
def foo(seq,struct): 
    out = []
    done = set()
    ln = len(seq)
    for i, el in enumerate(struct):
        if i in done:
            # If element already processed, continue.
            continue
        elif el == '.':
            if i < (ln+1)/2:  # first part of the sequence.
                if struct[-i-1] != '.' or i == ln-i-1:
                    # Last test is for middle el in case of odd number of bases.
                    out.append((seq[i], " ", " ", " ", "-"))
                else:
                    out.append((seq[i], " ", " ", " ", seq[-i-1]))
                    done.add(ln-i-1)
                done.add(i)
            else:  # second part of the sequence.
                # XXX This should never occures!
                if struct[-i-1] == '.':
                    out.append((seq[-i-1], " ", " ", " ", seq[i]))
                    done.add(ln-i-1)
                else:
                    out.append(("-", " ", " ", " ", seq[i]))
                done.add(i)
        elif el == '(':
            idx = 1
            for j,e2 in enumerate(struct[i+1:]):
                if e2 == '(':
                    idx += 1
                elif e2 == ')':
                    idx -= 1
                if not idx: break
            out.append((" ", seq[i], '|', seq[i+j+1], " "))
            done.add(i)
            done.add(i+j+1)
    return '\n'.join([''.join(l) for l in zip(*out)])
 
seq = list("AUCGUCGAUC")
struct = list("(()).(...)")
print foo(seq,struct)
 
  U ---
AU C   
|| |   
GC C   
  - GAU

**Thomas77380** · 19/05/2011, 14h37

Une fois de plus merci, cela fonctionne à merveille

J'aurais une question sur le code en lui même

je n'ai pas bien compris comment fonctionnait la méthode set(), j'ai trouvé assez peu de ressources sur le web:

There are currently two built-in set types, set and frozenset. The set type is mutable — the contents can be changed using methods like add() and remove(). Since it is mutable, it has no hash value and cannot be used as either a dictionary key or as an element of another set. The frozenset type is immutable and hashable — its contents cannot be altered after it is created; it can therefore be used as a dictionary key or as an element of another set.

en utilisant set on permet a la liste de subir des modifications grâce à la méthode add() c'est bien ça ?

Par ailleurs j'essaie de faire une dernière modification, j'aimerais récupérer les éventuels '.' situés entre la parenthèse du milieu (entre la dernière ouvrante et la première fermante), disposer les lettres correspondantes a ces points de manière à former une "boucle" pour clôturer le motif, comme dans cette exemple en fait avec les 4 nucléotides 'a' 'c' 'a' 'u' situé au bout a droite du motif:
http://www.mirbase.org/cgi-bin/mirna...?acc=MI0010516
Lorsque l'on clique sur "get Sequence" on a accès aux input du programme, c'est a dire la sequence et la structure.

Mais le problème c'est qu'il faut regarder plusieurs choses: on se place dans la boucle qui cherche les '.', mais il faut aussi trouver les bonnes parenthèses en parallèle

Concrètement l'affichage ne serait modifié que pour les derniers nucléotides : si le nombre de points est impairs, on répartit les 3 dernières bases sur les 3 lignes du milieu (la ligne du match, celle du symbole '|' et la dernière ligne du match), si le nombre de points est pairs, on met "simplement" les deux derniers nucléotides sur les mêmes lignes que ceux qui match, comme le 'c' et le 'a' dans l'exemple ci dessus. Cela permettrait de mieux visualiser la clôture du motif.

Je voulais donc savoir s'il était possible de récupérer ces fameux points sans bouleverser l'architecture du programme ?

edit: j'ai oublié de préciser que dans ce genre de structure il n'y a pas de parenthèse fermante avant la moiitié de la séquence et inversement.

**mont29** · 19/05/2011, 17h56

Ok.

D’abord, set() retourne un objet set, qui n’est pas une liste mais un ensemble (les éléments n’y sont pas ordonnés, et il n’y sont qu’en un seul exemplaire). L’avantage des set, c’est que les opérations sur les ensembles y sont aisées et rapide (savoir si un élément est dedans, intersection, union, etc.).

Maintenant, on ne va plus les utiliser, ces set

Si je comprends bien, une fois qu’on a débuté un groupe de parenthèses, elles sont toutes bien imbriquées les unes dans les autres*? autrement dit, on peut avoir "((.))..(..()).()", mais pas "...(..()(..)...((.).)..)", par exemple*? Si c’est bien le cas, alors le code ci-dessous devrait bien mieux convenir.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
def foo(seq,struct): 
    out = []
    ln = len(seq)
    matches = [[[-1, ln, 0, 0]]]
    grp_idx = 0
    idx = 0
    closing = False
    out_grp = False
    # Let's first parse that dummy struct string into lists of groups.
    for i, el in enumerate(struct):
        if el == '(':
            if out_grp:
                matches[grp_idx][0][1] = i
                grp_idx += 1
                out_grp = False
            idx += 1
            matches[grp_idx].append([i, ln, 0, 0])
        elif el == ')':
            closing = True
            matches[grp_idx][idx][1] = i
            idx -= 1
            if idx == 0:
                matches.append([[i, ln, 0, 0]])  # Add a new group.
                out_grp = True  # To force creation of a new group.
                closing = False
        elif el == '.':
            if out_grp:
                matches[grp_idx][idx][3] += 1
                matches[grp_idx+1][idx][2] += 1
            elif closing:
                matches[grp_idx][idx][3] += 1
            else:
                matches[grp_idx][idx][2] += 1
 
    # Now that all matches have been parsed, create their char representation.
    for grp_idx, grp in enumerate(matches):
        out.append([])
        if len(grp) == 0:
            continue
        # If only one element in grp (hence no matching bases).
        elif len(grp) == 1:
            print grp
            m = grp[0]
            # Here, m[3] will always be 0.
            if m[2] == 1:  # Only one base.
                out[grp_idx].append((" ", " ", seq[m[0]+1], " ", " "))
            elif m[2] > 1:
                nr = m[2]/2.0
                for i in xrange(1, int(nr)):
                    out[grp_idx].append((seq[m[0]+i], " ", " ", " ", seq[m[1]-i]))
                if int(nr) == nr:  # Even number of "ending bases":
                    out[grp_idx].append((" ", seq[m[0]+i+1], " ", seq[m[1]-i-1], " "))
                else:
                    out[grp_idx].append((" ", seq[m[0]+i+1], " ", seq[m[1]-i-1], " "))
                    out[grp_idx].append((" ", " ", seq[m[0]+i+2], " ", " "))
            continue
        # First element of each group is special, as it is not delimited by matching parenthesis.
        m = grp[0]
        if m[2] > m[3]:
            delta = m[2] - m[3]
            for i in xrange(1, m[2]+1):
                if i - 1 < delta:
                    out[grp_idx].append((seq[m[0]+i], " ", " ", " ", "-"))
                else:
                    out[grp_idx].append((seq[m[0]+i], " ", " ", " ", seq[m[1]-i+delta]))
        else:
            delta = m[3] - m[2]
            for i in xrange(1, m[3]+1):
                if i - 1 < delta:
                    out[grp_idx].append(("-", " ", " ", " ", seq[m[1]-i]))
                else:
                    out[grp_idx].append((seq[m[0]+i], " ", " ", " ", seq[m[1]-i]))
        for m in grp[1:-1]:
            out[grp_idx].append((" ", seq[m[0]], "|", seq[m[1]], " "))
            if m[2] > m[3]:
                delta = m[2] - m[3]
                for i in xrange(1, m[2]+1):
                    if i - 1 < delta:
                        out[grp_idx].append((seq[m[0]+i], " ", " ", " ", "-"))
                    else:
                        out[grp_idx].append((seq[m[0]+i], " ", " ", " ", seq[m[1]-i+delta]))
            else:
                delta = m[3] - m[2]
                for i in xrange(1, m[3]+1):
                    if i - 1 < m[3] - m[2]:
                        out[grp_idx].append(("-", " ", " ", " ", seq[m[1]-i]))
                    else:
                        out[grp_idx].append((seq[m[0]+i], " ", " ", " ", seq[m[1]-i]))
        # Last element in a group is also a special case!
        m = grp[-1]
        out[grp_idx].append((" ", seq[m[0]], "|", seq[m[1]], " "))
        # Here, m[3] will always be 0.
        if m[2] == 1:  # Only one base.
            out[grp_idx].append((" ", " ", seq[m[0]+1], " ", " "))
        elif m[2] > 1:
            nr = m[2]/2.0
            for i in xrange(1, int(nr)):
                out[grp_idx].append((seq[m[0]+i], " ", " ", " ", seq[m[1]-i]))
            if int(nr) == nr:  # Even number of "ending bases":
                out[grp_idx].append((" ", seq[m[0]+i+1], " ", seq[m[1]-i-1], " "))
            else:
                out[grp_idx].append((" ", seq[m[0]+i+1], " ", seq[m[1]-i-1], " "))
                out[grp_idx].append((" ", " ", seq[m[0]+i+2], " ", " "))
 
    return '\n\n'.join(['\n'.join([''.join(l) for l in zip(*grp)]) for grp in out])
 
seq =    "CUGAGGUGAGGUAGUAGGUUGUAUAGUUCAGAAGUACAACAUUGGAGAUGACUGUACAACCCGUUACCUUUUUUUGGGUCAUAUGCGUCGAUCGGUAC"
struct = "(..(((.(((((((..(((((((((((.((......((....))....)))))))))))))..))))))).)))..).....((.)).(...)....."
print foo(seq,struct)

Qui donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
----- UG   U       UA           U  GAAGUA  A 
     C  AGG GAGGUAG  GGUUGUAUAGU CA      CA C
     |  ||| |||||||  ||||||||||| ||      ||  
     G  UUU UUCCAUU  CCAACAUGUCA GU      GU A
UACUG GU   U       GC           -  --AGAG  U 
 
GUCAU   
     AU 
     ||G
     GC 
----U   
 
----U   
     CG 
     | U
     CG 
CAUGG   
 
G  
 G 
  U
 A 
C

Basiquement, il fait une première passe sur struct, et parse le tout pour obtenir des groupes (qui sont définis par les parenthèses les plus extérieures) contenant des quadruplet [idx_parenthèse_ouvrante, idx_parenthèse_fermante, nbr_bases_avant_groupe_interne, nbr_bases_après_groupe_interne]. Par exemple, "..(..(.()).)' donnerait un groupe [[-1, 13, 2, 0], [2, 12, 2, 1], [5, 10, 1, 0], [7, 8, 0, 0]] (note que le premier quadruplet est spécial, car il n’y a évidemment pas de parenthèses pour lui, seulement des bases non-appariées…

Ensuite, il fait une deuxième passe en produisant l’affichage à partir de cette liste de groupes.

Un point important*: comme je ne savais pas que faire avec les bases isolées entre chaque groupe, je les ai systématiquement placées à la fois en fin du groupe courant, et en début du prochain groupe (c’est facile d’adapter le code pour un autre comportement, ceci dit).

**Thomas77380** · 19/05/2011, 19h28

Merci beaucoup je vais travailler ca ce soir, un grand merci

**Thomas77380** · 20/05/2011, 12h38

Re bonjour,

j'ai travaillé le code ce matin et je dois avouer que j'ai un peu de mal à tout comprendre (tout est très bien, c'est commenté en plus, mais c'est moi qui ai un peu de mal

).

J'ai compris l'ossature du programme, la première partie composant les différents groupes en fonction des blocs de parenthèses avec les différents attributs de "matches".

C'est lors de la représentation des caractères que j'ai un peu plus de mal à suivre.

Tout d'abord je ne comprends pas bien le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

out.append([])

à la ligne 37:
tant qu'on parcours les différents groupes stockés dans matches on va ajouter une liste vide à out ?

Ensuite j'ai du mal a comprendre comment fonctionne "m", au début on initialise m a grp[0], c'est a dire au premier attribut du quadruplet ? soit l'index de la parenthèse ouvrante ? D'où le m[2] = 1 avec 2 correspondant au nombre de base avant le groupe interne ?
Le reste des conditions je comprends bien le fonctionnement, seulement j'aimerais être sur de bien comprendre à quoi correspond m puisqu'il est utilisé pour chacune des comparaisons.
Je pourrai ensuite modifier le comportement du programme concernant les '.' situés avant et après les toutes premières parenthèses, en fait je cherche dans quelle partie du programme ces points sont gérés.

Par exemple si en entrée j'ai:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
seq =    "CCAGGCCUGUUAAGCAUAAGUACUUCUUUACUAUCCCAUACUGAACUCAAUUGUAUGGAAUGUAAAGAAGUAUGUAUGGUUAGCAGGCUACCACGU"
struct = "...((((((((((.((((.((((((((((((.((.((((((...........)))))).)))))))))))))).)))).))))))))))......."

j'aurais en résultat :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
----GCC          G    A            U  C      UGAA  
       GGCCUGUUAA CAUA GUACUUCUUUAC AU CCAUAC    C 
       |||||||||| |||| |||||||||||| || ||||||     U
       UCGGACGAUU GUAU UAUGAAGAAAUG UA GGUAUG    C 
UGCACCA          G    G            -  A      UUAA  

AC  
  C 
   A
  C 
UG

Or je ne devrais pas avoir la boucle en bas, les nucléotides ACCACGU sont déjà bien présent au dessus, mais ce que je trouve étrange et que je n'arrive pas à expliquer c'est la présence des bases GCC en bleu, alors qu'on devrait avoir CCA (se sont les 3 premières bases de la séquence).

On devrait obtenir ;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
----cca          g    a            u  c      ugaa 
       ggccuguuaa caua guacuucuuuac au ccauac    c
       |||||||||| |||| |||||||||||| || ||||||    u
       ucggacgauu guau uaugaagaaaug ua gguaug    c
ugcacca          g    g            -  a      uuaa

je vais modifier l'apparition de la boucle du bas, mais pour les nucléotides GCC au lieu de CCA j'avoue que je ne vois pas

**mont29** · 21/05/2011, 15h05

Salut

La liste out est à deux dimensions*:

La première correspond aux grands groupes, ou boucles (dans mon exemple de code précédent, il y en a trois + le “reste”).

Donc, le out.append([]) ajoute une nouvelle liste (crée un nouveau groupe/boucle) de bases (les colonnes).

Quant à m, il s’agit à chaque fois d’un quadruplet complet (rappelle-toi que grp représente une boucle dans son ensemble, donc une liste de quadruplets).

Pour le problème des lettres de départ de la boucle, c’est corrigé (je pense

, simple petit problème d’offset oublié…)*:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
def foo(seq,struct): 
    out = []
    ln = len(seq)
    matches = [[[-1, ln, 0, 0]]]
    grp_idx = 0
    idx = 0
    closing = False
    out_grp = False
    # Let's first parse that dummy struct string into lists of groups.
    for i, el in enumerate(struct):
        if el == '(':
            if out_grp:
                matches[grp_idx][0][1] = i
                grp_idx += 1
                out_grp = False
            idx += 1
            matches[grp_idx].append([i, ln, 0, 0])
        elif el == ')':
            closing = True
            matches[grp_idx][idx][1] = i
            idx -= 1
            if idx == 0:
                matches.append([[i, ln, 0, 0]])  # Add a new group.
                out_grp = True  # To force creation of a new group.
                closing = False
        elif el == '.':
            if out_grp:
                matches[grp_idx][idx][3] += 1
                matches[grp_idx+1][idx][2] += 1
            elif closing:
                matches[grp_idx][idx][3] += 1
            else:
                matches[grp_idx][idx][2] += 1
 
    # Now that all matches have been parsed, create their char representation.
    for grp_idx, grp in enumerate(matches):
        out.append([])
        if len(grp) == 0:
            continue
        # If only one element in grp (hence no matching bases).
        elif len(grp) == 1:
            print grp
            m = grp[0]
            # Here, m[3] will always be 0.
            if m[2] == 1:  # Only one base.
                out[grp_idx].append((" ", " ", seq[m[0]+1], " ", " "))
            elif m[2] > 1:
                nr = m[2]/2.0
                for i in xrange(1, int(nr)):
                    out[grp_idx].append((seq[m[0]+i], " ", " ", " ", seq[m[1]-i]))
                if int(nr) == nr:  # Even number of "ending bases":
                    out[grp_idx].append((" ", seq[m[0]+i+1], " ", seq[m[1]-i-1], " "))
                else:
                    out[grp_idx].append((" ", seq[m[0]+i+1], " ", seq[m[1]-i-1], " "))
                    out[grp_idx].append((" ", " ", seq[m[0]+i+2], " ", " "))
            continue
        # First element of each group is special, as it is not delimited by matching parenthesis.
        m = grp[0]
        if m[2] > m[3]:
            delta = m[2] - m[3]
            for i in xrange(1, m[2]+1):
                if i - 1 < delta:
                    out[grp_idx].append((seq[m[0]+i], " ", " ", " ", "-"))
                else:
                    out[grp_idx].append((seq[m[0]+i], " ", " ", " ", seq[m[1]-i+delta]))
        else:
            delta = m[3] - m[2]
            for i in xrange(1, m[3]+1):
                if i - 1 < delta:
                    out[grp_idx].append(("-", " ", " ", " ", seq[m[1]-i]))
                else:
                    out[grp_idx].append((seq[m[0]+i-delta], " ", " ", " ", seq[m[1]-i]))
        for m in grp[1:-1]:
            out[grp_idx].append((" ", seq[m[0]], "|", seq[m[1]], " "))
            if m[2] > m[3]:
                delta = m[2] - m[3]
                for i in xrange(1, m[2]+1):
                    if i - 1 < delta:
                        out[grp_idx].append((seq[m[0]+i], " ", " ", " ", "-"))
                    else:
                        out[grp_idx].append((seq[m[0]+i], " ", " ", " ", seq[m[1]-i+delta]))
            else:
                delta = m[3] - m[2]
                for i in xrange(1, m[3]+1):
                    if i - 1 < m[3] - m[2]:
                        out[grp_idx].append(("-", " ", " ", " ", seq[m[1]-i]))
                    else:
                        out[grp_idx].append((seq[m[0]+i], " ", " ", " ", seq[m[1]-i]))
        # Last element in a group is also a special case!
        m = grp[-1]
        out[grp_idx].append((" ", seq[m[0]], "|", seq[m[1]], " "))
        # Here, m[3] will always be 0.
        if m[2] == 1:  # Only one base.
            out[grp_idx].append((" ", " ", seq[m[0]+1], " ", " "))
        elif m[2] > 1:
            nr = m[2]/2.0
            for i in xrange(1, int(nr)):
                out[grp_idx].append((seq[m[0]+i], " ", " ", " ", seq[m[1]-i]))
            if int(nr) == nr:  # Even number of "ending bases":
                out[grp_idx].append((" ", seq[m[0]+i+1], " ", seq[m[1]-i-1], " "))
            else:
                out[grp_idx].append((" ", seq[m[0]+i+1], " ", seq[m[1]-i-1], " "))
                out[grp_idx].append((" ", " ", seq[m[0]+i+2], " ", " "))
 
    return '\n\n'.join(['\n'.join([''.join(l) for l in zip(*grp)]) for grp in out])
 
#seq =    "CUGAGGUGAGGUAGUAGGUUGUAUAGUUCAGAAGUACAACAUUGGAGAUGACUGUACAACCCGUUACCUUUUUUUGGGUCAUAUGCGUCGAUCGGUAC"
#struct = "(..(((.(((((((..(((((((((((.((......((....))....)))))))))))))..))))))).)))..).....((.)).(...)....."
seq =    "CCAGGCCUGUUAAGCAUAAGUACUUCUUUACUAUCCCAUACUGAACUCAAUUGUAUGGAAUGUAAAGAAGUAUGUAUGGUUAGCAGGCUACCACGU"
struct = "...((((((((((.((((.((((((((((((.((.((((((...........)))))).)))))))))))))).)))).))))))))))......."
print foo(seq,struct)

Me donne bien

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
----CCA          G    A            U  C      UGAA  
       GGCCUGUUAA CAUA GUACUUCUUUAC AU CCAUAC    C 
       |||||||||| |||| |||||||||||| || ||||||     U
       UCGGACGAUU GUAU UAUGAAGAAAUG UA GGUAUG    C 
UGCACCA          G    G            -  A      UUAA  
 
AC  
  C 
   A
  C 
UG

Je te laisse faire le travail pour l’élimination du “reste” (indice*: teste simplement les groupes/boucles (grp), et s’ils ne sont faits que d’un seul élément, ne les affiche pas).

**Thomas77380** · 23/05/2011, 11h09

Merci encore

Soucis d'algo chaine de caractère

Python

Discussions similaires

Partager

Partager