compte de caractere en dynamique

**eyquem** · 11/06/2010, 13h45

Note bien que je ne comprends pas parfaitement tout ce qui se trouve au dessus de la ligne
p.read_Matrice(m2) # partition des log-probabilites maximales en chaque position
parce que je ne connais pas le sujet. L’essentiel est que cela fasse ce que tu veux et que tu en sois satisfaite, tu es seule juge.

Dans cette partie , j’écrirais juste de façon plus agréable à lire, pour que les lignes ne dépassent pas de l’écran:

Code :

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

1
2
3
4
5
6
7
8
Fichier_a_traiter = tkFileDialog.askopenfilename(filetypes = [("All", "*"),
                                                              ("Selection du fichier a traiter",
                                                               "*.fa")])
 
 
commands.getstatusoutput('/home/m1sp/bin/decoup_CpG '+\
                         Fichier_a_traiter +\
                         ' arbre Fichier_a_traiter.out 3 0.4 2.65 1.5 8.8 1.66')

Proposition supplémentaire:
dans la mesure où je vois tkFileDialog n’apparaître qu’une seule fois dans le code à l’endroit suivant
Fichier_a_traiter = tkFileDialog.askopenfilename(filetypes = [("All", "*"),......
ce serait peut être mieux de faire:

Code :

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

1
2
3
4
5
6
from tkFileDialog import askopenfilename
.....
.....
Fichier_a_traiter = askopenfilename(filetypes = [("All", "*"),
                                                              ("Selection du fichier a traiter",
                                                               "*.fa")])

-----------------------------------------------------

Pour ce qui est du bas du code, j’ai l’impression qu’il y a un peu de confusion.

1)

Dans le code de mon message #5, ADN désigne une chaîne ADN dans laquelle on s’intéresse aux segments repérés par des couples de positions contenus dans un objet de nom res.
Le nom ADN est dû au fait que dans ce code de ce message #15, le fichier que je fais ouvrir contient uniquement une séquence ADN.

Mais à la suite de ton message #18, il faut tenir compte du fait que tu prélèves la chaîne ADN (dans laquelle tu veux effectuer les recherches et calculs) dans un fichier que moi j’ai appelé 'hg18_panTro2_rheMac2' dans lequel se trouvent 3 chaînes ADN.

Dans ce fichier, pour récupérer l’une des 3 chaînes , il faut fixer l’objet de nom voulu à une certaine valeur ( 'hg18', ou 'panTro2', ou 'rheMac2' ) et lancer une regex sur le contenu du fichier.

Il convient donc de ne pas appeler ADN ce contenu du fichier, puisque tu veux en extraire une chaîne ADN et la placer dans un objet de nom ADN.
J’ai choisi le nom plusieurs_adn pour ce contenu lu dans le fichier.

Par contre, comme l’identifiant ADN dans le code du message #15 ,
précisément dans les lignes

Code :

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

1
2
    nbtirets_a  = nbtirets_b + sum('-'==car for car in ADN[prec:a])
    nbtirets_b  = nbtirets_a + sum('-'==car for car in ADN[   a:b])

réfère à une chaîne ADN unique, celle par rapport à laquelle on fait des calculs et des corrections,
il faut changer l’identifiant sequence dans

Code :

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

sequence = re.search(voulu+'\s*((?:[AGCTN-]+\r?\n)+)',ADN).group(1).replace('\n','')

en ADN:

D'où

Code :

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

ADN = re.search(voulu+'\s*((?:[AGCTN-]+\r?\n)+)',plusieurs_adn).group(1).replace('\n','')

2)

Par ailleurs, dans la mesure où il semble que le calcul des positions corrigées n’est effectué qu’une fois dans ce bout de code, je trouve mieux de ne pas confier ces calculs à une fonction positions_corrigees() spécialement isolée, c’est un peu lourdingue, et sans fonction le code sera légèrement plus rapide.

On s’aperçoit même alors qu’on peut condenser les choses, en se passant de créer un objet position préalable. On construit directement un objet p_pc qui comporte des couples de positions avant-après (c’est le zip(positions,pc) )

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
p=partition.Partition()
p.read_Matrice(m2)  # partition des log-probabilites maximales en chaque position
 
# for s in p:
#   if s.num()==[1]:
#       print s.deb(), s.fin(), s.val()/len(s)
 
 
 
with open('hg18_panTro2_rheMac2') as f:
    plusieurs_adn = f.read()
 
