Soucis d'algo chaine de caractère

Version imprimable

Bonjour à tous,

voila je suis bloqué depuis déjà un bon moment sur une question d'algo, je voudrais récupérer le dernier caractère d'une chaine de caractère qui en contient plusieurs occurences, exemples: je veux récupérer le dernier caractère "(", soit celui qui est en rouge dans l'exemple "((...))..()"

Voici mon code :
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 seq="AUCGUCGAUC" struct="(()).(...)" if len(seq) != len(struct): print('ERREUR LA SEQUENCE ET LA TAILLE DU MOTIF DOIVENT AVOIR LA MEME TAILLE') print('\n') print('La sequence a une taille de :', len(seq)) print('La structure a une taille de :', len(struct)) print ('\n') x=' ' First=0 i=0 j=0 LastPosition=0 for i, el in enumerate(struct): while (el=='(') and (i <= len(struct)): LastPosition=i #struct = struct.replace(el," ") break print ('Le dernier ( est a la position : ', LastPosition) for LastPosition, el in enumerate(struct): if el==')': First = LastPosition #struct = struct.replace(el," ") print ('Le premier ) est a la position : ',First) print struct
Dans la première partie du code j'arrive à récupérer la position du dernier élement et à l'afficher en la stockant dans ma variable "LastPosition", mais je voudrais récupérer le caractère (et non la position), car je voudrais supprimer ce caractère apres l'avoir récupérer, si je fais un struct = struct.replace('(', "") je vais supprimer toutes les occurences de '(', voila pourquoi je voudrais récupérer ce caractère pour le supprimer ensuite. J'espère que c'est pas trop flou :lol:

Merci à vous

14/05/2011, 20h25
VinsS
Salut,

Tout d'abord, tu peux parcourir une chaine (ou liste) en sens descendant.

Citation:

>>> for i in range(len(ch)-1, 0, -1):
... print ch[i]
...
f
e
d
c
b

Ensuite tu veux connaitre le caractère et non sa position or ton code dit que tu cherches un caractère spécifique, que tu connais déjà donc.

???

En tout état de cause, tu fais :
Code:

1 2 caractère = struct.pop(i)
ce qui aura pour effet de supprimer le caractère en question et tu le récupéreras dans ta variable 'caractère'.

Non ?
14/05/2011, 21h11
josmiley
Citation:
Envoyé par VinsS

En tout état de cause, tu fais :

Code:

1 2 caractère = struct.pop(i)

ce qui aura pour effet de supprimer le caractère en question et tu le récupéreras dans ta variable 'caractère'.

Non ?
un pop() sur un string ??? 8O
14/05/2011, 21h26
mont29

Eh eh, non, pas de (pape du) pop en string :D (puisqu’elles sont immutable…)

Par contre, un simple

Code:

struct = "".join((struct[:i], struct[i+1:]))

…suffit à se débarrasser de l’importun caractèr(i)e(l) ;)
15/05/2011, 05h52
Pierre Maurette
Bonjour,
- Si on se fiche de connaitre i:

Code:

struct = ''.join(struct.rsplit('(', 1))

épicétou.

- Si on veut également i:
Code:

1 2 cut = struct.rsplit('(', 1) i, struct = len(cut[0]), ''.join(cut)

pop pop pidou

Ben oui pop...

Code:

1
2
3
4
5
6
7
>>> struct = "(()).(..a.)"
>>> l = list(struct)
>>> l.pop(struct.rfind('a'))
'a'
>>> struct = ''.join(l)
>>> struct
'(()).(...)'

Bon.. Ok --->[]

Bonjour à tous et merci pour vos réponses,

En fait je veux récupérer les couples de parenthèses (), garder la position en mémoire, et stocker le caractère pour le supprimer par la suite, car mon but final est de récupérer tous les couples (), seulement je réfléchis a un algo pour récupérer les bon couples, un peu comme dans un calcul mathématique complexe il faut associer les bonnes parenthèses entres elles, bref c'est comme ça que j'ai raissoné, je récupère la dernière parenthèse ouvrante, puis je fais une boucle a partir de la position ou j'ai trouvé la dernière parenthèse ouvrante pour trouver la première parenthèse fermante ( qui sera forcémment la bonne, formant ainsi le bon couple), ensuite je les supprime et je voudrais réitéré jusqu'a les avoir toutes récupétrés, j'espère que c'est plus clair :D

J'ai essayé vos astuces et ca marche pour ma seconde boucle, mais pour la 1ere je supprime toutes les occurences de la parenthèse ouvrante :/ Voici le code actuel :
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 seq="AUCGUCGAUC" struct="(()).(...)" if len(seq) != len(struct): print('ERREUR LA SEQUENCE ET LA TAILLE DU MOTIF DOIVENT AVOIR LA MEME TAILLE') print('\n') print('La sequence a une taille de :', len(seq)) print('La structure a une taille de :', len(struct)) print ('\n') x=' ' First=0 i=0 j=0 LastPosition=0 for i, el in enumerate(struct): while (el=='(') and (i <= len(struct)): LastPosition=i #struct = struct.replace(el," ") break print ('Le dernier ( est a la position : ', LastPosition) for LastPosition, el in enumerate(struct): if el==')': First = LastPosition x = el struct = "".join((struct[:i], struct[i+1:])) print ('Le premier ) est a la position : ',First) print struct print x
PS : en fait la condition de la boucle est nulle, je n'arrive pas a récupérer que la dernière parenthèse ouvrante, je les récupère toute.

16/05/2011, 10h51
josmiley

donnes un exemple d'input/output (j'ai ça en entrée, je veux ça en sortie).
j'ai l'impression que tu veux faire une sorte d' "ordre de priorité", mais c'est pas clair ...
16/05/2011, 11h31
Thomas77380

