parser un fichier et recuperer des valeurs que l'on stocke dans un tableau

Version imprimable

1 pièce(s) jointe(s)

Bonjour à tous , cela fait un bon moment que je me démèle avec ce parseur j'ai essayé plusieurs approches , dictionnaires , etc ..j'avance à un rythme d'un escargot anémié :( je suis perdue avec les boucles for !aussi
mon fichier est en piece jointe et mon format de sortie aussi ,
voici le debut de mon code mais cela ne sort pas trop ce dont j'ai besoin... reelement !!! pouaahhh

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
fichier = open('sumo.txt', "r")
lignes = fichier.readlines ()
 
for uneLigne in lignes:
    champs=uneLigne.split()
    #print champs
    if len(champs)>0 and champs[0]== "guanidinium":
             Guan=champs[2]
    elif len(champs)>0 and champs[0]== "hyd_ali":
	     hyd=champs[2]
 
    elif len(champs)>0 and champs [0] == "hyd_ali ALA" :
	     hyd=champs [2]
 
    elif len (champs) > 0 and champs [0] =="hyd_ali VAL" :
	     hyd=champs [2]		
    elif len (champs) > 0 and champs [0] == "bb" :
	     Bb = champs [3]
 
 
    if uneLigne[0]=="-":
        print "guanidinium ARG:"+Guan
        print "hyd_ali ARG :"+hyd[ATTACH]141626[/ATTACH]
	print "hyd_ali ALA:" + hyd
        print "hyd_ali VAL:" + hyd
	print "backbone:" + Bb

Salut,

Je pense que ceci sera plus proche de ce que tu attend

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
with open('sumo.txt', "r") as inf:
    for line in inf:
        # enlever le retour ligne
        line = line.strip()
        if not line:
            # ligne vide
            continue
        champs = line.split(' ')
        if not champs:
            # on ignore
            continue
        if champs[0] == "guanidinium":
            Guan = champs[2]
        elif champs[0] == "hyd_ali":
            # verifier les deux directement
            if champs[1] in ("ALA", "VAL"):
                hyd = champs[3]
            else:
                hyd = champs[2]
        elif champs[0] == "bb":
            Bb = champs[3]

La suite, je ne sais pas parce que ton code n'est pas indenté.

La balise code est le symbole dièse # dans la barre d'outils d'édition.

merci pour ton aide vinsS tu m'as aider a y voir 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 fichier = open('sumo.txt', "r") lignes = fichier.readlines () for uneLigne in lignes: champs=uneLigne.split() #print champs if len(champs)>0 and champs[0]== "guanidinium": Guan=champs[2] elif len(champs)>0 and champs[0]== "hyd_ali": hyd=champs[2] elif len(champs)>0 and champs [0] == "hyd_ali ALA" : hyd=champs [2] elif len (champs) > 0 and champs [0] =="hyd_ali VAL" : hyd=champs [2] elif len (champs) > 0 and champs [0] == "bb" : Bb = champs [3] if uneLigne[0]=="-": print "guanidinium ARG:"+Guan print "hyd_ali ARG :"+hydPièce jointe 141626 print "hyd_ali ALA:" + hyd print "hyd_ali VAL:" + hyd print "backbone:" + Bb
le soucis avec mon code est qu'il me recupere des valeurs et qu'ils les repetent exemple de la sortie qui n'est pas tout a fait comme mon fichier de depart , et puis afin de stocker toutes ses valeurs dans mon tableau excel ,,,, je crois qu'il me reste du chemin a faire et j'ai l'impresion de tourner en rond sans trouver d'issus possible , a chaque fois que je tente une nouvelle approche soit ce n'est pas la bonne encore une fois !! ou alors je me perd encore plus qu'au debut et je reviens au point de depart !!!!!!

sortie de mon code :
guanidinium ARG:426
hyd_ali ARG :VAL
backbone:647
hyd_ali ALA:VAL
hyd_ali VAL:VAL
guanidinium ARG:426
hyd_ali ARG :650
backbone:647
hyd_ali ALA:650
hyd_ali VAL:650
guanidinium ARG:426
hyd_ali ARG :650
backbone:647
hyd_ali ALA:650
hyd_ali VAL:650
guanidinium ARG:426
hyd_ali ARG :650
backbone:647
hyd_ali ALA:650