voulu = 'hg18'
ADN = re.search(voulu+'\s*((?:[AGCTN-]+\r?\n)+)',plusieurs_adn).group(1).replace('\n','') 
 
res = '''s.deb(), s.fin(), s.val()/len(s)'''
 
nbtirets_b , prec = 0 , 0
for a,b,_ in map(str.split,res.splitlines()):
    a,b = int(a),int(b)
    nbtirets_a  = nbtirets_b + sum('-'==car for car in ADN[prec:a])
    nbtirets_b  = nbtirets_a + sum('-'==car for car in ADN[   a:b])
    p_pc.append( ((a,b)),a-nbtirets_a, b-nbtirets_b)) )
    prec = b
 
print ('Positions initiales'.ljust(26) + 'Positions corrigees',
       'dans ADN avec gaps '.ljust(26) + 'dans ADN sans gaps ','', sep='\n')
print ('\n'.join(repr(avant).ljust(26)+repr(apres) for avant,apres in p_pc))
 
with open("Fichier_a_traiter_logv.part","w") as f:
    f.write(str(p))
 
 
 
 
robjects.r("""source('dess.r')""")

Il reste deux problèmes.

3)

Pour ce qui est de
res = '''s.deb(), s.fin(), s.val()/len(s)'''
c’est simplement une chaîne de caractères.
Ça ne donne aucune liste ou tuple de couples de positions.
N’est ce pas ?

J'ai ecrit les positions dans un objet de nom res dans le message #15 parce qu’il fallait bien que je mette dans quelque chose les données positions que tu avais fournies.

Mais je pensais avoir compris que ces positions sont en fait obtenues dans l’objet p par les deux instructions:

Code :

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

1
2
p=partition.Partition()
p.read_Matrice(m2)

Il faudrait donc à mon avis remplacer cette ligne
res = '''s.deb(), s.fin(), s.val()/len(s)'''
par quelque chose du genre

res = traitement_de(p)
si p n’est pas directement exploitable par le code qui suit,

ou alors remplacer res par p dans
for a,b,_ in map(str.split,res.splitlines()):
si p contient directement les couples de positions

4)

Le deuxième problème est que si on calcule des positions corrigées, c’est par rapport à une chaîne ADN précise.

En faisant

Code :

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

1
2
3
4
5
with open('hg18_panTro2_rheMac2') as f:
    plusieurs_adn = f.read()
 
voulu = 'hg18'
ADN = re.search(voulu+'\s*((?:[AGCTN-]+\r?\n)+)',plusieurs_adn).group(1).replace('\n','')

on obtient cette chaîne ADN précise: c’est celle qui s’appelle hg18 dans le fichier 'hg18_panTro2_rheMac2'

Mais les deux lignes

Code :

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

1
2
p=partition.Partition()
p.read_Matrice(m2)

qui crée l’objet p dans lequel je pensais que se trouvent les positions à analyser se trouvent au dessus dans le code.

Donc , quel rapport entre le haut du code et le bas ?

----------------------------------------------

j’ai encore quelque chose à dire sur le déroulement du programme, mais j’envoie déjà ça pour clarifier les choses.

=====================================

et je me serais pas interessée à python

sauf que c est un des rare langage ou ont peux faire rapidement est assez facilement de chaine de markoff ( ce qui es tres compliqué)

meme les langage de programmation statistique comme R n 'arrivent pas a realiser ce type de HMM quelles que soient les differentes librairies

à ce point là ?!

Information bien intéressante

**asty69** · 13/06/2010, 11h57

p contient :

Code :

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

<0-38306>2:-209.826341555: XXX <38307-39910>1:-243.95249199: XXX <39911-293159>2:-574.632278147: XXX <293160-295112>1:-225.210377838: XXX <295113-315172>2:-315.362402129: XXX <315173-318010>1:-283.030517785: XXX <318011-438274>2:-449.142080783: XXX <438275-440998>1:-346.602201653: XXX <440999-602109>2:-372.776976076: XXX <602110-604635>1:-246.184074749: XXX <604636-666072>2:-630.381871521: XXX <666073-666482>1:-266.139829566: XXX <666483-687637>2:-960.739938805: XXX <687638-690666>1:-255.578192166: XXX <690667-1036629>2:-1273.95683635: XXX <1036630-1040301>1:-333.542496528: XXX <1040302-1134826>2:-435.321809412: XXX <1134827-1136571>1:-451.889781131: XXX <1136572-1180214>2:-320.441951673: XXX <1180215-1181891>1:-206.85573518: XXX <1181892-1543758>2:-765.528835972: XXX <1543759-1546672>1:-297.600891167: XXX <1546673-1704109>2:-303.267748464: ---> -9767.96566064

