Discussion :

[ben124]

Bonsoir à tous,

dans le but d'analyser du texte avec la librairie NLTK, j'essaye de construire un pattern à l'aide d'expressions régulières.
Or, j'ai du mal à saisir comment fonctionne vraiment une regex. En effet, le pattern ci-dessous marche très bien avec les 2 1eres lignes, mais ne trouve plus rien lorsqu'on rajoute la 3ème (regex pour détecter les abbréviations):

Code :

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

1
2
3
4
5
6
7
 
regEx = r'''(?x)
    \w+              # mots simples
  | [^\w]\d+[\.,]\d* # nombres entiers ou décimaux
  | ([a-z]\.)+       #abbréviations
'''
re.findall(regEx, txt)

Voici le texte que j'essaye d'analyser:

Code :

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

txt = "Voici un texte e.n français.[] J'essaye de pré-traiter à l'aide de nltk.T2NMx. mesures: 3,2 g/l, 10mm², 10 m.s. avec des %, 10% 5 %. 20/11/1990 "

Je pense que c'est un problème de "match" (si un match est trouvé avec la 1ere ligne de ma regex, alors les lignes derrières les | (ou logique) ne sont pas analysées?), mais je débute dedans alors si vous pouviez me donner des détails de pourquoi ça bug, et des pistes pour savoir comment "mimer" mon pattern de regex et obtenir un résultat, je vous en serai éternellement reconnaissant

[Sve@r]

Bonjour

Voici le texte que j'essaye d'analyser

Oui mais que veux-tu extraire de ce texte ? Tu ne nous l'as pas dit...

Or, j'ai du mal à saisir comment fonctionne vraiment une regex

C'est juste une espèce de langage qui permet de décrire ce que tu cherches par l'utilisation de symboles généralistes.

Je pense que c'est un problème de "match" (si un match est trouvé avec la 1ere ligne de ma regex, alors les lignes derrières les | (ou logique) ne sont pas analysées?)

Si une partie de la regex trouve l'info cherchée sur la ligne, alors pas besoin de continuer à chercher puisque le but (qui est de trouver si la ligne contient l'info) est atteint. Le "|" (ou logique) sépare deux regex, pas deux lignes. Si tu veux ensuite vérifier la ligne suivante, alors il faut relancer toute la recherche. Le principe de recherche d'info est "je cherche si un seul texte contient mon info" et si tu as plusieurs textes à vérifier, alors il faut faire plusieurs recherches en séquentiel.

