Discussion :

[rambc]

Quelle expression régulière permet de transformer "Bla bla 1 , 2 bla bla" vers "Bla bla 1,2 bla bla" ?
Le code suivant ne marche que si la virgule est suivie d'au moins un chiffre. Pourquoi ? Que faire ?

Code :

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

1
2
3
4
5
6
7
import re
def remplace(m):
    return m.group(0).replace(' ', '')
 
rx = re.compile(r'\d[0-9, ]+\d')
txt = "Bla  bla 1,     bla bla"
print rx.sub(remplace, txt)

Merci.

[tyrtamos]

Bonjour,

Si j'ai bien compris, on cherche le motif suivant:

- une virgule
- avec à sa gauche entre 0 et plusieurs espaces
- et à sa droite entre 0 et plusieurs espaces

Dans ce cas: motif = r"[ ]{0,}[,][ ]{0,}"
et la chaine de remplacement: rempl = r","

Ce qui donne:

print re.sub(motif, rempl, "Bla bla 1 , bla bla")
Bla bla 1,bla bla

Tyrtamos

[rambc]

En fait mon problème serait de compléter la méthode proposée dans la discussion suivante .

Par exemple, je voudrais remplacer
"du texte avec des espaces 12 3 45 6 encore du texte avec des espaces 1 4 , 5 ou aussi 5 6 , et voilà"
par
"du texte avec des espaces 123456 encore du texte avec des espaces 14,5 ou aussi 56, et voilà".