j'ai tenter en effet en utilisant un dictionnaire , je ne suis pas du genre à me decourager facilement , cependant , c'est claire qu'il me faut une aide , ou plusieurs avis pour en sortire une idée coherente et qui fonctionnerait en fin , !!! pour ce tableau !!!!!
voici mon code en utilisant les dictionnaires

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
 
 
fichier = open('sumo.txt', "r")   
filin=fichier.readlines
 
for ligne in fichier.readlines():
 
 
	print(ligne.rstrip())
 
#les differents dictionnaires avec des cles similaires
 
dico1= {"1QMF guanidinium ARG" :(426)  ,"1QMF hydali ARG" :( 426) , "1QMF bb GLY " : (647)  , "1QMF hydali ALA" :( 650), "1QMF hydali VAL" :(662)},
 
dico2= {" 1X7Z guanidinium ARG" :(220) ,"1X7Z bb GLY" : (192 )  , " 1X7Z hydali ALA ":(195) }
 
dico3 ={ "2ZI6 guanidinium ARG" : (2192) , "2ZI6 bb ALA" :(2031)  ,"2ZI6 hydali ARG" :( 2188) }
 
dico4 ={"3A9E guanidinium ARG"  :(321) ,  "3A9E  bb ALA" : ( 332) , "3A9E" "hydali ALA" :(276) }
 
dico5 = {"2NT7 guanidinium ARG" : (254) , "2NT7 bb GLY" : (647) , "2NT7 hydali MET" :(258)  }
 
dico6={"3U2V guanidinium  ARG" :( 77),  "3U2V bb GLY" :(215) ,"3U2V hydali LEU" :(214) }
 
 
dico7 ={"2F6Z guanidinium ARG" : (254 ) , "2F6Z bb GLY" :( 259 ) ,"2F6Z hydali MET " : (650) }
 
 
mes_dicos = [dico1, dico2 , dico3 , dico4 , dico5 , dico6, dico7 ]
 
 
for dico in mes_dicos:
	for value in dico :
		print dico

la aussi çeci m'imprime 3 fois a chaque fois les lignes souhaitées !!! au lieu d'une seule fois seulement

Je suppose même que le premier dico est printé cinq fois, non ?

ton code:

Code:

1
2
3
4
for dico in mes_dicos:    # pour chaque dico dans la liste
	for value in dico :   # pour chaque clé du dico
		print dico       # print le dico entier

Ce n'est pas plutôt ceci que tu veux faire:

Code:

1
2
3
4
5
 
for dico in mes_dicos:
    for key, value in dico.items():
        print value,
    print

Ca donne ceci:

Code:

1
2
3
4
5
6
7
8
 
647 650 426 662 426
192 195 220
2188 2192 2031
321 332 276
647 254 258
214 215 77
259 254 650

31/03/2014, 14h51
they_are_numbers

oui parfaitement je voudrai recuperer les valeurs aussi , seulement ça me met une erreur

AttributeError: 'tuple' object has no attribute 'items' quand j'utilise ce que vous m'avez conseillé je ne comprends pas pourquoi ???,
31/03/2014, 15h36
Viand0x
Bonjour,

lorsque tu as fais:

Code:

dico1= {"1QMF guanidinium ARG" :(426) ,"1QMF hydali ARG" :( 426) , "1QMF bb GLY " : (647) , "1QMF hydali ALA" :( 650), "1QMF hydali VAL" :(662)},

tu as laissé une virgule (mis en rouge). Cette virgule va automatiquement spécifier que ton objet dico1 est de type "tuple" alors que c'est bien un dictionnaire que tu voulais. Or comme un tuple n'a pas de méthode "items()" tu reçois un message d'erreur.

Ainsi si tu fais:
Code:

1 2 3 a = 1, b = "salut", c = [1],
tu obtiendra toujours des "tuples". C'est juste une erreur d'étourderie...

:oops:ohhhhhh ! ça marche enfin , !!!! cette maudite virgule , à croire qu'on a le nez tellement colé à l'ecran qu'on y vois plus les erreurs , cependant pourquoi mes valeurs ne sortent elles pas dans le meme ordre que dans les dictionnaires auriez vous une explication à cela ?????,,, ????:roll: y'a t il un moyen toute fois , de les avoir exactement sous le meme ordre
cet exactement mon but final a partir de mon fichier initiale , et j'ai patogé un long moment avant de rassembler tout les elements et morceaux de mon peuzzle afin d'etablir etape par etape cequ'il faut pour arriver a ce tableau !!!!!!

