help les regexp !

Version imprimable

Bonjour tout le monde!

Je me prend la tête avec les regexp sur un truc simple...

J'essaye de matcher un groupe entre <<<%% et %%>>>.
Du coup j'ai ecris :
Code:

1 2 3 4 5 6 >>>def foo(match): ... print("{}\t{}\t{}".format(match.group(0),match.group(1),match.group(2))) ... return "OK!!!!!" ... >>>l__string="debut bla bla <<<%%le match goup%%>>>bli bli fin" >>>l__reRes = re.sub(r"(.*)<<<\%\%(\w*)\%\%>>>(.*)",foo, l__string)
et ... rien. Je ne passe pas dans foo() :(
Pourquoi tant de haine ?

Salut,

Je ferais ainsi.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import re
 
PATTERN = '<<<\%\%(\w*)\%\%>>>'
 
def foo(matchobj):
    match = matchobj.group(0)
    if match == '<<<%%toto%%>>>':
        return 'TITI'
    else: return match
 
replace = lambda s : re.sub(PATTERN, foo, s)
 
print replace('123<<<%%tutu%%>>>xyz')
print replace('123<<<%%toto%%>>>xyz')

- W

17/05/2010, 10h59
pilpoil123

Merci !
Je peux effeectivement passer par là. L'idée fonctionnelle est (en simplifiée):
Dans un fichier j'ai des trucs comme "Bonjour <<<%%Dest_Name%%>>>, votre courrier du <<<%%Aff_Date%%>>>..."
Je lis la ligne du courrier et doit produire : "Bonjour M. Client, votre courrier du 12/12/12..."
du coup je dois virer les tags d'ouverture "<<<%%" et fermeture "%%>>>" et modifiant l'intérieur. En procédant par groupes :
- le groupe avant(.*)
- le groupe match(\w*)
- le groupe apres(.*)
il me suffisait (dans foo) de retourner qqchose comme :

Code:

match.group(0)+dico[match.group(1)]+match.group(2)

Cela dit, merci. Ta solution me permet d'avancer mais je ne comprend pas pourquoi la mienne ne fonctionne pas :(
Son interet etant que foo n'a pas a connaitre les tags utilisés et devient générique

Salut,

Citation:

L'idée fonctionnelle est (en simplifiée):
Dans un fichier j'ai des trucs comme "Bonjour <<<%%Dest_Name%%>>>, votre courrier du <<<%%Aff_Date%%>>>...

Je lis la ligne du courrier et doit produire : "Bonjour M. Client, votre courrier du 12/12/12..."
du coup je dois virer les tags d'ouverture "<<<%%" et fermeture "%%>>>" et modifiant l'intérieur

Ci dessous je remplace les tags de la forme <<<%%TOKEN%%>>> par $(TOKEN)s, i.e. par des tags que le formatteur de chaines de caractères sait reconnaitre. Le 'texte' soumis est donc transformé en 'template'.

=> Il serait peut être astucieux de voir si vous ne pourriez pas construire vos 'tags' sous une forme 'acceptable' par un gestionnaire de template 'normal'. Ce qui éviterait de remplacer des tags par des tags.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 import re PATTERN = '<<<\%\%(\w*)\%\%>>>' def foo(matchobj): token = matchobj.group(1) return '%%(%s)s' % token replace = lambda s : re.sub(PATTERN, foo, s) test_string = "<<<%%Dest_Name%%>>>, votre courrier du <<<%%Aff_Date%%>>>..." template = replace(test_string) Dest_Name = 'Mr.Toto' Aff_Date = '16 Mai 2010' print template % vars()
- W

En fait j'utilise deja les string template. J'ai décris mon probleme de façon simplifié (pour alléger le propos :) ) mais dans sa globalité je dois traiter (à l'interieur de mes tags) des expressions plus complexes qu'une simple substitution de variable. Je dois pouvoir aussi accepter un appel de fonction python.

Mon fichier input contient :
1 <<<%%Paris le ${Aujourdhui},%%>>>
2 Comme convenu ...
3 <<<%%${Dest_Name}, votre courrier du ${Aff_Date} est traité dans ...%%>>>
4 ...
5 et nous avons le plaisir de vous informer que les produits :
6 <<<%%__liste_produit('${NCommand}')%%>>>
7 vous serons livrés comme prévu.
8 ...
Dans les lignes 1, 3 et 6 la substition s'applique d'abord par la methode substitute de la classe Template sur la base d'un dico pour les clefs qui figurent entre {}. Cela permet de "tagger" le fichier de façon simplifié (marquage de ligne), sauf si le tag contient un appel de fonction (comme __liste_produit à la ligne 6) où là il borde l'appel.
Du coup mon code (python 3.1) :
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 from string import Template def __TemplateReplaceCallback(i__match): global g__TMPLVars l__tmpl = Template(i__match.group(1)) l__buffer = l__tmpl.substitute(**g__TMPLVars) l__buffer = eval(l__buffer, locals(), globals()) return i__match.group(0)+l__buffer+i__match.group(2); def instanciateTemplate(i__templateFile, i__instanceFile): l__regExp = "(.*)<<<\%\%(\w*)\%\%>>>(.*)" l__file_tmpl = open(i__templateFile,"r") if(l__file_tmpl): l__file_out = open(i__instanceFile,"w") if(l__file_out): l__lines = l__file_tmpl.readlines() for line in l__lines : line = re.sub(l__regExp, __TemplateReplaceCallback, line) l__file_out.write(line) l__file_out.close() l__file_tmpl.close()
Dans la fonction __TemplateReplaceCallback "l__tmpl.substitute(**g__TMPLVars)" traite les substitution de variable et "eval(l__buffer, locals(), globals())" effectue l'appel de fonction si present.

wouala donc pourquoi je dois traiter par regExp. Je dois faire en sorte que la fonction __TemplateReplaceCallback ne connaisse rien du tag et reste generique.

Wouala vous savez tout !
Donc, ma question: "Pourquoi l__regExp = "(.*)<<<\%\%(\w*)\%\%>>>(.*)" ne match pas?" :(

Merci de votre aide...

Salut,
j'ai lu en diagonale, mais ça serait pas plutôt :

Code:

print("{}\t{}\t{}".format(match.group(1),match.group(2),match.group(3)))

que tu voudrais ?

Code:

match.group(0)

te renvoi l'ensemble de la chaîne matchante.

Chez moi :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 >>> f = "123<<<%%tutu%%>>>xyz" >>> g = re.match(r"(.*)<<<%%(\w*)%%>>>(.*)", f) >>> g.group(1) '123' >>> g.group(2) 'tutu' >>> g.group(3) 'xyz' >>> g.group(0) '123<<<%%tutu%%>>>xyz' >>> g.group() '123<<<%%tutu%%>>>xyz'

17/05/2010, 13h06
pilpoil123

heuu oui peut être, mais là n'est pas la question.
Ma question porte sur le pattern pour matcher le contenu entre <<<%% et %%>>>

:)

cela dit dans un pattern comme "(.?)<<<\%\%(\w+)\%\%>>>(.?)" il existe 3 groupes et donc le group(0) concerne la partie avant le pattern et group(1) concerne le contenu qui m'interesse

Merci.
17/05/2010, 13h58
wiztricks

Salut,

Citation:

Ma question porte sur le pattern pour matcher le contenu entre <<<%% et %%>>>

Pour ce qui est de re.sub, le pattern est '<<<\%\%(\w*)\%\%>>>' et çà vous retournera group(0) l'ensemble de et group(1) l'intérieur.

Citation:

cela dit dans un pattern comme "(.?)<<<\%\%(\w+)\%\%>>>(.?)" il existe 3 groupes et donc le group(0) concerne la partie avant le pattern et group(1) concerne le contenu qui m'interesse

Pour re.match peut être, mais pour re.sub?
- W
PS: et je persiste à penser que des gestionnaires de templates 'normaux' font déjà cela très bien et qu'il serait préférable de s'aligner la dessus à la génération de vos fichiers.
17/05/2010, 14h04
dahtah
Citation:

Envoyé par pilpoil123

cela dit dans un pattern comme "(.?)<<<\%\%(\w+)\%\%>>>(.?)" il existe 3 groupes et donc le group(0) concerne la partie avant le pattern et group(1) concerne le contenu qui m'interesse

Non, justement. group(0) te renvoi l'ensemble de la chaîne matchante. Les groupes commencent ensuite à 1. group(2) sera la partie qui t'intéresse.

Citation:

Envoyé par pilpoil123

Ma question porte sur le pattern pour matcher le contenu entre <<<%% et %%>>>

Suffit d'enlever les parenthèses groupantes:
Code:

1 2 .?<<<\%\%(\w+)\%\%>>>.?
Là, group(1) renverra la partie attendue.
Bon courage

A wiztricks : Je suis d'accord pour ta remarque concernant les gestionnaires de template (preuve je les utilise) mais a ma connaissance ils ne gèrent pas l'appel de fonction et m'obligent donc à continuer sur la base d'une recherche de tag et de l'interpretation specifique d'un contenu type "code python"

A dahtah : Biin j'ai beau essayer ca ne marche pas comme tu dis:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 >>> def foo(match): ... print("{}\t{}".format(match.group(0),match.group(1))) ... return "OK!!!!!" ... >>> >>> l__string="debut bla bla <<<%%le match group%%>>>bli bli fin" >>> >>> l__reRes = re.sub(r".*<<<\%\%(\w+)\%\%>>>.*",foo, l__string) >>> l__reRes 'debut bla bla <<<%%le match group%%>>>bli bli fin' >>> l__reRes = re.sub(r".?<<<\%\%(\w+)\%\%>>>.?",foo, l__string) >>> l__reRes 'debut bla bla <<<%%le match group%%>>>bli bli fin' >>> l__reRes = re.sub(".?<<<\%\%(\w+)\%\%>>>.?",foo, l__string) >>> l__reRes 'debut bla bla <<<%%le match group%%>>>bli bli fin' >>>
Dans ces trois cas, à aucun moment je ne passe dans foo !! :(
:arf:

Re-Salut,

Avec le PATTERN = '.*<<<\%\%(\w*)\%\%>>>.*', mon machin marche aussi bien qu'avec '<<<\%\%(\w*)\%\%>>>' _sur l'exemple_.
Et je dis bien _sur l'exemple_, car pour remplacer toutes les '<<<\%\%(\w*)\%\%>>>', par autre chose, je ne vois pas pourquoi il faudrait s'occuper de ce qu'il peut y avoir entre.
Un gestionnaire de template qui ne sait pas gérer les appels de fonction ne s'appelle par un gestionnaire de template: regardez Mako par exemple, il fait cela très bien.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 import re PATTERN = '.*<<<\%\%(\w*)\%\%>>>.*' def foo(matchobj): print '0 = ', matchobj.group(0) print '1 = ', matchobj.group(1) token = matchobj.group(1) return '%%(%s)s' % token replace = lambda s : re.sub(PATTERN, foo, s) test_string = "blah bla <<<%%Dest_Name%%>>> x y z" template = replace(test_string) Dest_Name = 'Mr.Toto' Aff_Date = '16 Mai 2010' print template % vars() print 'done'
- W

Citation:

Envoyé par pilpoil123

A dahtah : Biin j'ai beau essayer ca ne marche pas comme tu dis:
Dans ces trois cas, à aucun moment je ne passe dans foo !!

C'est normal, tu n'utilises pas sub() de la bonne manière. Voici un exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #!/usr/bin/bash # -*- coding: utf-8 -*- import re def foo(match): print "%s\t%s" % (match.group(0), match.group(1)) return "OK!!!!!" l__string = "debut bla bla <<<%%le match group%%>>>bli bli fin" p = re.compile(r".*<<<%%(.*)%%>>>.*") print p.sub(foo, l__string)
Par contre, c'est un usage un peu détourné de sub(). Son utilisation première est de faire des substitutions.

Bon ca y est !!!
zetes trop forts.

Alors en mixant et cherchant j'arrive à :
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 import re from string import Template g__TMPLVars = {'Dest_Name':'Mr.Toto', 'Aff_Date':'16 Mai 2010', 'Param':'OKeeeeeee'} PATTERN = '(.*)<<<\%\%(.+)\%\%>>>(.*)' def foo2(matchobj): global g__TMPLVars token = matchobj.group(2) template = Template(token) buffer = template.substitute(**g__TMPLVars) try: buffer = eval(buffer, locals(), globals()) except: # string contains text => no evaluation pass return matchobj.group(1) + buffer + matchobj.group(3) def foo3(param): row = param+'\n' return row*3 test_string = """ blah bla <<<%% ${Dest_Name}, Paris le ${Aff_Date} %%>>> <<<%%foo3("${Param}")%%>>> """ template = re.sub(PATTERN, foo2, test_string) print(template)
Et c'est exactement ce que je voulais faire :P
Je voulais utiliser les string template et donc utiliser la notation ${nomVar} dans mon fichier. Hors les caractères ${} ne sont plus "matché" par (\w*) et tu avais raison (dahtah) le bon pattern contenais (.?) ou plus precisement (.+) (je dois avoir au moins un car...). Ensuite je souhaitais réaliser la substitution dans la callback sans qu'elle ne connaisse le pattern. Du coup je crée les groupes avant et apres (les groupes 1 et 3). je traite le groupe 2 et renvoie la concatenation du tout. :ccool:
le try catch me permet d'evaluer le contenu du groupe 2 et d'envoyer le code python si il en contient (foo3).
wouala...
testez vous verrez...
Merci a tout les deux !

PS : Je n'ai pas compris ton allusion à Mako. Kesako ? Ca m'interesse
PS2 : j'avance sur l'interface MySQL / Python 3.0 que tu m'as proposé je reviens bientôt avec mes critiques...

17/05/2010, 18h55
miawaw

Citation:

Envoyé par pilpoil123

PS : Je n'ai pas compris ton allusion à Mako. Kesako ? Ca m'interesse

j'adore ce site recherche python Mako :mouarf:

désolé, je déconne... (je sais pas ce que c'est Mako non plus :roll:)

enfin, tu as quand même le lien vers la page.
17/05/2010, 19h40
wiztricks

Salut

Citation:

PS : Je n'ai pas compris ton allusion à Mako. Kesako ? Ca m'interesse

Mako est un gestionnaire de template écrit en Python qui contredit:

Citation:

les gestionnaires de template (preuve je les utilise) mais a ma connaissance ils ne gèrent pas l'appel de fonction et m'obligent donc à continuer sur la base d'une recherche de tag et de l'interpretation specifique d'un contenu type "code python"

Il est inclus par défaut dans Pylons et TurboGears2 machins avec lesquels je bosse en ce moment.
-W
17/05/2010, 20h57
pilpoil123

ok ok...
quand je dis : "je les utilise" il faut entendre "j'utilise celui qui est fourni par python" : string.Template.

Je vais jeter un oeil à Mako. Je pense que tu as vu ce que cherchais à faire. In fine je trouve le traitement assez (trop) long. Pres de 30 sec pour traiter un fichier de 6500 lignes avec une vingtaine de substitution.

Si j'imagine qu'il permet des operations de substitutions avancés, penses-tu que ce genre d'outils apporte un plus en temps de traitement ?
17/05/2010, 22h42
wiztricks

Salut,

Citation:

Si j'imagine qu'il permet des operations de substitutions avancés, penses-tu que ce genre d'outils apporte un plus en temps de traitement ?

Il est certain que cela réduit la quantité de code à écrire et donc, on peut espérer livrer plus vite, moins cher et moins risqué - et donc un salaire moyen plus élevé pour le prestataire.

Pour ce qui est 'temps de traitement', avec un domaine assez étroit on doit 'potentiellement' pouvoir optimiser et aller plus vite. Mais comme c'est risqué et que les résultats sont incertains, le salaire moyen 'baisse'.

Ce que vous pourriez déjà faire c'est générer un template "consommable"
dès le premier coup, çà devrait déjà réduire le temps par presque moitié.

Citation:

In fine je trouve le traitement assez (trop) long. Pres de 30 sec pour traiter un fichier de 6500 lignes avec une vingtaine de substitution.

D'après ce que je comprends, un template va être utilisé avec plusieurs dictionnaires.

Plutôt que de vouloir faire la transformation en one shot, faites en 2 étapes:
Appliquez:
1 - les re.sub pour normaliser le template d'entrée,
2 - les dicos au template normalisé - issu de (1) -.
3 - Comme vous avez dissocié les 2, parallélisez plusieurs étapes (2).
Trichez!
Je suis quasiment sûr que vous avez un ensemble de courrier types qui bougent peu... avant (1) appliquez leur un MD5 pour retrouver les précédentes transformations.
- W
PS: Il devrait y avoir des gestionnaires de templates en C++ mais j'ai pas cherché.