En fait en combinant les deux méthodes, cela marche. Existe-t-il un moyen de "réunir" les deux méthodes en une seule (pour ne faire qu'un seul appel à la méthode re) ?

PS : merci tyrtamos.

[tyrtamos]

Voilà une solution qui marche:

Code :

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

1
2
3
4
5
 
chaine = u"du texte avec des espaces 12 3 45 6 encore du texte avec des espaces 1 4 , 5 ou aussi 5 6 ,  et voilà"
 
motif = re.compile(r"([0-9,])[ ]+([0-9,])")
chaine = "".join(motif.split("".join(motif.split(chaine))))

Ce qui donne bien:

Code :

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

1
2
3
 
print chaine
du texte avec des espaces 123456 encore du texte avec des espaces 14,5 ou aussi 56,  et voilà

En fait, le problème que j'ai rencontré est que les recherches se font sans recouvrement. C'est à dire que "1 2 3 4 5" doivent être traité 2 fois!

Tyrtamos

[rambc]

Nickel. De nouveau merci tyrtamos.

PS : si tu as 5min à perdre tyrtamos, peux-tu m'expliquer rapidement comment cela marche ? Une référence lisible sur le sujet me suffirait (je n'ai pas encore trouvé le temps d'apprendre à utiliser des expressions régulières mais celle proposée est claire à décoder, c'est plus l'histoire des join qui me parait très obscure...).

[tyrtamos]

Pour l'expression avec join, il suffit de décomposer les instructions.

On part de:

Code :

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

1
2
3
 
chaine = "du texte avec des espaces 12 3 45 6 encore du texte avec des espaces 1 4 , 5 ou aussi 5 6 ,  et voilà"
motif = re.compile(r"([0-9,])[ ]+([0-9,])")

Et on a en premier:

Code :

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

1
2
3
4
 
x1 = motif.split(chaine)
print x1
['du texte avec des espaces 1', '2', '3', ' 4', '5', '6', ' encore du texte avec des espaces ', '1', '4', ' ', ',', '5', ' ou aussi ', '5', '6', ' ,  et voilà']

split() du module "re" fait la même chose que split() pour les chaines, mais utilise le motif comme critère de coupure. On voit bien que certains espaces sont éliminés, mais pas tous. Parce qu'il ne peut pas y avoir de recouvrement entre les motifs trouvés successivement: quand le motif a trouvé "2 3", il ne peut plus trouver "3 4" parce que le "3" serait commun.

Code :

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

1
2
3
4
 
x2 = "".join(x1)
print x2
du texte avec des espaces 123 456 encore du texte avec des espaces 14 ,5 ou aussi 56 ,  et voilà

join() ne fait que de reconstruire la chaine à partir de la liste x1. On voit que tous les espaces n'ont pas été traités. A la limite, si on avait "1 2 3 4 5 6", on aurait traité un espace sur 2.

Code :

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

1
2
3
4
 
x3 = motif.split(x2)
print x3
['du texte avec des espaces 12', '3', '4', '56 encore du texte avec des espaces 1', '4', ',', '5 ou aussi 5', '6', ',', '  et voilà']

Et donc, on recommence pour traiter les espaces qui restent!

Code :

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

1
2
3
4
 
x4 = "".join(x3)
print x4
du texte avec des espaces 123456 encore du texte avec des espaces 14,5 ou aussi 56,  et voilà

Et c'est terminé!

Ok?

Tyrtamos

[eyquem]

Rassure toi, rambc, j'ai passé 2 heures hier soir à décortiquer le programme de tyrtamos pour comprendre la regex puis le procédé avec join.
Malgré la grande admiration que j'ai pour ceux qui maitrisent à ce point les subtilités de Python, j'ai trouvé que c'est trop compliqué et aprés moult efforts je suis arrivé au programme ci-dessous.

Je n'ai pas réussi à trouver une regex qui ne prenne pas le dernier blanc aprés toute tranche recherchée, d'où le rstrip() pour éliminer tous les blancs à droite d'une tranche trouvée dans tranches1, et d'où l'obligation de faire une liste tranches2 à partir de la première.
Ça correspond au même problème que celui de tyrtamos sauf que ça ne concerne que le/les deniers blancs après une tranche (une tranche = [\d ,]+ ).
Si quelqu'un trouve une regex qui évite ceci, ce sera mieux.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
import re
 
chaine = "du texte avec des espaces 12 3 45 6 encore du texte avec des espaces 1 4 , 5 ou aussi 5 6 , et voilà"
p = re.compile("\d[\d, ]+")
 
tranches1= re.findall(p,chaine)
tranches2 = [tr.rstrip() for tr in tranches1]
 
for x in tranches2:
    chaine = chaine.replace(x,x.replace(' ',''))
 
print chaine

[tyrtamos]

Et voilà plus simple que ma précédente solution:

Code :

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

1
2
3
4
5
6
7
 
chaine = "du texte avec des espaces 12 3 45 6 encore du texte avec des espaces 1 4 , 5 ou aussi 5 6 ,  et voilà"
 
motif = r"([0-9,])[ ]+([0-9,])"
rempl = r"\1\2"
chaine = re.sub(motif, rempl, chaine)
chaine = re.sub(motif, rempl, chaine)

Ou en une seule ligne:

Code :

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

1
2
 
chaine = re.sub(motif, rempl, re.sub(motif, rempl, chaine))

2 particularités:

=> les \1 et \2 de rempl sont remplacés par les caractères effectivement trouvés de chaque côté de l'espace du motif. Cela marche un peu comme des noms de variable. Ils correspondent aux parenthèses de motif que je n'ai mises que pour ça.

=> le re.sub doit être appliqué 2 fois à cause de l'absence de recouvrement de la recherche par motif.

Tyrtamos

[rambc]

Merci beaucoup pour les infos même si je n'ai pas trop pigé cette histoire de \1\2.

[tyrtamos]

Merci beaucoup pour les infos même si je n'ai pas trop pigé cette histoire de \1\2.

Grâce aux parenthèses:

le "\1" de rempl sera remplacé par le caractère trouvé dans le 1er "([0-9,])" de motif

Et le "\2" de rempl sera remplacé par le caractère trouvé dans le 2ème "([0-9,])" de motif

En fait, quand on met des parenthèses, on identifie un groupe auquel, dans certaines circonstances, on peut faire référence par les "\n". Ces groupes sont numérotés à partir de 1, puis 2, etc..

Au 1er traitement, la 1ère sous-chaine qui colle avec le motif, c'est "2 3".
Dans ce cas, le "\1" sera remplacé par "2", et le "\2" sera remplacé par "3". Donc, la sous-chaine "2 3" trouvée sera remplacée par "23". Etc... CQFD.

Tyrtamos

[rambc]

OK. Là c'est compris. Merci pour ta patience.

[eyquem]

J'ai réussi à trouver une regex qui permet de trouver les tranches [chiffre virgule blanc] dans lesquelles enlever les blancs en 1 seul fois, sans avoir à faire de rstrip() pour enlever le blanc à droite:

Code :

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

1
2
3
4
5
6
7
8
9
import re
 
chaine = "du texte avec des espaces 12 3 45 6 encore 12, 7, 86 35 2 90, 57,du texte avec 14 , 5des espaces 1 4 , 5 ou aussi 5 6 , et voilà"
p = re.compile("\d[\d, ]*[\d,]")
 
for x in re.findall(p,chaine):
    chaine = chaine.replace(x,x.replace(' ',''))
 
print chaine

Par contre, je n'arrive pas à trouver comment mettre cette solution sous forme chaine = re.sub("\d[\d, ]*[\d,]",fonction,chaine)

Le programme suivant me sort l'erreur
Traceback (most recent call last):
File "E:/Python/Essais Python/m rambc.py", line 13, in <module>
chaine = re.sub("\d[\d, ]*[\d,]",f,chaine)
File "C:\Python25\lib\re.py", line 142, in sub
return _compile(pattern, 0).sub(repl, string, count)
File "E:/Python/Essais Python/m rambc.py", line 4, in f
x = x.replace(' ','')
AttributeError: replace

Code :

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

1
2
3
4
5
6
7
8
9
import re
 
def f(x):
    x = x.replace(' ','')
    return x
 
chaine = "du texte avec des espaces 12 3 45 6 encore 12, 7, 86 35 2 90, 57,du texte avec 14 , 5des espaces 1 4 , 5 ou aussi 5 6 , et voilà"
chaine = re.sub("\d[\d, ]*[\d,]",f,chaine)
print chaine

[tyrtamos]

Bonjour eyquem,

Le pb de ton code est celui-ci:

Dans la méthode re.sub, il est effectivement accepté de transmettre une fonction au lieu de la chaine de remplacement.

Cette fonction doit retourner la chaine de remplacement à utiliser. Mais il est passé à cette fonction comme paramètre non pas une chaine, mais un "Match object".

Tu peux le voir si tu essaies d'afficher le "x" dans la fonction f: "<_sre.SRE_Match object at 0x01504BF0>".

Pour terminer la mise au point de ton code, il est intéressant d'afficher la ligne suivante à l'intérieur de ta fonction f(x):

Code :

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

1
2
 
print "===> ", x.group(), "===", x.start(), "===", x.end()

cela affichera:

Code :

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

1
2
3
4
5
6
 
===>  12 3 45 6 === 26 === 35
===>  12, 7, 86 35 2 90, 57, === 43 === 65
===>  14 , 5 === 79 === 85
===>  1 4 , 5 === 97 === 104
===>  5 6 , === 114 === 119

Et x.string permet de retrouver la chaine complète telle qu'elle est à l'appel de f(x).

On voit donc que la sous-chaine trouvée en 1er est x.group='12 3 45 6' qui commence à l'index x.start()=26 et qui se termine à l'index x.end()=35.

Donc, il suffit que ta fonction f renvoie en tant que chaine de remplacement, cette chaine trouvée dans laquelle les espaces auront été éliminés par replace:

Code :

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

1
2
 
x.string[x.start():x.end()].replace( ' ','')

Ce qui donne comme code complet:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import re
 
def f(x):
    return x.string[x.start():x.end()].replace( ' ','')
 
chaine = u"du texte avec des espaces 12 3 45 6 encore 12, 7, 86 35 2 90, 57,du texte avec 14 , 5des espaces 1 4 , 5 ou aussi 5 6 , et voilà"
 
chaine = re.sub(r"\d[\d, ]*[\d,]", f, chaine)
 
print chaine

Ce qui affiche:

Code :

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

1
2
 
du texte avec des espaces 123456 encore 12,7,8635290,57,du texte avec 14,5des espaces 14,5 ou aussi 56, et voilà

Et ça marche: bravo!

On peut même faire ça en une seule ligne:

Code :

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

1
2
 
chaine = re.sub(r"\d[\d, ]*[\d,]", lambda x: x.string[x.start():x.end()].replace( ' ',''), chaine)

Tyrtamos

[rambc]

Moi qui pensais poser une quetion toute bête... Très intéressante cette dernière méthode.

[tyrtamos]

Moi qui pensais poser une quetion toute bête... Très intéressante cette dernière méthode.

Oui, c'est manifestement la solution la plus élégante et la plus adaptée à ton problème.

Tyrtamos

[eyquem]

Venant de tyrtamos, c'est un compliment.

Il faut quand même remarquer qu'il y a deux replace qui fonctionnent dans mon code. C'est un peu similaire aux deux passages du code de tyrtamos.

Il resterait à tester la rapidité. Car le look ou l'algorithme du code sont deux choses choses, mais quel est le/les critères déterminant pour choisir un code plutôt qu'un autre ? C'est une question générale, pas spécialement pour ce problème. Qu'y a-t-il dans "la plus adaptée à ton problème" ?


PS merci pour l'explication sur sub. les mystères de Python se lèvent peu à peu

[tyrtamos]

Qu'y a-t-il dans "la plus adaptée à ton problème" ?

Ce qui me parait adapté au problème posé, c'est que le 1er "replace" (sub) trouve le "bloc" composé de chiffres, espace et virgule, et que le 2ème le traite en supprimant les espaces. A défaut de pouvoir faire cela en 1 seule fois, c'est un bon déroulement méthodologique.

Dans ma solution, je ne trouvais pas très élégant de recommencer 2 fois une opération qui ne traitait pas complètement le problème la 1ère fois. Je me suis même demandé au début s'il ne fallait pas une boucle "while" qui traitait jusqu'à ce qu'il n'y ait plus de différence avec le résultat du traitement précédent...

Je n'ai pas envisagé la durée de traitement comme un critère ici.

Tyrtamos


[Edit:] 2 petits additifs:

- on peut utiliser x.group() pour faire plus simple:

Code :

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

1
2
 
chaine = re.sub(r"\d[\d, ]*[\d,]", lambda x: x.group().replace( ' ',''), chaine)

- pour la rapidité, il faudrait au moins compiler l'expression régulière si on a plusieurs traitements à faire:

Code :

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

1
2
3
 
motif = re.compile(r"\d[\d, ]*[\d,]")
chaine = motif.sub(lambda x: x.group().replace( ' ',''), chaine)

Ce qui donne, bien entendu, le même résultat

[rambc]

Ok merci pour toutes ces infos.