Discussion :

[neflerine]

Bonjour à tous. Je n'ai pas trouvé de rubrique notepad++ donc je ne suis pas sur de poster dans la bonne section.

Un problème qui me semblait simple me donne en ce moment des nœuds à la tête :
J'ai une ligne dans laquelle je souhaite détecter le "!" et suite à cela toutes les occurrences de 6 chiffres se trouvant après un ":"

23/06/2021!06:31:00!872701!4125:063100,4143,101,207,225,229,303,325,329,441:252222

Cette expression fonctionne parfaitement : (:[0-9]{6})
Cependant dès que j'essaye de détecter le "!" en le rajoutant devant l'expression cela ne marche plus.

Merci d'avance pour votre aide.
Bonne journée à tous.

[Sve@r]

Bonjour

J'ai une ligne dans laquelle je souhaite détecter le "!" et suite à cela toutes les occurrences de 6 chiffres se trouvant après un ":"

Que signifie "suite à cela" ??? Autant dans le langage courant rester dans le flou ça peut passser, autant en informatique ça ne passe plus.

23/06/2021!06:31:00!872701!4125:063100,4143,101,207,225,229,303,325,329,441:252222

Cette expression fonctionne parfaitement : (:[0-9]{6})
Cependant dès que j'essaye de détecter le "!" en le rajoutant devant l'expression cela ne marche plus.

Tu aurais pu poster ton exemple car là on est obligé d'en rester à des suppositions. Donc si comme je le suppose tu as écrit !(:[0-9]{6}) il est évident que ça ne peut pas marcher puisque dans ton exemple, le caractère "!" n'est pas suivi du caractère ":". D'où la demande de précision de ton "suite à cela". Car c'est ce "suite à cela" qu'il va falloir exprimer sous forme de regex.
Par exemple !.{0,}(:[0-9]{6}) signifiant "point d'exclamation suivi de 0 à n caractères quelconques (ce fameux "suite à cela") puis dans lesquels survient un double point suivi de 6 chiffres" pourrait donner un résultat intéressant...

[Invité]

Ah on peut faire ça avec Notepad++ c'est cool ! Je vois pas en quoi ça me servirait mais bon ^^

[neflerine]

Alors tout d'abord je m'excuse d'avoir émis une demande non claire, et je comprends totalement la réaction.

En fait je souhaite détecter ce qui est en gras après un point d'exclamation comme ci-dessous :

23/06/2021!06:31:00!872701!4125:063100,4143,101,207,225,229,303:111111,325,329,441:252222


Voila le début d'une ligne correspond à une date et à son identifiant et les données commencent après le point d'exclamation.
Sur certaines données (chacune séparée par une virgule), il y a parfois un horaire représenté par un ":" suivi de 6 chiffres HHMMSS

J'aimerais supprimer ces horaires des lignes.
La regex !.{0,}(:[0-9]{6}) n'a pas fonctionné chez moi pour supprimer tous les horaires de la ligne

[tyrtamos]

Bonjour,

Je ne suis pas sûr d'avoir trouvé une solution élégante, mais au moins, elle a l'air de marcher:

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
import re
 
ch = "23/06/2021!06:31:00!872701!4125:063100,4143,101,207,225,229,303:111111,325,329,441:252222"
 
motif = r"(:[0-9]{6})"
regex = re.compile(motif)
horaires = []
i = ch.find("!")
if i>=0:
    # la chaine comporte un "!" => on cherche les horaires à la suite
    while True:
        x = regex.search(ch, i)
        if x is None:
            break # pas d'autres horaires
        horaires.append([x.group(1), x.start(1), x.end(1)])
        print(x.group(1), x.start(1), x.end(1))
        i = x.end(1)
print()    
# suppression des sous-chaines trouvées (parcours à l'envers)
for horaire, debut, fin in horaires[::-1]:
    ch = ch[:debut] + ch[fin:]
print()
print(ch)

Ce qui affiche:

Code :

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

1
2
3
4
5
:063100 31 38
:111111 63 70
:252222 82 89
 
23/06/2021!06:31:00!872701!4125,4143,101,207,225,229,303,325,329,441

Le "search" est intéressant parce qu'il renvoie un objet "match" qui permet non seulement de connaître la sous-chaine trouvée, mais aussi l'endroit où elle se trouve (start, end)

C'est ce qui permet de supprimer toutes les sous-chaines trouvées, à condition bien sûr, de parcourir la liste des sous-chaines à l'envers (sinon, les indices seraient faux dès la 2ème sous-chaine).