Il y a aussi, je pense, un souci lié aux triples quotes. Car les triples quotes encadrent tout ce qui s'y trouve et qui devient du texte intégral. Or si "\w+" est une instruction de regex, "\w+ # mots simples" ne l'est pas. la chaine "# mots simples" (sensée être un commentaire python donc non visible par le moteur d'analyse du langage) est bel et bien vue, intégralement récupérée et envoyée à re.findall() qui, donc, ne trouve plus rien.

Tu devrais remplir ta variable de cette façon

Code python :

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

1
2
3
4
5
6
regEx = (
	r"(?x)"
	+ "\w+"				# mots simples
	+ "| [^\w]\d+[\.,]\d*"		# nombres entiers ou décimaux
	+ "| ([a-z]\.)+"		#abbréviations
)

je vous en serai éternellement reconnaissant

Mouais. On verra ça...

[wiztricks]

Salut,

le pattern ci-dessous marche très bien avec les 2 1eres lignes, mais ne trouve plus rien lorsqu'on rajoute la 3ème (regex pour détecter les abbréviations)

Çà ne trouve pas rien, çà retourne des chaînes vides.
Et c'est un comportement "normal" à cause des parenthèses de votre dernier groupe:

re.findall(pattern, string, flags=0)

Return all non-overlapping matches of pattern in string, as a list of strings. The string is scanned left-to-right, and matches are returned in the order found. If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result.

Essayez avec:

Code :

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

1
2
3
4
5
regEx = r'''(?x)
    (\w+)              # mots simples
  | ([^\w]\d+[\.,]\d*) # nombres entiers ou décimaux
  | ([a-z]\.)+       #abbréviations
'''

Vous verrez remonter des triplets (un par groupe) avec ce qui a été trouvé dedans.

mais je débute dedans alors si vous pouviez me donner des détails de pourquoi ça bug, et des pistes pour savoir comment "mimer" mon pattern de regex et obtenir un résultat, je vous en serai éternellement reconnaissant

Quelque soit le problème que vous cherchez à résoudre, vous pouvez toujours utiliser une mixture de regexp et d'opérations sur les chaînes de caractères...
inutile de construire une regexp "magique" (où vous pouvez attendre qu'un magicien de la regexp passe).

Il y a aussi, je pense, un souci lié aux triples quotes. Car les triples quotes encadrent tout ce qui s'y trouve et qui devient du texte intégral.

Les questions posées par les débutants sont intéressantes pour revisiter des fonctionnalités qu'on connaît mal. Mais cela suppose de prendre le temps de reproduire le problème, ouvrir la documentation, tester,... Bosser un peu quoi.

- W

[ben124]

Oui mais que veux-tu extraire de ce texte ? Tu ne nous l'as pas dit...

Je veux extraire ce qui est défini par mes "3" regex: mots simples, abbréviations et nombres.

Le "|" (ou logique) sépare deux regex, pas deux lignes. Si tu veux ensuite vérifier la ligne suivante, alors il faut relancer toute la recherche.

Si j'ai bien compris, à partir du moment où ma regex /w+ trouve un match, celui-ci ne pourra plus être "capturé" avec celle qui match les abbréviations par exemple? Ce qui se passe c'est que /w+ va détecter 3 matchs dans "e.n.a" (e, n et a) alors que ma regex "abbréviations" va détecter un seul match (e.n.a). C'est ce dernier match que je veux, mais vu que mon /w+ est analysé avant, la regex "abbréviations" n'est pas utilisé? Comment faire dans ce cas?

Çà ne trouve pas rien, çà retourne des chaînes vides.
Et c'est un comportement "normal" à cause des parenthèses de votre dernier groupe:

Ah oui je comprends un peu: c'est un problème de recouvrement. Comment faire pour afficher les match qui se recouvrent entre regex? On m'a parlé de "match le + long", "greedy", est ce une bonne piste?
Par ailleurs, comment se fait-il que je puisse combiner regex "mots simples" + "nombres" alors qu'il y a aussi du recouvrement? (/w+ va détecter 3,2 comme 3 et 2; ma regex de nombre va bien détecter 3,2; et ma regex "combiné" m'affiche bien 3,2 et pas (3 et 2)).

Pour mon problème initial: la meilleure façon (ou a plus simple) serait donc de séparer mes 3 patterns de regex plutôt que d'essayer de les combiner?

[wiztricks]

Salut,

Pour mon problème initial: la meilleure façon (ou a plus simple) serait donc de séparer mes 3 patterns de regex plutôt que d'essayer de les combiner?

Attendez, au départ:

dans le but d'analyser du texte avec la librairie NLTK, j'essaye de construire un pattern à l'aide d'expressions régulières.

donc, vous devez tokeniser puis taguer.
Et si vous voulez savoir pourquoi on ne peut pas faire cela avec de simples expressions régulières, demandez à votre prof (c'est un sujet de théorie des langages pas de programmation).

- W

[ben124]

J'ai testé vos 2 solutions mais ça ne me donne pas ce que je veux

[Sve@r]

Les questions posées par les débutants sont intéressantes pour revisiter des fonctionnalités qu'on connaît mal. Mais cela suppose de prendre le temps de reproduire le problème, ouvrir la documentation, tester,... Bosser un peu quoi.

Faut pas me titiller. Tu devrais me connaitre, tu sais que ça m'énerve et qu'ensuite, je reviens te démontrer que j'avais raison !!!

Bon, déjà le contexte: je suis au travail, dans un centre classifié. Sur mon poste de travail, j'ai du linux, donc du Python, mais pas internet. Internet je l'ai sur un autre poste mais qui n'a pas de linux et pas de Python. Si je veux tester, faut alors que je prenne une clef, récupère le code, l'amène sur mon poste. De là je teste, je regarde, et si j'ai un code à remonter alors opération inverse. Donc pas vraiment évident de le faire à chaque coup. Il m'arrive de le faire effectivement pour des trucs un peu complexes mais le plus souvent, en semaine aux heures de bureau, dans la plupart des cas qui sont assez simples je réponds "à capella" en me fiant plus à mes connaissances qu'à un test réel. Mais généralement je suis aussi assez sûr de moi quand je les écris...

Toutefois, là, exceptionnellement, je me suis fendu de toutes ces opérations. Juste pour toi...

[ben124]

Salut,

donc, vous devez tokeniser puis taguer.
Et si vous voulez savoir pourquoi on ne peut pas faire cela avec de simples expressions régulières, demandez à votre prof (c'est un sujet de théorie des langages pas de programmation).

- W

Je n'ai pas vraiment de prof: je suis en stage de Master dans le domaine informatique médical, avec qd même plus de médical que d'informatique du coup je ne connais pas vraiment d'expert en regex.
Dans la librairie nltk, un tokenizer permet de donner des regex en argument, c'est pour ça que j'essaye de contruire un pattern regex avant de tokenizer.
En effet on m'a conseillé de tokenizer puis de taguer, mais ça rajoute une sacré charge de travail, qui sera difficile à réaliser dans le délai imparti... Est ce que normaliser le texte avant de tokenizer serait une solution plus simple?

[wiztricks]

Je n'ai pas vraiment de prof: je suis en stage de Master dans le domaine informatique médical

Stop, vous êtes en stage: votre première ressource est votre responsable de stage.
C'est à lui d'arbitrer vos hésitations.

note: nous n'avons aucune idée du contexte dans lequel vous bossez... on ne pourra avoir que de mauvaises idées.

Faut pas me titiller. Tu devrais me connaitre, tu sais que ça m'énerve et qu'ensuite, je reviens te démontrer que j'avais raison!!!

Heureux de voir que çà égaille ta journée
Ceci dit tu devrais quand même regarder l'option re.VERBOSE (et la dernière ligne en tout petit).

- W

[Sve@r]

Heureux de voir que çà égaille ta journée

Nan, faut pas !!! En plus j'emmène ma femme au ciné ce soir et je suis ultra pressé !!!

Ceci dit tu devrais quand même regarder l'option re.VERBOSE (et la dernière ligne en tout petit).

Ah oui mais s'il faut en plus lire les lignes en tout petit

Ok, t'as gagné (pouvait-il en être autrement ?)

[ben124]

Ok je vais essayer de voir si quelqu'un peut répondre à mon problème, mais j'en doute fortement.

Mais sortons de mon but initial: si maintenant je veux récupérer mes 3 patterns (mots simples, abréviations, nombres) sur un string, quelle est pour vous la meilleure solution? combiner ces 3 patterns avec gestion de l'overlapping? ou les utiliser séparément et regrouper leurs résultats (dans une liste par exemple)?

Merci à vous 2!

[Sve@r]

Hé, tout dépend de ton algo.
Si par exemple tu veux gérer les pattern en individuel (exemple chercher le premier, puis le 3°, puis plus tard le second), une liste est très adéquate (enfin moi pour un ensemble de trucs immuables je suis plus pour le tuple qui prend moins de place mais ça change rien à l'idée).

Si maintenant tu veux tes 3 pattern d'un coup, alors ta première façon de faire reste la plus simple. Et comme la pep 20 de Python dit "simple is better than complex"...

[ben124]

D'accord!

Au final, j'ai réussi à combiner mes regex, juste en changeant l'ordre et en mettant \w+ à la fin et le pattern "abréviations" en premier. C'est effectivement un problème d'overlapping et de "consommation" de match (j'espère me faire comprendre, je débute vraiment dans les regex et je ne pensais pas que ça pouvait être si complexe quand on sort du cadre scolaire).

Du coup j'en conclue qu'il faut faire très attention lorsqu'on combine des regex et que sans doute il ne faut pas trop le faire, sauf si on est sûr que nos patterns ne se recouvrent pas entre eux ou si il est facile de trouver l'ordre dans lequel les agencer.
En tant qu'expert, vous êtes d'accord avec moi? Ou bien le fait que je galère à combiner 3 patterns vient seulement du fait que je suis archi débutant dans le domaine?

[wiztricks]

Ou bien le fait que je galère à combiner 3 patterns vient seulement du fait que je suis archi débutant dans le domaine?

Le problème n'est pas de combiner 3 patterns, mais de partir d'une phrase ou d'un paragraphe dans lequel on filtre "tout ce qui n'est pas".

Du coup j'en conclue qu'il faut faire très attention lorsqu'on combine des regex et que sans doute il ne faut pas trop le faire, sauf si on est sûr que nos patterns ne se recouvrent pas entre eux ou si il est facile de trouver l'ordre dans lequel les agencer.

Si la structure de vos données est "régulière", on peut tester les différents cas de figures et s'assurer que çà ne manque rien ni n'attrape ce qu'on ne veut pas. Le problème est que phrases et paragraphes du langage ne sont pas réguliers (et çà ne va pas être coton d'écrire le plan de tests).

- W

[BufferBob]

salut,

\w est piégeux, déjà parce qu'il est sensible à la locale et parce qu'en l'occurrence il inclue également les chiffres et l'underscore :

Code :

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

1
2
>>> re.findall(r'\w+', '1ç2_3à4-5èé6')
['1ç2_3à4', '5èé6']

on comprend donc que si on cherche à matcher les nombres flottants après que \w+ soit passé (dans l'ordre de la regex) ben on est marron :

Code :

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

1
2
3
4
>>> re.findall(r'\w+|\d+\.\d+', '12.34')
['12', '34']
>>> re.findall(r'\d+\.\d+|\w+', '12.34')
['12.34']

les nombres je les matcherai avec un truc du genre \d+(?:[\.,]\d+)? :

• (?: ) permet de faire des groupes non-capturants (on ne peut pas les indexer par \1, \2 etc. et ils n'apparaissent donc pas dans les résultats retournés)
• (...)? le point d'interrogation rend le groupe optionnel

quant aux abréviations, on pourrait imaginer un truc du genre (?:[A-Za-z0-9]{1,3}\.)+ capable de matcher M., Mme. ou S.O.S. mais aussi des fins de phrases aléatoires comme os., nez. ou dur., ça peut donc être piégeux là aussi.

j'aurai plutôt tendance à partir sur une liste d'abréviations, qu'on peut éventuellement transformer en regex pourquoi pas, il faut tout de même prendre garde aux cas limites comme à chaque fois;
dans 'un éclat.', 'lat.' n'est pas une abréviation, on peut le préciser via le métacaractère \b (word boundary), et en gardant en tête qu'il a les mêmes limites que \w (ex: '5Kg.' sans espace, il faut donc d'abord matcher les nombres pour extraire le '5', puis matcher les abréviations pour extraire 'Kg.').

Code :

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

1
2
3
4
5
6
7
8
9
10
11
>>> txt = "Voici un texte e.n français.[] J'essaye de pré-traiter à l'aide de nltk.T2NMx. mesures: 3,2 g/l, 10mm², 10 m.s. avec des %, 10% 5 %. 20/11/1990 "
>>> reg_motsimple = r'\w+'
>>> reg_nombre = r'\d+(?:[,\.]\d+)?'
>>> liste_abrev = ['g/l', 'mm²', 'm.s.']                          # ici l'ordre n'importe pas, mais ça pourrait
>>> reg_abrev = r'|'.join(r'\b' + w.replace('.', '\.') for w in liste_abrev)
>>> regex = r'|'.join([reg_nombre, reg_abrev, reg_motsimple])     # dans l'ordre
>>> re.findall(regex, txt)
['Voici', 'un', 'texte', 'e', 'n', 'français', 'J', 'essaye', 'de', 'pré', 'traiter', 'à', 'l', 'aide', 'de', 'nltk', 'T2NMx', 'mesures', '3,2', 'g/l', '10', 'mm²', '10', 'm.s.', 'avec', 'des', '10', '5', '20', '11', '1990']
>>> import nltk
>>> nltk.regexp_tokenize(txt, regex) == re.findall(regex, txt)
True

on pourra généraliser le principe aux mots composés, entités nommées etc. c'est un peu touchy au début mais tellement pratique les regex...

à noter quand même qu'il manque au module re (par défaut) quelques fonctionnalités sympas comme le support des catégories Unicode, et qu'à tout ce qu'il manque le module regex pourvoira.