En entrée j'ai une séquence avec un alphabet seq='AUCGC'

et une structure correspondante a ma sequence, struct='().()'

En sortie je veux :

A C G
| . __|
U _ C

l'affichage bug je suis pas doué... le A est en face du U relié par un '|', le C est seul, il y a juste un '.' sur la seconde ligne, et enfin le G est lié au C par un '|'.

en fait je veux lier les lettres en elles (en fonction de l'agencement des parenthèses), lorsque qu'un point apparait cela signifie qu'il n'y a pas d'appariment. Voila le résultat final que j'aimerais en sortie.
16/05/2011, 11h40
Pierre Maurette

Je suis comme josmiley, je ne comprends pas trop le but du jeu. Peut-être le premier problème est-il de trouver les couples de parenthèses de même rang, et ce qu'il y a entre ? C'est alors un problème assez classique. Dans Google, avec python, vous ajoutez parenthesis matching (ou appairage parenthèses). Vous aurez des solutions le plus souvent regex.
Une idée pour un algo classique: à partir d'une '(', vous initialisez une variable à 0, vous faites +1 pour chaque '(' rencontré, et -1 pour chaque ')'. La ')' correspondante est la première rencontrée avec la variable à 0.

Remarque: il est utile pour poster un problème de faire un embryon de cahier des charges. D'ailleurs le plus souvent en le rédigeant on répond soi-même à la question avant de la poser...
16/05/2011, 11h47
josmiley

avec ça ça donnerait quoi ?

seq="AUCGUCGAUC"

struct="(()).(...)"
16/05/2011, 11h51
Thomas77380

Oui ok je vais essayer de poser un peu plus les choses ca semble bien plus compliqué que je ne pensais.

Citation:

avec ça ça donnerait quoi ?

seq="AUCGUCGAUC"

struct="(()).(...)"

Pour une question de lisibilité je vais présenter le résultat horizontalement:

A --- G
U --- C
U .
C --- C
G .
A .
U .
16/05/2011, 12h13
josmiley

l'ordre a une importance ?
16/05/2011, 12h16
Thomas77380

Oui la séquence finale doit respectée l'ordre d'apparition des parenthèses, comme dans l'exemple.

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
seq=bytearray("AUCGUCGAUC")
 
struct=bytearray("(()).(...)" )
 
out = []
 
while seq:
    if chr(struct[0]) == '.':
        out.append(chr(seq.pop(0)))
        struct.pop(0)
    elif chr(struct[0]) == '(':
        idx = 1
        for e,i in enumerate(struct[1:]):
            if chr(i) == '(':
                idx+=1
            elif chr(i) == ')': idx-=1
            if not idx: break
        out.append((chr(seq.pop(0)),chr(seq.pop(e))))
        struct.pop(0)
        struct.pop(e)
 
print out
 
[('A', 'G'), ('U', 'C'), 'U', ('C', 'C'), 'G', 'A', 'U']

bon, c'est crade ...
j'a fait ça vite fait ...
en gros, tu scannes tes deux chaines en même temps, si t'as un '.', tu retires la lettre correspondante ainsi que le '.', si t'as un '(' tu retires la lettre correspondante et le '(' AINSI QUE le ')' correspondant et la lettre qui y correspond ...
ça fait pas mal de correspondance.

16/05/2011, 12h58
Thomas77380

Je vais tester ça, merci d'avoir pris de votre temps c'est vraiment sympa :)

Ce code nécessite t'il l'importation d'une librairie spécifique ? j'obtiens le message d'erreur suivant lorsque je tente de l'executer :

"NameError: name 'bytearray' is not defined"
16/05/2011, 13h21
josmiley