Le motif regex sélectionné ici est peut-être imparfait. Par exemple, si l'horaire est suivi par un chiffre, ce n'est peut-être pas un horaire. On peut donc préciser que l'horaire cherché doit être suivi soit par autre chose qu'un chiffre (une virgule par exemple), soit par la fin de la chaine. Dans ce cas, le motif serait:

Code :

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

motif = r"(:[0-9]{6})([^0-9]|$)"

Ce qui donne ici le même résultat.

[jurassic pork]

hello,

Alors tout d'abord je m'excuse d'avoir émis une demande non claire, et je comprends totalement la réaction.

En fait je souhaite détecter ce qui est en gras après un point d'exclamation comme ci-dessous :

23/06/2021!06:31:00!872701!4125:063100,4143,101,207,225,229,303:111111,325,329,441:252222


Voila le début d'une ligne correspond à une date et à son identifiant et les données commencent après le point d'exclamation.
Sur certaines données (chacune séparée par une virgule), il y a parfois un horaire représenté par un ":" suivi de 6 chiffres HHMMSS

J'aimerais supprimer ces horaires des lignes.
La regex !.{0,}(:[0-9]{6}) n'a pas fonctionné chez moi pour supprimer tous les horaires de la ligne

Ta demande n'est pas très claire :
1 - Pourquoi veux tu te synchroniser sur un ! alors que tu recherches les horaires ( un ":" suivi de 6 chiffres HHMMSS) ? et si oui lequel (il y en a plusieurs sur la ligne) ?
2 - Dans ton exemple il y a :252222 ? une 25ème heure

si le ! n'a pas d'importance ce code fait le boulot :

Code :

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

1
2
3
4
 
strtest  =  "23/06/2021!06:31:00!872701!4125:063100,4143,101,207,225,229,303:111111,325,329,441:252222"
p = re.compile('(:\d{6})')
print(re.sub(p, "", strtest))

résultat :

23/06/2021!06:31:00!872701!4125,4143,101,207,225,229,303,325,329,441

Ami calmant, J.P

[Sve@r]

Je vois pas en quoi ça me servirait mais bon ^^

Tous les éditeurs de développement ("vi", "notepad++") connaissent les regex. Par exemple une fois, j'avais un fichier de sous-titres (donc timecodé) mais une traduction l'avait modfié et tous les timecodes style "hh:mn:ss" étaient devenus "hh: mm: ss" et le sous-titre ne passait plus dans VLC. Un coup de regex dans notepad++ et ça l"a réparé.

23/06/2021!06:31:00!872701!4125:063100,4143,101,207,225,229,303:111111,325,329,441:252222
La regex !.{0,}(:[0-9]{6}) n'a pas fonctionné chez moi pour supprimer tous les horaires de la ligne

Normal, tu avais présenté ton besoin comme devoir trouver "un" groupe de chiffres et ta ligne en contient trois. Et comme la recherche .{0,} est gloutonne (elle va le plus loin possible) je pense que ça supprime le groupe "252222" en laissant intact les groupes "063100" et "111111". Sauf que je ne pense pas qu'une regex exprimant "point d'exclamation puis n'importe quoi puis deux points puis 6 chiffres, ces éléments sauf le point d'exclamation pouvant eux-mêmes être répétés" puisse exister.
Mais en répétant cette regex autant de fois qu'il le faut...

[neflerine]

Merci pour vos réponses.

Je souhaite me synchroniser sur le ! pour 2 raisons :
1/ car ce qu'il y a à gauche du ! est susceptible de changer dans le temps
2/ pour apprendre à me caler à l'endroit que je veux en regex (volonté académique ?)

Pour la petite histoire il s'agit de ma compagne qui travaille dans les itinéraires de trains, et chaque nombre à droite du ! correspond à un itinéraire du train.
Cependant un collègue parti à la retraite qui à développé un logiciel en pascal qui analyse les itinéraires n'a laissé que l’exécutable de son logiciel (méchant papi) et en + à fait une erreur dans son code en laissant les horaires.

Du coup je voulais juste une petite regex notepad++ qui supprime les horaires des fichiers. Ma regex initiale fonctionne très bien, mais le jour où le format changera, j'aimerais pouvoir me caler sur ce qu'il y a à droite du !

Vos codes en python sont très intéressant pour moi, et je vais les potasser, cependant dans son entreprise, python n'est pas installé, voila pourquoi je souhaite rester sur np++ tout simple.

A la reflexion j'aurais du expliquer tout ceci dans mon premier message, j'espère que tout est clarifié et que les trains arriveront à l'heure