d'ou je selection [1]

Code :

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

1
2
3
for s in p:
   if s.num()==[1]:
       print s.deb(), s.fin(), s.val()/len(s)

d'ou je pensais que le code suivant etai suivant pour la correction des Gap

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
def positions_corrigees(ADN, positions, nbtirets_b = 0, prec = 0):
    for (a,b) in positions:
        nbtirets_a  = nbtirets_b + sum('-'==car for car in ADN[prec:a])
        nbtirets_b  = nbtirets_a + sum('-'==car for car in ADN[   a:b])
        yield (a-nbtirets_a, b-nbtirets_b)
        prec = b
 
with open('Fichier_a_traiter') as f:
    plusieurs_adn = f.read()
 
voulu = 'hg18'
ADN = re.search(voulu+'\s*((?:[AGCTN-]+\r?\n)+)',plusieurs_adn).group(1).replace('\n','') 
 
res = '''s.deb(), s.fin(), s.val()/len(s)'''
 
positions = [ (int(a),int(b)) for a,b,_ in map(str.split,res.splitlines()) ]
 
pc = positions_corrigees(ADN,positions)
 
print ('Positions initiales'.ljust(26) + 'Positions corrigees',
       'dans ADN avec gaps '.ljust(26) + 'dans ADN sans gaps ','', sep='\n')
print ('\n'.join(repr(avant).ljust(26)+repr(apres) for avant,apres in zip(positions,pc)))
f=open("Fichier_a_traiter_logv.part","w")
f.write(str(p))
f.close()

**eyquem** · 13/06/2010, 15h02

p contient :

<0-38306>2:-209.826341555: XXX <38307-39910>1:-243.95249199: XXX <39911-293159>2:-574.632278147: XXX <293160-295112>1:-225.210377838: XXX <295113-315172>2:-315.362402129: XXX <315173-318010>1:-283.030517785: XXX <318011-438274>2:-449.142080783: XXX <438275-440998>1:-346.602201653: XXX <440999-602109>2:-372.776976076: XXX <602110-604635>1:-246.184074749: XXX <604636-666072>2:-630.381871521: XXX <666073-666482>1:-266.139829566: XXX <666483-687637>2:-960.739938805: XXX <687638-690666>1:-255.578192166: XXX <690667-1036629>2:-1273.95683635: XXX <1036630-1040301>1:-333.542496528: XXX <1040302-1134826>2:-435.321809412: XXX <1134827-1136571>1:-451.889781131: XXX <1136572-1180214>2:-320.441951673: XXX <1180215-1181891>1:-206.85573518: XXX <1181892-1543758>2:-765.528835972: XXX <1543759-1546672>1:-297.600891167: XXX <1546673-1704109>2:-303.267748464: ---> -9767.96566064

Ah, on voit enfin à quoi ressemble p. Il aura fallu attendre le 22ième post.
Mais c’est quoi ce machin ?
Je vois une chaîne et je me demande quel est le rapport de cette chaîne avec une instance p=partition.Partition()
Quelle est la nature de p ?

d'où je pensais que le code suivant était pour la correction des Gap

1- tu ne veux pas corriger les gaps, tu veux corriger des positions de séquences de bases entrelardée de gaps

2- Tu n’écris des codes qu’en y pensant ?
Tu ne les fais jamais tourner ?

En ajoutant import re et en faisant tourner —>

Code :

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

1
2
3
4
Traceback (most recent call last):
........
    positions = [ (int(a),int(b)) for a,b,_ in map(str.split,res.splitlines()) ]
ValueError: invalid literal for int() with base 10: 's.deb(),'

Donc non, ça ne marche pas.
Ce n’était pas un peu prévisible ?

D’autant plus que dans mon message précédent:

3)

Pour ce qui est de
res = '''s.deb(), s.fin(), s.val()/len(s)'''
c’est simplement une chaîne de caractères.
Ça ne donne aucune liste ou tuple de couples de positions.
N’est ce pas ?

J'ai ecrit les positions dans un objet de nom res dans le message #15 parce qu’il fallait bien que je mette dans quelque chose les données positions que tu avais fournies.

Mais je pensais avoir compris que ces positions sont en fait obtenues dans l’objet p par les deux instructions:

Code :
p=partition.Partition()
p.read_Matrice(m2)Il faudrait donc à mon avis remplacer cette ligne
res = '''s.deb(), s.fin(), s.val()/len(s)'''
par quelque chose du genre

res = traitement_de(p)
si p n’est pas directement exploitable par le code qui suit,

ou alors remplacer res par p dans
for a,b,_ in map(str.split,res.splitlines()):
si p contient directement les couples de positions

Tel que j’ai compris le problème:
- d’un coté on a une chaîne ADN avec des gaps ’-’ : ADN
- d’un autre coté on a des positions au sein de CETTE chaîne ADN, qui sont contenues dans un objet p

L’objectif est de calculer les positions corrigées dans la chaîne ADN débarrassée des gaps et de les mettre dans un objet pc

Pour que tout ça ait un sens il faut que les positions initiales p correspondent à ADN.

Dans les messages précédents, on s’est occupé de l’obtention de la chaîne ADN par lecture et sélection dans un fichier contenant 3 chaînes ADN.

Et pour ma part, j’en suis resté à un code qui s’occupe d’extraire les positions p à partir d’une chaîne res (#15).

Du fait que je ne savais pas bien ce qu’il y a en amont de l’obtention de p dans ton code,
et que je ne savais pas comment est foutu p (et je ne sais toujours pas),
je pensais que tu verrais bien désormais , et mieux que moi, comment obtenir l’objet positions à partir de p.

Ce n’est manifestement pas le cas.
Donc après avoir redistribué les noms de références (= noms de “variables“) dans ton code du post #20, il faut maintenant que je suggère encore 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
15
16
17
18
19
20
21
22
23
24
25
26
import re
 
def positions_corrigees(ADN, positions, nbtirets_b = 0, prec = 0):
    for (a,b) in positions:
        nbtirets_a  = nbtirets_b + sum('-'==car for car in ADN[prec:a])
        nbtirets_b  = nbtirets_a + sum('-'==car for car in ADN[   a:b])
        yield (a-nbtirets_a, b-nbtirets_b)
        prec = b
 
 
with open('hg18_panTro2_rheMac2') as f:
    plusieurs_adn = f.read()
 
voulu = 'hg18'
ADN = re.search(voulu+'\s*((?:[AGCTN-]+\r?\n)+)',plusieurs_adn).group(1).replace('\n','') 
 
positions = [ (int(s.deb()), int(s.fin())) for s in p if s.num()==[1] ]
 
pc = positions_corrigees(ADN,positions)
 
print ('Positions initiales'.ljust(26) + 'Positions corrigees',
       'dans ADN avec gaps '.ljust(26) + 'dans ADN sans gaps ','', sep='\n')
print ('\n'.join(repr(avant).ljust(26)+repr(apres) for avant,apres in zip(positions,pc)))
f=open("Fichier_a_traiter_logv.part","w")
f.write(str(p))
f.close()

Mais ceci ne règle pas un point en suspens:

de quelle façon est assurée la nécessité que les positions contenues dans un objet p et utilisées dans le code ci-dessus correspondent bien à la valeur de l’objet ADN utilisé ?

Il ne s’agit pas de corriger des positions relatives à une chaîne ADN1 en faisant des décomptes de gaps dans une chaîne ADN2.

Remarque importante:

<0-38306>2:-209.826341555: XXX <38307-39910>1:-243.95249199: XXX <39911-293159>2:-574.632278147: XXX

Est-ce que
<0-38306>
signifie:
ça part de devant l’item 0 et ça s’arrête devant l’item 38306
comme en Python ??

Parce que si c’est le cas, il faut que le suivant commence ainsi: <38306-39910>
c’est à dire:
ça commence devant 38306 et ça s’arrête devant 39910

En effet pour
li = [0,11,222,3333,44444,555555,6666666]
alors
li[1:3] est [11,222]
car dans li[1:3] l’item 3333 de la dernière borne n’est pas compris,

de la même façon que dans
range(10) , l’item 10 de la suite d’entiers 0,1,2,3,4,5,6,7,8,9,10,11,12,13.... n’est pas compris

Heureusement puisque liste = [a,b,c,d,e] comporte 5 items et que len(liste) est 5
et que tout ça permet d’écrire simplement range(len(liste)) quand on veut les indexes 0,1,2,3,4 des éléments de liste......

compte de caractere en dynamique

Python

Discussions similaires

Partager

Partager