Citation:

Envoyé par Thomas77380

Je vais tester ça, merci d'avoir pris de votre temps c'est vraiment sympa :)

Ce code nécessite t'il l'importation d'une librairie spécifique ? j'obtiens le message d'erreur suivant lorsque je tente de l'executer :

"NameError: name 'bytearray' is not defined"

ça dépend peut-être de la version de python ... j'ai 2.7.

La solution de josmiley me semble parfaite – c’est aussi l’algorithme que j’aurais utilisé. Par contre, pourquoi utiliser bytearray, qui en plus oblige à systématiquement reconvertir en chr ?

Voici une version avec list, testée sous 2.6 :

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
seq = list("AUCGUCGAUC")
 
struct = list("(()).(...)")
 
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)
 
print out
 
[('A', 'G'), ('U', 'C'), 'U', ('C', 'C'), 'G', 'A', 'U']

PS : Thomas, c’est quoi comme ADN, et à quoi correspond ce regroupement ? ;)

16/05/2011, 14h06
Thomas77380

ça fonctionne merci :), je vais regarder tout ça en détail maintenant.

Citation:

PS : Thomas, c’est quoi comme ADN, et à quoi correspond ce regroupement ?

En fait ce sont des séquences d'ARN, et la structure composée de point et de parenthèses est obtenue suite à l'execution de logiciel de prédiction de structure secondaire d'ARN (c''est à dire le repliement de la molécule d'ARN, d'où cette notion d'appariement). Je ne travail pas sur un regroupement particulier en fait je dois pouvoir matérialiser graphiquement ces structures secondaires d'ARN à partir de n'importe quelles séquences / structures.

Voici un lien vers un logiciel, ce sera sûrement plus parlant :
http://varna.lri.fr/demo.html

EDIT : en fait je suis biologiste de formation et comme vous avez pu le constater mes compétences en programmation sont assez faibles, je ne connais pas trop les listes en python (encore moins que les chaines de caractères c'est dire...) mais à votre avis est'il possible de manipuler cet algo pour avoir un affichage vertical ? car là les appariements sont parfaits, c'est juste le rendu graphique qui pose "problême", j'aimerai obtenir quelque chose qui ressemble à peu près ca :

c agg gagguag gguuguau
| ||| ||||||| ||||||||||| || ||
g uuu uuccauu ccaaca

je voudrais juste savoir si c''est faisable en manipulant des listes ?

Citation:
Envoyé par mont29
La solution de josmiley me semble parfaite – c’est aussi l’algorithme que j’aurais utilisé. Par contre, pourquoi utiliser bytearray, qui en plus oblige à systématiquement reconvertir en chr ?

Voici une version avec list, testée sous 2.6 :
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 seq = list("AUCGUCGAUC") struct = list("(()).(...)") 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) print out [('A', 'G'), ('U', 'C'), 'U', ('C', 'C'), 'G', 'A', 'U']
PS : Thomas, c’est quoi comme ADN, et à quoi correspond ce regroupement ? ;)
comme j'ai dit plus haut, j'ai pondu ça vite fait; j'ai fait une sieste et en me réveillant je me suis dit "mais chui trop c**" ... trop tard. ^^

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:

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

Non, en effet, ça va pas :)

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

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

si je peux me permettre ...

Code:

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)

17/05/2011, 21h13
Thomas77380

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 :)
18/05/2011, 11h24
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 :roll:

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

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:

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 :oops:

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:

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 :lol:

Merci encore
18/05/2011, 12h17
mont29
Citation:
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 :roll:

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

Code:

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 ?

Citation:

Envoyé par Thomas77380

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

Code:

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 :oops:

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()
Citation:
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:

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 :lol:

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 :D

bonjour,

la notation avec * dans une fonction sert à ceci:

Code:

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:

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.

18/05/2011, 12h24
Thomas77380

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

Citation:

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 :ccool:

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 8O

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:

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)

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:

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

19/05/2011, 14h37
Thomas77380

Une fois de plus merci, cela fonctionne à merveille :)

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

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

Citation:

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.

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 :mouarf:

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:

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:

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

19/05/2011, 19h28
Thomas77380

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

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 :roll:).

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:

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:

1 2 seq = "CCAGGCCUGUUAAGCAUAAGUACUUCUUUACUAUCCCAUACUGAACUCAAUUGUAUGGAAUGUAAAGAAGUAUGUAUGGUUAGCAGGCUACCACGU" struct = "...((((((((((.((((.((((((((((((.((.((((((...........)))))).)))))))))))))).)))).))))))))))......."
j'aurais en résultat :
Code:

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:

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 :?

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:

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:

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

23/05/2011, 11h09
Thomas77380

Merci encore :)