[Sve@r]

cependant dans son entreprise, python n'est pas installé

np++ impose une action de ta part (ouvrir le fichier, lancer la regex, la relancer autant de fois qu'il le faut etc...) alors qu'en python ça peut s'automatiser (style "tant que je trouve je traite"). Apparemment tu es développeur dans cette boite donc tu dois avoir ta machine de dev. Pourquoi ne pas lui installer un petit Python des familles (en plus si t'es sous linux c'est déjà automatiquement le cas) puis développer ton petit script qui traite automatiquement le fichier. Ensuite négligemment tu laisses entendre que le papi a laissé une verrue mais que grace à Python tu as pu passer par dessus cette difficulté et qu'il mériterait qu'on s'y intéresse. A la limite si tu as le temps tu recodes tout le programme Pascal en Python et tu fais une démo. C'est comme ça qu'on fait évoluer les mentalités...

[Invité]

@Sve@r Okay ! Faudrait peut-être que je m'y mette alors.
Pour ton problème je crois que j'aurais fais remplacer ": " par ":" tant pis pour les 2 ou 3 " : " présent dans le texte.

[jurassic pork]

hello,
voici une solution pour ne prendre en compte que ce qui est après le ! . Pour cela j'utilise deux expressions régulières :
- La première supprime de la chaîne initiale la partie qui va jusqu'au ! ( 2 possibilités 1- jusqu'au premier ! , 2 - jusqu'au dernier !)
- La deuxième supprime tous les horaires dans la chaîne calculée par la première expression régulière.
A la fin on reconstitue la chaîne entière.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
strtest  =  "23/06/2021!06:31:00!872701!4125:063100,4143,101,207,225,229,303:111111,325,329,441:252222"
#lazy (jusqu'au premier  !)
#p1= re.compile('^.+?!')
#greedy (jusqu'au dernier !)
p1= re.compile('^.+!')
p2 = re.compile('(:\d{6})')
part1 = re.search(p1, strtest).group()
print(part1)
strtrunc = re.sub(p1, "", strtest)
print(strtrunc)
print(part1 + re.sub(p2, "", strtrunc))

Il y a peut-être moyen de tout faire avec une seule expression régulière mais je ne suis pas assez balaise en expression régulière pour le faire.

Ami calmant, J.P

[wiztricks]

Salut,
pas sur d'avoir tout compris mais j'écrirais ça:

Code :

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

1
2
3
4
5
6
7
>>> s
'23/06/2021!06:31:00!872701!4125:063100,4143,101,207,225,229,303:111111,325,329,
441:252222'
>>> rg = r'!*(:\d{6})'
>>> re.sub(rg, '', s)
'23/06/2021!06:31:00!872701!4125,4143,101,207,225,229,303,325,329,441'
>>>

- W

[jurassic pork]

hello,

Salut,
pas sur d'avoir tout compris mais j'écrirais ça:

Code :

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

1
2
3
4
5
6
7
>>> s
'23/06/2021!06:31:00!872701!4125:063100,4143,101,207,225,229,303:111111,325,329,
441:252222'
>>> rg = r'!*(:\d{6})'
>>> re.sub(rg, '', s)
'23/06/2021!06:31:00!872701!4125,4143,101,207,225,229,303,325,329,441'
>>>

- W

effectivement çà à l'air de fonctionner mais en réalité cela ne fonctionne pas si il y a un : suivi de 6 chiffres avant le ! :
exemple :

Code :

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

1
2
3
4
strtest  =  "23/06/2021:123456!06:31:00!872701!4125:063100,4143,101,207,225,229,303:111111,325,329,441:252222"
p = re.compile('!*(:\d{6})')
print(p.findall(strtest))
print(re.sub(p, '', strtest))

donne comme résultat :

[':123456', ':063100', ':111111', ':252222']

23/06/2021!06:31:00!872701!4125,4143,101,207,225,229,303,325,329,441

le :123456 est supprimé. Cela s'explique par le fait que !* veut dire 0 ou plus caractère ! et l'expression régulière est vérifiée pour 0 caractère !

Ami calmant, J.P

[wiztricks]

effectivement çà à l'air de fonctionner mais en réalité cela ne fonctionne pas si il y a un : suivi de 6 chiffres avant le !

Tout à fait, mais comme on ne connait pas le format du début de la chaine de caractères, pas sûr que ce soit si important.

- W

[CosmoKnacki]

Avec la commande rechercher de notepad++ et si les nombres se trouvent à droite du !, tu peux utiliser cette expression:

Code regex :

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

(?:\G(?!^)|!)(?:[^:\n]*:)+?\K\d{6}

C'est une expression à deux entrées (dans la première parenthèse, autrement dit, le groupe non-capturant (?:....)). La première entrée \G(?!^) ne peut réussir que si elle se trouve à une position de la chaîne juste après une correspondance réussie (c'est ce qu'impose l'ancre \G). La deuxième entrée elle, se charge de trouver le !.
La suite est commune aux deux entrées: (?:[^:\n]*:) atteint les : sur la même ligne et est répété autant de fois que nécessaire (avec +?) pour trouver 6 chiffres \d{6}.
Le bien pratique \K sert à exclure tout ce qui se trouve avant lui du résultat (pour ne garder que les chiffres).

