Discussion :

[Mydriaze]

je n'arrive pas à contouner une difficulté à la noix...

J 'ai une liste : Liste_a de noms : chaine_a de maximum 50 caracteres que je compare une une autre liste : liste_b de noms : chaine_b
Pour savoir si le nom_a de la premiere liste appartient à un des nom_b de la liste_b
par exemple : dans la liste_a j'ai dupond et je cherche si j'ai c'ette chaine dans la liste_b
je veux retrouver tous les "dupond", "dupond_la_joie", "dupond_machin"...
(Désolée pour les duponds, s'il y en a qui lisent)
or dans la liste_a j'ai des chaines qui ont été tronquées pour faire maximum 50 caractères
Donc dans la liste _a j'ai des chaines style :
"Dupond ( de 'trifouillis' les oisillons en"
avec une parenthese isolée , eventuellement des cotes...
pour les comparer aux noms_b de la liste_b je fais

Code :

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

1
2
3
def format_nom (nom_maudit):
    nom_a_formate = re.sub("\'", "\\\'", nom_a_formate)
    return nom_a _formate

qd je fais boucler le programme avec des :

Code :

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

1
2
if re.search(format(nom_a), format(nom_b)):
                print nom_a, nom_b

J'ai cette erreur : sre_constants.error: unbalanced parenthesis

dès qu'un nom avec une parenthese apparait.

Alors apres j'ai modifié en :

Code :

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

1
2
3
4
5
def format_nom (nom_maudit):
    nom_a_formate = re.sub("\(", "\\\(", nom_a_maudit)
    nom_a_formate = re.sub("\)", "\\\)", nom_a_formate)
    nom_a_formate = re.sub("\'", "\\\'", nom_a_formate)
    return nom_a _formate

Pas mieux...
Je l'ai tourné ds tous les sens je n'arrive pas à le débloquer...

Quelqu'un aurait-il une idee pour me dépanner s'il vous plait?

[eyquem]

Là tu parles de Liste_a, chaine_a, liste_b, chaine_b (soit dit en passant Liste_a a une majuscule, liste_b n'en a pas ; c'est voulu ? Python considère liste_b et Liste_b comme deux choses différentes) :

Code :

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

J 'ai une liste : Liste_a de noms : chaine_a de maximum 50 caracteres que je compare une une autre liste : liste_b de noms : chaine_b

Puis là tu parles de nom_a et de nom_b:

Code :

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

Pour savoir si le nom_a de la premiere liste appartient à un des nom_b de la liste_b

Que doit-on comprendre ?



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

Que cherches tu à faire ? Regarder si des nom_a extraits de strings chaine_a de Liste_a sont dans une chaine_b de Liste_b ?

Ou regarder si une chaine_a de Liste_a se trouve dans Liste_b ?




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

Code :

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

1
2
3
def format_nom (nom_maudit):
    nom_a_formate = re.sub("\'", "\\\'", nom_a_formate)
    return nom_a _formate

Ce ne serait pas plutôt ? :

Code :

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

1
2
3
def format_nom (nom_a_formate):
    nom_a_formate = re.sub("\'", "\\\'", nom_a_formate)
    return nom_a _formate

Il faudrait enlever l'espace en trop dans return nom_a _formate



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

Et aussi, il faudrait écrire, je pense:

Code :

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

1
2
if re.search(format_nom(nom_a), format_nom(nom_b)):
                print nom_a, nom_b

Je pense que l'erreur sre_constants.error: unbalanced parenthesis
est levée quand le programme rencontre le deuxième parenthèse ( dans
if re.search(format(nom_a), format(nom_b)):
Comme il ne connait pas format comme étant une fonction, il attend après format une parenthèse fermante, qui n'y est pas....



--------------------
"'" et "\'" sont des écritures considérées identiquement par Python.
-------------------------------------------------------------------------------------
Pourquoi utiliser sub() et non pas replace() ?
-------------------------------------------------------------------------------------

Code :

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

1
2
a = 'rou'
b = 'un chat roux aux yeux verts'

Le résultat de a in b est True.
Tu pourrais te passer du recours a des regex je pense.

[eyquem]

J'ai essayé le code suivant:

Code :

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

1
2
3
4
5
6
7
8
9
import re
def format_nom (nom_a_formate):
    nom_a_formate = re.sub("\'", "\\\'", nom_a_formate)
    return nom_a_formate
 
nom_a = "Dupond"
nom_b = "Dupond ( de 'trifouillis' les oisillons en" 
if re.search(format(nom_a), format(nom_b)):
    print nom_a, nom_b

Ça affiche une erreur
NameError: name 'format' is not defined
et non pas
sre_constants.error: unbalanced parenthesis

J'ai finalement compris que sre_constants.error concerne les regex.
Mais je n'identifie pas la source du problème.

Peux-tu donner les 2 codes (fonctionnels) qui produisent l'erreur, avec deux strings pour lesquels se produit l'erreur, s'il te plait.
Parce que quand j'essaie des codes écrit à partir de tes bouts de code (corrigés), ça marche.
En fait je n'ai pas le départ de ton problème.

[Mydriaze]

Aaaaah! zuuuuteu! J'vous ai ecrit des bétises!
Excusez moi!
Merci pour vos réponses!!!!

Donc, effectivement, c'est une fonction format_nom() partout, liste_a et liste_b...
J'ai voulu retranscrire en changeant les noms pour que ce soit plus simple et je n'ai pas fait attention aux majuscules...
Correction :

ça, ça marche :

Code :

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

1
2
3
def format_nom (nom_maudit):
    nom_a_formate = re.sub("\'", "\\\'", nom_maudit)
    return nom_a _formate

Il voit quand il y a une cote dans mes chaines et ça ne le derange pas.

Code :

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

1
2
3
 
if re.search(format_nom(nom_a), format_nom(nom_b)):
     print nom_a, nom_b

En fait , ça vient bien du module Re mon probleme.

Je veux savoir si une chaine est presente dans une autre.
Et qd la premiere chaine contient une parenthese ouverte (même probleme avec un criochet ouvert) il me sort ce message d'erreur...

sre_constants.error: unbalanced parenthesis

alors j'ai cru qu'il fallait rajouter des antislashs mais ça fait pareil...

Code :

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

1
2
3
4
5
6
 
def format_nom (nom_maudit):
    nom_a_formate = re.sub("\(", "\\\(", nom_a_maudit)
    nom_a_formate = re.sub("\)", "\\\)", nom_a_formate)
    nom_a_formate = re.sub("\'", "\\\'", nom_a_formate)
    return nom_a _formate

J'utise Re.search car la suite de mon programme se fait en fonction de true ou false que renvoie le search .

Si
nom_a = "Dupond ( de 'trifouillis' les oisillons en"
je veux pouvoir le retrouver dans :
nom_b = "Dupond ( de 'trifouillis' les oisillons en Provence)"

Du coup, comme j'etais pressée, j'ai supprimé les parentheses et les crochets en attendant de trouver mieux...

J'ai fait :

Code :

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

1
2
3
4
5
6
7
8
 
def format_nom (nom_maudit):
    nom_a_formate = re.sub("\(", "", nom_a_maudit)
    nom_a_formate = re.sub("\)", "", nom_a_formate)
    nom_a_formate = re.sub("\[", "", nom_a_formate)
    nom_a_formate = re.sub("\]", "", nom_a_formate)
    nom_a_formate = re.sub("\'", "\\\'", nom_a_formate)
    return nom_a _formate

Là ça marche... mais on doit pouvoir tenir compte des parentheses et des crochets je pense, non?

[bredelet]

Les parenthèses ont une signification spéciale dans les expressions régulières, tout comme bon nombre de caractères... Je crois que cette ligne est une Mauvaise Idée

Code :

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

re.search(format_nom(nom_a), format_nom(nom_b))

[Mydriaze]

oui, mais c'est bizare qu'on ne puisse pas l'echapper...

On devrait qd meme pouvoir chercher une chaine qui contient des parentheses dans une autre quand meême ...

[pierjean]

Bonjour,

Code :

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

1
2
3
4
def format_nom (nom_maudit):
    nom_a_formate = re.sub("\(", "\(", nom_maudit)
    nom_a_formate = re.sub("\)", "\)", nom_a_formate)
    return nom_a_formate

[eyquem]

C'est ce que je viens de comprendre il y a juste 10 minutes

Essayer le code:

Code :

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

1
2
import re
print re.sub("\(", "\(", "Dupond (Louis")

Le résultat est

Dupond \(Louis


Reste à savoir pourquoi....
Soit on tombe sur cette écriture par hasard et il faut chercher ensuite l'explication.
Soit on comprend d'abord un truc et on en déduit l'écriture. C'est ce que j'ai fait, j'y ai passé un sacré moment.

Qu'en est il pour vous ? Je suis curieux de savoir comment tout un chacun comprend ça: remplacer quelque chose par soi-même et ça change quand même..... Python est d'une subtilité (complication ?) qui me sidère sur ce coup là.

[Mydriaze]

Arrrrrrrrrrrrrrrrrgh!

Je viens de voir que la solution etait dans la premiere réponse...
La derniere ligne...

effectivement on peut utiliser in sans les regex....

pffffffff keske j'suis nulle Bouhouhouhouuuuuuuuuuuuuuuuuu


Merci beaucoup pour votre aide.
J'ai crois que j'ai testé tout pour les antislash soit ça ne passe pas le re.search, soit ça ne donne pas le bon résultat parce que ça ajoute trop d'antislash devant la parenthèse...
J'abandonne...

Le in marche ...

MERCI À TOUS !!!!


J'abandonne pour les regex...
Je fais kwa? Je mets [Résolu] qd même ?

[eyquem]

Tu n'es pas nulle, on est tous passés au moins une fois par là: prendre une voie et s'apercevoir qu'il y a en fait plus simple. C'est souvent le cas avec Python. Pour prendre tout de suite la bonne voie, il faudrait connaître très bien toutes les fonctions de Python se rapportant à son problème et en avoir une vue suffisamment globale. Ça ne vient que peu à peu.


"J'abandonne... "
C'est dommage, parce que je crois que c'est en persévérant à comprendre parfaitement quelque chose qu'on avance.
Après coup, ma première réponse d'hier ne me plaisait pas et je suis revenu sur le problème: je me suis alors aperçu que je n'avais rien compris , et en creusant je suis parvenu à comprendre un truc essentiel ce matin concernant les regex.
Tu ne devrais pas lacher le morceau. Il faut arriver à comprendre entièrement un sujet. Soit pas du tout, soit entièrement, mais les idées confuses ce n'est pas bon. Ça donne plus tard des programmeurs à la bidouille C'est mon avis.

C'est pour ça que je te demande ce que tu veux dire en écrivant
"j'ai testé tout pour les antislash soit ça passe pas le re.search soit ça donne pas le bon resultat parceque ça ajoute trop d'antislash devant la parenthèse..."
Je ne comprends pas, "soit ça passe pas le re.search soit ça donne pas le bon resultat", ça veut dire quoi ?

[eyquem]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
import re
 
def form(x):
    return re.sub('\(','\(',x)
 
print "Dupond ("
print form("Dupond (")
print
 
if re.search( form("Dupond (") , "Dupond (Louis Adrien)" ):
    print 'Dupond (   est dans le texte'

C'est simplement une utilisation de ce qu'a indiqué pierjean. Parfois ça sert de bien lire les réponses. Comme moi dans ma première réponse.

[bredelet]

C'est ce que je viens de comprendre il y a juste 10 minutes

Essayer le code:

Code :

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

1
2
import re
print re.sub("\(", "\(", "Dupond (Louis")

Le résultat est

Dupond \(Louis


Reste à savoir pourquoi....

C'est simple: tu utilises l'expression régulière "\(" qui correspond à une parenthèse ouvrante "(". (il faut un caractère d'échappement "\" car les parenthèses ont un sens spécial dans une regexp)
Tu substitue cette expression avec "\(": deux caractères, "\" et "(".
Donc logiquement "Dupond (Louis" ===> "Dupond \(Louis"

[Mydriaze]

Bon oki, je laisse le post ouvert alors...

Oui, ça m'interesse d'avoir le fin mot de l'histoire, mais je ne veux pas non plus prendre le temps des gens alors que je ne suis plus bloquée comme hier...

J'ai testé jusqu'à 13 antislashs.
soit j'avais le
sre_constants.error: unbalanced parenthesis

soit ça ne trouvait pas la bonne reponse :

Voilà à peu près ce que les traces donnaient :

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
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
>>> def format_nom (nom_maudit):
...     nom = re.sub("\(", "", nom_maudit)
...     nom = re.sub("\)", "", nom)
...     nom = re.sub("\[", "", nom)
...     nom = re.sub("\]", "", nom)
...     return nom
... 
>>> nom_a = "Dupont(de 'trifouillis' les oisillons en"
>>> nom_b = "Dupont(de 'trifouillis' les oisillons en provence)"
>>> import re
>>> if re.search (format_nom(nom_a) , format_nom (nom_b)):
...  print "yaisss"
... else:
...  print "no :("
... 
yaisss

>>> def format_nom (nom_maudit):
...     nom = re.sub("\(", "\\(", nom_maudit)
...     nom = re.sub("\)", "\\)", nom)
...     nom = re.sub("\[", "\\[", nom)
...     nom = re.sub("\]", "\\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom (nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
no :(
>>> format_nom(nom_a)
'Dupont\\(de 'trifouillis' les oisillons en'
>>> format_nom(nom_b)
'Dupont\\(de 'trifouillis' les oisillons en provence\\)'
>>> def format_nom (nom_maudit):
...     nom = re.sub("\(", "\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\)", nom)
...     nom = re.sub("\[", "\\\[", nom)
...     nom = re.sub("\]", "\\\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
no :(
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\(de 'trifouillis' les oisillons en provence\)
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\\)", nom)
...     nom = re.sub("\[", "\\\\[", nom)
...     nom = re.sub("\]", "\\\\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
no :(
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\(de 'trifouillis' les oisillons en provence\)
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\\\)", nom)
...     nom = re.sub("\[", "\\\\\[", nom)
...     nom = re.sub("\]", "\\\\\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
 Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.5/re.py", line 134, in search
    return _compile(pattern, flags).search(string)
  File "/usr/lib/python2.5/re.py", line 233, in _compile
    raise error, v # invalid expression
sre_constants.error: unbalanced parenthesis
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\\(de 'trifouillis' les oisillons en provence\\)
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\\\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\\\\)", nom)
...     nom = re.sub("\[", "\\\\\\[", nom)
...     nom = re.sub("\]", "\\\\\\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
 Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.5/re.py", line 134, in search
    return _compile(pattern, flags).search(string)
  File "/usr/lib/python2.5/re.py", line 233, in _compile
    raise error, v # invalid expression
sre_constants.error: unbalanced parenthesis

>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\\(de 'trifouillis' les oisillons en provence\\)
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\\\\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\\\\\)", nom)
...     nom = re.sub("\[", "\\\\\\\[", nom)
...     nom = re.sub("\]", "\\\\\\\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
 Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.5/re.py", line 134, in search
    return _compile(pattern, flags).search(string)
  File "/usr/lib/python2.5/re.py", line 233, in _compile
    raise error, v # invalid expression
sre_constants.error: unbalanced parenthesis

>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\\(de 'trifouillis' les oisillons en provence\\)
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\\\\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\\\\\)", nom)
...     nom = re.sub("\[", "\\\\\\\[", nom)
...     nom = re.sub("\]", "\\\\\\\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
 Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.5/re.py", line 134, in search
    return _compile(pattern, flags).search(string)
  File "/usr/lib/python2.5/re.py", line 233, in _compile
    raise error, v # invalid expression
sre_constants.error: unbalanced parenthesis
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\\(de 'trifouillis' les oisillons en provence\\)

>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\\\\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\\\\\)", nom)
...     nom = re.sub("\[", "\\\\\\\[", nom)
...     nom = re.sub("\]", "\\\\\\\]", nom)
...     return nom
... 

>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
 Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.5/re.py", line 134, in search
    return _compile(pattern, flags).search(string)
  File "/usr/lib/python2.5/re.py", line 233, in _compile
    raise error, v # invalid expression
sre_constants.error: unbalanced parenthesis

>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\\(de 'trifouillis' les oisillons en provence\\)
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\\\\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\\\\\)", nom)
...     nom = re.sub("\[", "\\\\\\\[", nom)
...     nom = re.sub("\]", "\\\\\\\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
 Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.5/re.py", line 134, in search
    return _compile(pattern, flags).search(string)
  File "/usr/lib/python2.5/re.py", line 233, in _compile
    raise error, v # invalid expression
sre_constants.error: unbalanced parenthesis

>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\\(de 'trifouillis' les oisillons en provence\\)
>>> 
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\\\\\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\\\\\\)", nom)
...     nom = re.sub("\[", "\\\\\\\\[", nom)
...     nom = re.sub("\]", "\\\\\\\\]", nom)
...     return nom
... 
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\\(de 'trifouillis' les oisillons en provence\\)
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\\\\\\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\\\\\\\)", nom)
...     nom = re.sub("\[", "\\\\\\\\\[", nom)
...     nom = re.sub("\]", "\\\\\\\\\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
no :(
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\\\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\\\(de 'trifouillis' les oisillons en provence\\\)

>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\\\\\\\\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\\\\\\\\\)", nom)
...     nom = re.sub("\[", "\\\\\\\\\\\[", nom)
...     nom = re.sub("\]", "\\\\\\\\\\\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
no :(
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\\\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\\\(de 'trifouillis' les oisillons en provence\\\)
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\\\\\\\\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\\\\\\\\\)", nom)
...     nom = re.sub("\[", "\\\\\\\\\\\[", nom)
...     nom = re.sub("\]", "\\\\\\\\\\\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
no :(
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\\\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\\\(de 'trifouillis' les oisillons en provence\\\)
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\\\\\\\\\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\\\\\\\\\\)", nom)
...     nom = re.sub("\[", "\\\\\\\\\\\\[", nom)
...     nom = re.sub("\]", "\\\\\\\\\\\\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
no :(
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\\\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\\\(de 'trifouillis' les oisillons en provence\\\)
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\\\\\\\\\\\\(", nom_maudit)
...     nom = re.sub("\)", "\\\\\\\\\\\\\)", nom)
...     nom = re.sub("\[", "\\\\\\\\\\\\\[", nom)
...     nom = re.sub("\]", "\\\\\\\\\\\\\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
...
 Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.5/re.py", line 134, in search
    return _compile(pattern, flags).search(string)
  File "/usr/lib/python2.5/re.py", line 233, in _compile
    raise error, v # invalid expression
sre_constants.error: unbalanced parenthesis
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\\\\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\\\\(de 'trifouillis' les oisillons en provence\\\\)
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\\(", nom_maudit)
...     nom = re.sub("\)", "\\)", nom)
...     nom = re.sub("\[", "\[", nom)
...     nom = re.sub("\]", "\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
no :(
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\(de 'trifouillis' les oisillons en provence\)
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\(", nom_maudit)
...     nom = re.sub("\)", "\)", nom)
...     nom = re.sub("\[", "\[", nom)
...     nom = re.sub("\]", "\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
no :(
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\(de 'trifouillis' les oisillons en \)
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\(de 'trifouillis' les oisillons en provence\)
>>> def format_nom(nom_maudit):
...     nom = re.sub("\(", "\(", nom_maudit)
...     nom = re.sub("\)", "\)", nom)
...     nom = re.sub("\[", "\[", nom)
...     nom = re.sub("\]", "\]", nom)
...     return nom
... 
>>> if re.search (format_nom(nom_a) , format_nom(nom_b)):
...     print "yaisss"
... else:
...     print "no :("
... 
no :(
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\(de 'trifouillis' les oisillons en provence\)
>>> if nom_a in nom_b:
...     print "yaisss"
... else:
...     print "no :("
... 
yaisss 
>>> print "format_nom(nom_a) = " , format_nom(nom_a)
format_nom(nom_a) =  Dupont\(de 'trifouillis' les oisillons en
>>> print "format_nom(nom_b) = " , format_nom(nom_b)
format_nom(nom_b) =  Dupont\(de 'trifouillis' les oisillons en provence\)

[Mydriaze]

ça y est ! j'ai compris le probleme!

C'est dans Re.search je "formatais" la deuxieme chaine aussi et il ne faut pas!!!

.. pas évident de voir ça par contre...

Et bien Merci beaucoup pour le coup de main!!

[eyquem]

mais:
- pourquoi ne faut-il pas formater le deuxième argument alors qu'il faut formater le premier ?
- et quelle est la cause precise de l'erreur sre_constants.error: unbalanced parenthesis qui apparait sinon ?

Pour répondre à ces questions, il faut avoir compris une petite chose, quasiment un détail, mais qui est essentielle, et que j'ai comprise grâce à au problème de Mydriase.

Vous me direz que j'ai découvert que l'herbe pousse du bas vers le haut et que l'eau mouille. OK
Mais depuis un an que j'utilise un peu les regex, je ne l'avais pas comprise et ça troublait ma compréhension. Je faisais comme Mydriase: je balançais des backslash au pifomètre et je regardais le résultat.

Dans la réponse de bredelet, je suis étonné qu'il ne s'étonne pas qu'on puisse écrire

Code :

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

print re.sub("\(", "\(", "Dupond (Louis")

où "\(" "remplace" "\(",
alors qu'on doit écrire

Code :

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

mod = 'Dupond (Louis)'.replace('(','\(')

Y a un truc derrière tout ça....

[bredelet]

Dans la réponse de bredelet, je suis étonné qu'il ne s'étonne pas qu'on puisse écrire

Code :

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

print re.sub("\(", "\(", "Dupond (Louis")

où "\(" "remplace" "\(",
alors qu'on doit écrire

Code :

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

mod = 'Dupond (Louis)'.replace('(','\(')

Y a un truc derrière tout ça....

replace est une fonction des chaînes de caractères, ça remplace une chaîne avec une chaîne. Rien de spécial là.

Par contre re.sub appartient au module des expressions régulières. Sa définition est:

Code :

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

sub(pattern, repl, string[, count])

Où pattern est une expression régulière. De ce fait il lui faut un antislash devant une parenthèse pour matcher un caractère parenthèse. ("\(" remplace "(")

Si ton pattern contient "[", "?", "+", "*" etc il faut aussi un antislash devant.

[eyquem]

C'est bien ça. Je veux dire que c'est bien ce que j'ai compris.
Je ne l'avais pas saisi jusqu'à aujourd'hui

C'est à dire qu'une regex n'est pas une chaine de caractères.
Dans x.replace(A,B) effectivement A et B sont des strings.
Dans sub(pattern, repl, string[, count]), pattern est une regex.

Ça parait évident on fois qu'on l'a compris, et les difficultés qu'on avait avant paraissent plus compréhensibles.

En fait il faut toujours être bien conscient de la nature de ce dont on s'occupe
et avoir le réflexe de se demander est-ce une regex ou est-ce un string ?

Excuse moi, mais quand tu écris
"replace est une fonction des chaînes de caractères, ça remplace une chaîne avec une chaîne." ,
ça ne permet pas de comprendre qu'il faut avoir ce réflexe.
En effet tu ne parles alors que de x dans x.replace(A,B) et du résultat renvoyé par la fonction. mais ce qui est important c'est que A et B sont des strings, alors que dans sub(pattern, repl, string[, count]), pattern est une regex.

Or dans un string , le caractère ? n'est pas un caractère spécial qui demande à être échappé, tandis que dans une regex il l'est.
Le problème de Mydriase était de plus obscurci par le fait qu'elle avait écrit une instruction avec search() du module re

Code :

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

if re.search(format_nom(nom_a), format_nom(nom_b)):

comportant une fonction format_nom() avec sub() du module re,

Code :

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

nom_a_formate = re.sub("\'", "\\\'", nom_maudit)

soit deux fonctions re imbriquées.

Je donne peut être l'impression de couper les cheveux en 4 mais quand je vois les difficultés que semblent rencontrer beaucoup avec les regex, je pense qu'il n'est pas inutile de se faire les idées bien claires sur ce sujet.
Si les choses étaient simples, Mydriase aurait obtenu une réponse correcte rapidement.

[Mydriaze]

Bonjour à tous,

Merci beaucoup pour votre aide!!! C'est vrai que c'est important de comprendre ça! Et j'avoue que sans ses explications je serais passée complètement à côté...

Merci pour tout