Discussion :

[kali38]

Bonjour,

Voila je doit réaliser un parser qui me permet de récupérer des données dans le fichier suivant:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
pin : "streck"
 dst : "smatch
 macro(AMD) {
  pin_ehq :"top";
  pin_ert :"ray";
  pin_tfg :"vft";
 macro(AGT) {
  pin_ehq :"top";
  pin_ert :"ray_ht";
  pin_tfg :"vft";
 macro(BGD) {
  pin_ehq :"top";
  pin_ert :"ray_li";
  pin_tfg :"vft";

Je cherche à extraire la chaine de caractere "pin_ert" qui correspond à chaque "macro". Par exemple pour la macro "macro(AMD)" correspond la pin_ert "ray". Ensuite pouvoir concaténer "AMD_ray".

J'ai fait un bout de programme mais sa ne marche pas:

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
def toto():
 
       Liste = ('AMD','AGT','BGD')
       ch = "pin_ert"   
       fs = open('fichier1', 'r')
       fd = open('fichier2','w')
       while 1:
        txt = fs.readline()
        if txt =='':
            break
        if ch in txt:
            fd.write(txt)
    fs.close()
    fd.close()
    returnsource.close()

Je suis débutant sur python et j'aimerais obtenir de l'aide svp...

[rambc]

Bonsoir,
peux-tu utiliser la balise code dans ton message ?

Sinon, pour ton problème, étant donné que tu dis être débutant, et que tu ne parles pas de regex, je te propose la méthode suivante :

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
 
#! /usr/bin/env python
#coding=utf-8
 
pathOfTheFile = "fichierEntree.txt"
infosFound = []
 
with open(pathOfTheFile, mode = 'r') as fileToAnalyse:
    for oneLine in fileToAnalyse:
        oneLine = oneLine.strip()
 
        if oneLine.startswith('macro'):
            id = oneLine\
                    .replace('macro', '')\
                    .replace('(', '')\
                    .replace(')', '')\
                    .replace('{', '')
 
            id = id.strip()
 
        elif oneLine.startswith('pin_ert'):
            val = oneLine\
                    .replace('pin_ert', '')\
                    .replace(':', '')\
                    .replace('"', '')\
                    .replace(';', '')
 
            val = val.strip()
 
            infosFound.append(id + '_' + val)
 
with open('sortie.txt', mode = 'w') as answer:
    answer.write('\n'.join(infosFound))

Bien entendu, on peut faire mieux.

[kali38]

Ben en fait la balise code c'est pour des fichier HTML jcrois nn.....moi je cherche à parser un fichier texte.....

par contre si j'avais dans mon fichier un truc du genre:

macro AMD
param1
param2
end macro AMD

macro BGD
param1
param2
end macro BGT
...........
............

pour recueillir le param2 je n'ai pas besoin de prendre en compte "end macro...." puisque "macro" me suffit pour me déplacer de macro en macro et de surcroit sur le param2 correspondant à la bonne macro nn??

[Pierre Maurette]

Comme très souvent pour ce genre de question, le cahier des charges est flou. Et même parfois la personne qui pose la question ajoute des contraintes au fur et à mesure que des réponses sont proposées. Remarquez, à chaque fois que j'ai mis sur papier les données d'un problème de ce type en vue de poster, le problème s'en est trouvé résolu avant de poster.
On est tenté de proposer une réponse gag, genre:

Code :

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

1
2
3
4
5
6
def resoudProbleme():
    return """AMD_ray
AGT_ray_ht
BGD_ray_li"""
 
print resoudProbleme()

Plus sérieusement le code suivant peut fonctionner dans certains cas:

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
#lines = open('fichier', 'r').readlines()
lines = """pin : "streck"
 dst : "smatch
 macro(AMD) {
  pin_ehq :"top";
  pin_ert :"ray";
  pin_tfg :"vft";
 macro(AGT) {
  pin_ehq :"top";
  pin_ert :"ray_ht";
  pin_tfg :"vft";
 macro(BGD) {
  pin_ehq :"top";
  pin_ert :"ray_li";
  pin_tfg :"vft";""".splitlines()
 
#élimination des lignes vides, facultatif
lines = [L for L in lines if len(L.strip()) != 0]
 
for keyline, valueline  in [(lines[i], lines[i+2]) for i in range(2, len(lines), 4)]:
    print keyline.split('(')[1].split(')')[0] + '_' + valueline.split('"')[1]

[nardo47]

Salut,

si tu es responsable de l'écriture du fichier, moyennant quelques modifications, tu dois pouvoir utiliser un parser existant.

Exemple avec PyYAML :

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
 
#data.yaml
pin: streck
dst: smatch
macros:
    AMD:
        pin_ehq: top
        pin_ert: ray
        pin_tfg: vft
    AGT:
        pin_ehq: top
        pin_ert: ray_ht
        pin_tfg: vft
    BGD:
        pin_ehq: top
        pin_ert: ray_li
        pin_tfg: vft

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#get_macros.py
from yaml import load
 
with open('data.yaml') as f:
    data = load(f.read())
 
macros = data['macros']
 
print macros

Regarde ce que donne la sortie de get_macros.py.

A adapter en fonction de :
1. ce que tu veux;
2. ce que tu peux modifier dans le fichier d'input.

Bien sûr, si tu ne peux pas modifier le fichier d'input, mon idée va être beaucoup moins intéressante (en même temps, une syntaxe où il y a des accolades ouvrantes sans accolades fermantes correspondantes, ça me parait louche).