Le scénario se déroule de cette manière: tant que la deuxième entrée n'a pas réussi, rien ne se passe. Par contre, lorsque c'est le cas donc que ! est trouvé ainsi que le premier groupe de 6 chiffres, alors passer par la première entrée, celle de \G, devient possible. Ce passage par la première entrée part de la position suivant la correspondance précédente pour atteindre le deuxième groupe de 6 chiffres.

Tant qu'il y a réussite de la pattern et qu'on peut partir de la dernière position pour atteindre les prochains 6 chiffres, la première entrée sera empruntée.

Tu remarqueras que j'ai exclu le saut de ligne \n de la classe de caractères. Ceci garantit que les 6 chiffres seront bien sur la même ligne que le ! et pas sur un autre. Mais cela va aussi permettre au mécanisme de s'interrompre, car quand il n'y aura plus de groupes de 6 chiffres sur la ligne, la pattern échouera et la première entrée ne pourra plus être empruntée.

Ce mécanisme pourra bien sûr reprendre si sur une autre ligne, ! est trouvé de nouveau grâce à la deuxième entrée. Et ainsi de suite.

demo


NB: J'ai ajouté (?!^) à la suite de \G car ce dernier réussit aussi en début de chaîne. (?!^) fera échouer la pattern à cet endroit précis.

[jurassic pork]

hello,
merci CosmoKnacki pour cette expression régulière. Il me semble que la demande initiale demandait aussi de supprimer le : devant les 6 chiffres. L'expression régulière ne serait elle pas alors :

Code :

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

(?:\G(?!^)|!)(?:[^:\n]*)+?\K:\d{6}

Le module re python ne connaît pas l'ancre \G. Par contre le module regex disponible dans Pypi la connaît.

Avec ce code :

Code :

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

1
2
3
4
5
6
7
8
import regex
strtest  =  """:123456
abcdef:123456
23/06/2021:123456!06:31:00!872701!4125:063100,4143,101,207,225,229,303:111111,325,329,441:252222"
"""
p = regex.compile('(?:\G(?!^)|!)(?:[^:\n]*)+?\K:\d{6}')
print(p.findall(strtest))
print(regex.sub(p, '', strtest))

j'obtiens ceci :

[':063100', ':111111', ':252222']
:123456
abcdef:123456
23/06/2021:123456!06:31:00!872701!4125,4143,101,207,225,229,303,325,329,441"

Ami calmant, J.P

[CosmoKnacki]

hello,
merci CosmoKnacki pour cette expression régulière. Il me semble que la demande initiale demandait aussi de supprimer le : devant les 6 chiffres. L'expression régulière ne serait elle pas alors :

Code :

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

(?:\G(?!^)|!)(?:[^:\n]*)+?\K:\d{6}

OK, mais mieux vaut déplacer le \K, (car à la base (?:[^:\n]*:)+? se répète jusqu'à ce qu'il soit suivi de 6 chiffres et ce en passant les éventuels : pour lesquels ce n'est pas le cas).

Donc:

Code :

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

(?:\G(?!^)|!)(?:[^:\n]*+\K:)+?\d{6}

Le fait de répéter \K est inhabituel et peut sembler étrange, mais c'est sans conséquences. Un détail, j'ai explicitement passé le quantificateur * en possessif *+ car je crois que le fait de placer un simple \K avant le : qui est exclu de la classe de caractères précédente, empêche l'auto-possessification.


Sinon, pour reprendre ton idée précédente où le ! peut se trouver n'importe où sur la ligne, on peut très bien remplacer ! par un test avant ancré en début de ligne:

Code :

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

(?m:\G(?!\A)|^(?=.*!))(?:[^:\n]*+\K:)+?\d{6}