1QMF guan ARG 426 hydali ARG 426 bb GLY 647 hydali ALA 650 hydali VAL662

1X7Z guanARG220 bbGLY 192 hydali ALA 195

2ZI6 guani ARG 2192 bbALA332 hydaliALA276

3A9E guani ARG 321 bbALA 332 hydaliALA 276

la moitié du chemin est fait reste à raccorder le tout ,
encore , gracias

31/03/2014, 16h08
VinsS
Ben non, les dictionnaires ne sont pas ordonnés, du moins par défaut, ce n'est pas utile non plus puisque le but est d'accéder aux valeurs par leur clé.

Par contre, ce que tu montres:
Code:

1 2 3 4 1QMF guan ARG 426 hydali ARG 426 bb GLY 647 hydali ALA 650 hydali ALA 1X7Z guanARG220 bbGLY 192 hydali ALA 195 2ZI6 guani ARG 2192 bbALA332 hydaliALA276
c'est le boxon, comment arrives-tu à ce résultat ?
31/03/2014, 16h19
they_are_numbers

j'ai fait le tableau a l'aide du tableau ici presenté sur la page , le faire avec un code python est la lourde tache sur laquelle je travail , enfin lourde non , mais tres enigmatiques par moments , en effet je dois arriver a cette sortie dans un output ,
peut etre que ma maniere de proceder n'est pas correcte ou est insinifiante , je perciste ! je pérciste .... auriez vous une hypothése a me suggérer ???:roll::(
03/04/2014, 12h04
Tryph

OrderedDict

salut,

Si tu as réellement besoin d'avoir un dictionnaire ordonné, tu peux utiliser un OrderedDict.

Merci pour l'information , Tryph mais je ne crains que ce soit une mauvaise piste , j'ai revu mon code , et réaranger pleins d'erreurs , ceci m'a sortis des listes ,
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
37
38
39
40
41
42
43
 
import string 
 
 
# script basique. Il recherche dans chaque ligne une chaine bien definie puis renvoie cette ligne
 
fichier = open("sumo.txt" , "r" )
for ligne in fichier:
  if "guanidinium" in ligne:
    line = ligne.split()
    print line
  elif "hyd_ali" in ligne:
    line = ligne.split()
    print line
  elif "bb" in ligne:
    line = ligne.split()
    print line
 
fichier.close()
 
# script avec un compteur pour recuperer les lignes en double pour chaque mot cle
 
compt = 0
fichier = open("sumo.txt" , "r" )
for ligne in fichier:
  if compt == 1 and ligne:
    line = ligne.split()
    print line
    compt = 0
  else:
    compt = 0
  if "guanidinium" in ligne:
    line = ligne.split()
    print line
    compt = 1
  elif "hyd_ali" in ligne:
    line = ligne.split()
    print line
    compt = 1
  elif "bb" in ligne:
    line = ligne.split()
    print line
    compt = 1

ça me sort enfin exactement ce que je veux , mais j'ai besoin de recuperer ces caracteres et les transformer en string puis les ranger dans un tableau , et j'avoue ..........je suis complétement perdue ...

03/04/2014, 13h50
Tryph

faudrait nous donner un exemple de fichier sumo.txt pour y voir plus clair.
ou simplement coller son contenu dans une réponse.
03/04/2014, 14h26
they_are_numbers

1 pièce(s) jointe(s)

Pièce jointe 142039
03/04/2014, 14h33
they_are_numbers

1 pièce(s) jointe(s)

voici le fichier sumo , que je viens de poster et avec mon code j'arrive à obtenir ceci ,

sortie du code : resultat donc mon but finale si cela pourrai ce faire à l'aide de listes ou ....... le moyens m'echape encore , d'en faire un tableau ou je pourrai prendre uniquement a chaque fois les 3 premiers champs ,
dans mon tableau sur la premiere ligne , c'est la molecule reference : 'guanidinium', 'ARG', '426[ comme je l'ai afficher dans le fichier excel ..... l'algorithme m'echappe totallement j'ai beau me creuser les meninges .... ca me donne du fil a retordre ....!!!!

['guanidinium', 'ARG', '426', 'A', '{1.0}', '0.00', '0.000']
['ARG', '426', 'A']

['hyd_ali', '[cd]', 'ARG', '426', 'A', '{0.6}', '0.00', '0.000']
['[cd]', 'ARG', '426', 'A']

['bb', '[backbone]', 'GLY', '647', 'A', '{0.5}', '0.00', '0.000']
['[backbone]', 'GLY', '647', 'A']
['hyd_ali', 'ALA', '650', 'A', '{0.6}', '0.00', '0.000']
['ALA', '650', 'A']
['hyd_ali', '[cbcg2]', 'VAL', '662', 'A', '{0.6}', '0.00', '0.000']
['[cbcg2]', 'VAL', '662', 'A']
['guanidinium', 'ARG', '426', 'A', '{1.0}', '0.21', '0.046']
['ARG', '220', 'A']
['bb', '[backbone]', 'GLY', '647', 'A', '{0.5}', '0.16', '0.051']
['[backbone]', 'GLY', '192', 'A']
03/04/2014, 16h18
Tryph

le format du fichier d'entrée se prête pas vraiment à une analyse simple. personellement, j'aurais tendance à utiliser des expressions régulières pour faire ça, mais je suis peut être un peu trop amateur d'expression régulière et pour un débutant (ce qui semble être ton cas) c'est pas si simple.

juste par curiosité, ça sort de quoi ce genre de fichiers? d'un logiciel? y a pas moyen d'exporter le même genre d'info sous un format un peu plus facile à analyser (genre XML ou autre)?

Tu peux nous en dire un peu plus sur ce que représente ce fichier texte: à quoi correspondent et comment sont organisées les données qu'il contient.
parce que en regardant le fichier d'entrée et le tableau que tu attends, je me dis que ce que tu veux exactement n'est pas clair.

si tu peux nous l'expliquer en termes simples sans parler d'algo, ça peut nous aider à t'aider.

je proposerai bien ma version de ce que je pense que tu veux, mais je suis pas certain que ça soit un gain de temps ;)
03/04/2014, 16h47
they_are_numbers

merci Tryph de bien vouloir m'aider et essayer de comprendre mon probléme , il sort en effet d'un logiciel comme la pdb (protein data bank) , et à partir de ce tableau je dois encore le traiter en html .......

je vais essayé de décortiquer le probléme comme je l'ai compris , il y'a plusieurs bloc dans mon fichier , séparés par des tirets , le challenge !!!! si j'y arrive (et ma téte est en jeu .:(...) ,est de faire a chaque fois une comparaison entre les diffrentes molecules a chaque debut des blocs qui sont , dans le bon ordre 1QMF , 1X7Z , 2ZI6 , 3A9E ,2NT7 , 3U2V 2FZ et pour etre encore plus claire 1QMf est la molecule reference avec laquelle je veux comparer les valeurs des autres molecules

par exemple 1QMF guanidinium ARG 426 je la compare avec 1X7Z je trouve guanidinium ARG 220 , alors il me colle cette valeur dans le tableau , pour 2ZI6 guanidinium ARG CA SERA 2192 ANSI DE SUITE ......
il n'ya pas parcontre hyd ali ARG426 dans la plus part des autres molecules , uniquement dans cette 1QMF , alors il laisse la case vide du tableau pareil pour hydali VAL662

il s'agit je pense de comparer les lignes entre elles mais je me suis inventé tout un monde parsemé d'ambuches .... manque de logique de recul par rapport ... a tout cela ...

j'espére avoir un peu eclairer votre lantérne afin que tu puisez me préter main forte ... :calim2::calim2::calim2:

je me dis : ne jamais se decourager , plus on se trompe plus on des chances d'y arriver !
04/04/2014, 10h33
Tryph

c'est quoi ton niveau en développement en général et plus particulièrement en Python?

parce que je peux éventuellement t'orienter vers une solution à base d'expressions régulières puisque personne ne propose mieux, mais c'est pas forcément très conviviale et ça fait parfois un peu peur aux néophites. et si tu n'y comprends rien, on sera pas beaucoup plus avancés.
04/04/2014, 10h46
they_are_numbers

Bonjour , Tryph , et bien je ne suis pas une programmeuse , trés spécialisée mais mon domaine est la bioinformatique depuis pas trés longtemps , donc ,j'utilise python pour chercher des solutions , j'arrive à faire et à resoudre des exercices de tout genre avec le livre de poulin et patrick fuchs et PIERRE POULain , cependant , parfois il y'a des quaks !!!!!! je suis preneuse de ce que tu pourrais m'apporter et me proposer , si ca arrive a resoudre ou a ne se resque m'aider a avancer , et toutefois si je n'arrive pas a comprendre je me redirigerai vers toi , pour des explications , :roll:

c'est ce que je pensais pour le niveau en programmation.

du coup je te propose un script qui stocke les données extraites dans un dictionnaire dont les clefs sont les codes des molécules (1QMF, 2NT7, etc...).
à chaque clef est associée une liste d'"éléments" (je connais pas le vocabulaire qui va bien).
chaque "élément" est lui même une liste contenant:

un nom (guanidinium, bb ou hyd_ali)
éventuellement le texte qu'on peut trouver entre crochets (cd, backbone, cb, etc...)
le code de 3 lettres (ARG, GLY, ALA, etc...)
le code entre 2 et4 chiffres (77, 647, 2188, etc...)
la lettre seule (A, B)

une fois affiché dans un format lisible, ça donne ça pour le fichier que tu as fourni:

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
1QMF
	['guanidinium', '', 'ARG', '426', 'A']
	['hyd_ali', 'cd', 'ARG', '426', 'A']
	['bb', 'backbone', 'GLY', '647', 'A']
	['hyd_ali', '', 'ALA', '650', 'A']
	['hyd_ali', 'cbcg2', 'VAL', '662', 'A']
2NT7
	['guanidinium', '', 'ARG', '254', 'A']
	['bb', 'backbone', 'GLY', '259', 'A']
	['hyd_ali', 'cb', 'MET', '258', 'A']
2F6Z
	['guanidinium', '', 'ARG', '254', 'A']
	['bb', 'backbone', 'GLY', '259', 'A']
	['hyd_ali', 'cb', 'MET', '258', 'A']
3U2V
	['guanidinium', '', 'ARG', '77', 'B']
	['bb', 'backbone', 'GLY', '215', 'B']
	['hyd_ali', 'cbcg', 'LEU', '214', 'B']
3A9E
	['guanidinium', '', 'ARG', '321', 'A']
	['bb', 'backbone', 'ALA', '332', 'A']
	['hyd_ali', '', 'ALA', '276', 'A']
2ZI6
	['guanidinium', '', 'ARG', '2192', 'B']
	['bb', 'backbone', 'ALA', '2031', 'B']
	['hyd_ali', 'cb', 'ARG', '2188', 'B']
1X7Z
	['guanidinium', '', 'ARG', '220', 'A']
	['bb', 'backbone', 'GLY', '192', 'A']
	['hyd_ali', '', 'ALA', '195', 'A']

le script est basé sur ce que j'ai compris du besoin, et je suis pas encore certain que c'est bien que tu veux mais ça fera une base pour discuter.
c'est probablement pas la façon la plus élégante de faire, mais vu la présentation des infos dans le fichier d'entrée je crois qu'il faut pas trop faire le difficile.
pour les explications dont tu aurais besoin je t'invite à te tourner en priorité vers:

ces pages répondront certainement bien mieux que moi à nombre de questions que tu pourrais te poser. tu pourras éventuellement ensuite revenir poser des questions plus précises sur que tu as du mal à comprendre dans la doc.

pour commencer, les commentaires dans le code te fourniront les premières indications sur ce que fait le script:

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
# -*- coding:utf-8 -*-
# import du module d'expressions régulières
import re
 
# définition des expressions régulières qui vont servir à extraire les info
# -> cette expression régulière sert à identifier le séparateur de "blocs"
#    (au moins 2 tirets)
separator_re = re.compile(r"--+")
# -> celle ci sert à extraire les codes des molécules d'un bloc
#    (4 chiffres ou caractères en majuscule)
codes_re = re.compile(r"([0-9A-Z]{4}):")
# -> celle ci sert à extraire toutes les autres info utiles d'un bloc
#    - un nom parmi un liste donnée
#    - un texte quelconque entre crochets
#    - une suite d'au moins 1 caratère(s) majuscule
#    - une suite d'au moins 1 chiffre(s)
#    - un caractère seul
#    - <de nouveau les 4 type de données précédantes>
data_re = re.compile(r"((?:guanidinium)|(?:hyd_ali)|(?:bb)) +"
                     "(?:\[(.*)\])? +"
                     "([A-Z]+) +"
                     "([0-9]+) +"
                     "([A-Z]).+\n +"
                     "(?:\[(.*)\])? +"
                     "([A-Z]+) +"
                     "([0-9]+) +"
                     "([A-Z])")
 
# lecture du fichier
content = ""
with open("sumo.txt", "r") as file_:
    content = file_.read()
 
# séparation du fichier en blocs et stockage des bloc dans une liste "blocs"
blocs = re.split(separator_re, content)
 
 
# création d'un dictionnaire pour contenir les infos
dict = {}
# pour chaque bloc...
for bloc in blocs:
    temp = []
    # extraction des codes des molécules et des infos
    codes = re.findall(codes_re, bloc)
    infos = re.findall(data_re, bloc)
    # pour chaque groupe d'info extraite...
    for info in infos:
        elem = []
        # création d'une liste contenant l'info de la première molécule
        first = list(info[1:5])
        first.insert(0, info[0])
        # création d'une liste contenant l'info de la deuxième molécule
        second = list(info[5:])
        second.insert(0, info[0])
        # ajout de l'info des 2 molécule dans une liste
        elem.append(first)
        elem.append(second)
        # ajout de ce couple d'info à une liste temporaire
        temp.append(elem)
 
# à ce stade, on a toutes les infos et on va les ranger un peu mieux
 
    # pour chaque molécule du bloc
    for index in xrange(2):
        # si le dictionnaire ne contient pas déjà les infos de la molécule
        if codes[index] not in dict:
            # création d'une entrée dans le dictionnaire qui associe une liste
            # (vide pour le moment) au code de la molécule.
            dict[codes[index]] = []
            # pour chaque élément dans la liste temporaire
            for elem in temp:
                # on ajoute a la liste de la molécule l'info qui lui correspond
                dict[codes[index]].append(elem[index])
 
 
# affichage du dictionnaire
print dict
print "-" * 80
# affichage plus lisible du dictionnaire
for key, val in dict.iteritems():
    print key
    for elem in val:
        print "\t{}".format(elem)

04/04/2014, 12h49
wiztricks

Salut,

Vous pourriez récupérer la base de données des protéines sous son format XML... Mais si vous débutez c'est compliqué.
Jetez un œil au projet Python ProDy.
Il fait déjà pas mal de chose pour vous - au sens métier -.

Je vous dit çà car un schéma de données pour les protéines assez riche pour pouvoir la visualiser en 3D et faire des opérations dessus est un objet informatique compliqué.
Si vous débutez en programmation et que vous voulez apprendre c'est une bonne chose.
Python est un bon langage pour apprendre a programmer.
Ceci dit, il faut vous donner le temps d'apprendre les bases.
Et accepter d'oublier un peu votre métier pendant un certain temps pour accepter d'en apprendre un autre.

- W
04/04/2014, 16h17
they_are_numbers

Un grand merci à toi ... j'avais expérimenté au tout déput la piste des expressions réguliéres mais ...j'avais du mal , a y parvenir c'est parfait le code fonctionne trés bien , il faudrait juste que j'intégre un output en CSV pour afficher ce que j'ai obtenu en format tableau
normallement chaque element de la liste obtenu séparer par ";" ou une "," et par la suite je pourrait ouvrir le fichier csv dansmon tableau .....

ce qui me reste à faire à partir de ce que j'ai obtenu , la liste des dictionnaires , faire un code python , à l'aide d'une boucle ( peut etre )pour les classer dans un tableur ordoné , et encore merci de votre aide à tous !!:)
04/04/2014, 18h04
Tryph

cool.

pour formater ton output en CSV, tu trouveras peut être utile la fonction str.format().
quoi qu'il existe peut être en python un module spécifique pour gérer le format CSV.

Ceci dit, tu devrais porter attention à ce que dit wiztricks car dans le fond, il a raison sur toute la ligne.
le faire un script qui marchote pour lire des données dans un fichier quelconque à base d'expression régulière, àa dépanne mais c'est clairement pas pérenne.
suffit que le format de ton fichier d'entrée change un peu pour que le script fasse n'importe quoi et ne soit plus utilisable, et les expressions régulières, ça a beau être pratique et puissant, ça n'en reste pas moins illisible et difficilement maintenable.

ça serait beaucoup plus facile de faire des lectures dans un fichier XML et si ton logiciel le permet, faut déjà voir de ce coté.
et j'approuve aussi ce qu'il dit a propos de l'apprentissage des bases ;)

1QMF	guan ARG 426	hydali ARG 426	bb GLY 647	hydali ALA 650	hydali VAL662
1X7Z	guanARG220		bbGLY 192	hydali ALA 195
2ZI6	guani ARG 2192		bbALA332	hydaliALA276
3A9E	guani ARG 321		bbALA 332	hydaliALA 276