Les RegEx ou Expressions Régulières

LIENS

https://www.freeformatter.com/regex-tester.html

https://www.regexpal.com

https://regex101.com plusieurs langages (Python, JavaScript, PHP) et une bibliothèque de regex prêtes à être utilisées.

http://regexstorm.net/tester

https://ihateregex.io/?q= Une liste de la plupart des RegEx utilisées

http://aichallenge.org permet de bien découvrir des langages (Python), et d’y appliquer des mathématiques, tout en s’amusant

MÉTACARACTÈRES

^ début chaine >  /^music/ (commence par music)

$ fin de chaine > /^music$/ (commence et termine par music)

| ou > /music|musique/ (music ou musique)

. tous les caractères sauf les retour charriot \n (il faut utiliser l’option s) /./ (vaut donc pour a ou pour 8 ou pour $)

\ caractère d’échappement /\?/ (? devient un caractère normal)

Quantificateurs

? 0 ou 1 fois /bue?no/ (buno, ou bueno)

+ 1 ou plus /bue+no/ (bueno, bueno, bueeeeeeno…)

* 0, 1 ou plus /bue*no/ (buno, bueno, bueeeeeeno…)

( ) permet d’appliquer répétition sur plusieurs signes /Ay(Ay)*/ ( Ay, AyAy, AyAyAyAyAyAy…)

{ } préciser le nombre de répétitions

/Ay(Ay){3}/ 3 fois exactement > (AyAyAyAy)

/Ay(Ay){1-4}/ > (AyAy, AyAyAy […] AyAyAyAyAy)

#a{3,5}# « a » doit apparaître de 3 à 5 fois (« aaa », « aaaa », « aaaaa »).

/Ay(Ay){3,}/ au moins 3 fois > (AyAyAyAy ; AyAyAyAyAy ; etc)

 

{0,1} équivaut à ?
{1,} équivaut à +
{0,} équivaut à *

 

#Ay(ay|oy)*# Fonctionne pour Ay, Ayay, Ayoy, Ayayayoyayayoyayoyoyoy, etc.

Classes et intervalles

[ ] classe de caractères /gr[oai]s/ (gros, gras ou gris)

[ - ] intervalle de classe /n°[0-9]/ (n°1, n°2, […] n°9)

[^ ] classe à exclure /h[^3-9]/ (h1 et h2 uniquement)

 

Pour inclure - en tant que caractère, on doit le placer en fin de classe (ou au début).

pour ], il faut l’échapper par un antislash.

Les autres métas-caractères ne comptent pas dans les classes. On ne les échappe pas. Cette classe [0-9a-z?+*{}.] correspond donc à un chiffre, une lettre, un point d’interrogation, un point, un plus…

Classes abrégées et nommées

\d équivaut à [0-9] ou [:digit:]

\D équivaut à [^0-9]

\w équivaut à [a-zA-Z0-9_] ou [:alnum:]

\W équivaut à [^a-zA-Z0-9_]

\t indique une tabulation

\n indique une nouvelle ligne

\r indique un retour chariot

\s indique un espace blanc (correspond à \t \n \r)

\S indique ce qui n’est PAS un espace blanc (\t \n \r)

[:alpha:] caractères alphabétiques ([A-Za-z])

[:blank:] caractères blanc (espace, tabulation)

[:ctrl:] caractères de contrôle (les premiers du code ASCII)

[:graph:] caractère d’imprimerie (qui fait une marque sur l’écran en quelque sorte)

[:print:] caractère imprimable (qui passe à l’imprimante … tout sauf les caractères de contrôle)

[:punct:] caractère de ponctuation

[:space:] caractère d’espacement

[:upper:] caractère majuscule

[:xdigit:] caractère hexadécimal

Capture et références

les () sont capturantes. On peut faire référence aux expressions capturées à deux endroits :

Dans la REGEX elle-même. Ex avec les palindromes : /(\w)a\1/> \w sélectionne tout caractère alphanumérique, suivi d’un a puis du backreference (donc l’expression entre parenthèses, soit la première lettre sélectionnée) :

 

SOS je suis fais des gag !

 

Il peut y avoir plusieurs backreferences dans une même expression, la première est indiquée par \1, la seconde \2 et ainsi de suite.

 

const birth = 'Je suis né en 1990 à Lyon';
console.log(birth.match(/^Je suis né en ([0-9]{4})/)); // ["Je suis né en 1990", "1990"]

 

On obtient d’abord le match global en index 0, puis dans leur sens d’apparition les résultats des groupes capturants.

Comme on ne peut en général capturer que neuf éléments (en Javascript par exemple, vous ne pourrez pas aller au delà de $9), il peut être intéressant de préciser qu’un couple de parenthèse utilisé à des fin de groupement est non capturant. Il faut pour cela placer ?: juste après la parenthèse ouvrante ex. /(?:[0-9]{4})/.

Lookahead et lookbehind

Permet de matcher un élément en fonction de son contexte.

lookahead regarde en avant : on pourra sélectionner un élément en fonction de ce qu’il y a (ou pas) après lui.

lookahead s’exprime par des parenthèses, comme les groupes de captures, mais on y ajoute la chaîne ?=. Exemple :

 

const birthQuent = 'Je suis Quentin et je suis né en 1990 à Lyon';
const birdtRoger = 'Je suis Roger et je suis né en 1978 à Paris';

const regex = /en ([0-9]{4}) (?=à Lyon)/;

console.log(regex.exec(birthQuent)); // ["en 1990 ", "1990"]
console.log(regex.exec(birdtRoger)); // null

 

Lorsqu’on sélectionne selon ce qu’il n’y a pas, on parle de lookahead négatif. Le principe est le même mais on remplace =? par =!. Comme un exemple vaut mille mots :

 

const birthQuent = 'Je suis Quentin et je suis né en 1990 à Lyon';
const birdtRoger = 'Je suis Roger et je suis né en 1978 à Paris';
const birthSixt = 'Je suis Sixtine et je suis né en 1994 à Bordeaux';

const regex = /en ([0-9]{4}) (?!à Paris)/;

console.log(regex.exec(birthQuent)); // ["en 1990 ", "1990"]
console.log(regex.exec(birdtRoger)); // null
console.log(regex.exec(birthSixt)); // ["en 1994 ", "1994"]

 

lookbehind match les expressions qui sont (ou pas) précédées par ce qu’il y a dans le lookbehind. Les notations sont respectivement pour le positif et le négatif (?<=) et (?<!).

 

const alex = 'Codename 006 – Alec Trevelyan';
const james = 'Codename 007 – James Bond';

const regex = /(?<=007 – )([A-Z][a-z]+ [A-Z][a-z]+)/;

 

Attention, lookbehind n’est supporté en JavaScript qu’en ES2018. Il n’est donc pas encore vraiment supporté par les navigateurs.

Métacaractères

Les métacaractères sont :
# ! ^ $ ( ) [ ] { } | ? + * .
Pour utiliser un métacaractère dans une recherche, il faut l’échapper avec un antislash :\.

 

Les métacaractères n’ont pas besoin d’être échappés dans une classe, sauf pour # (symbole de fin de la regex),  ] (symbole de la fin de la classe) et  \
Si on veut rechercher un tiret dans une classe de caractères, il faut le placer au début ou à la fin de la classe :[a-zA-Z0-9-].

Capture et remplacement

En utilisant la fonctionpreg_replaceon peut automatiquement faire des remplacements à l’aide de regex.

<?php $texte = preg_replace('#\[b\](.+)\[/b\]#i', '<strong>$1</strong>', $texte); ?>

PHP > $1,$2,$3, etc. jusqu'à$99
(?:texte)est une parenthèse non capturante : elle ne crée pas de variable.

$0 est toujours créée et correspond à l'ensemble de la regex.

Ainsi, la regex suivante…
#(anti)co(?:nsti)(tu(tion)nelle)ment#
$0 : anticonstitutionnellement ;
$1 : anti ;
$2 : tutionnelle ;
$3 : tion.

Options

i pas de différence entre majuscules / minuscules ;

s le point fonctionnera aussi pour les retours à la ligne (\n) ;

U Ungreedy (pas gourmand) pour que la regex s’arrête le plus tôt possible. Pratique pour le bbCode[b][/b] : la regex s’arrêtera à la première occurrence de[/b].

Principes de base

Lorsqu’une chaîne de caractère correspond à la description donnée par l’expression régulière, on dit qu’il y a « correspondance » entre la chaîne et le motif, ou que le motif « reconnaît » la chaîne. Cette correspondance peut concerner la totalité ou une partie de la chaîne de caractères. Par exemple, dans la phrase « Les deux équipes ont terminé ex-æquo et se sont saluées. », la sous-chaîne « ex-æquo » est reconnue par le motif « ex-(a?e|æ|é)quo ».

Lorsque c’est possible, elles tentent de reconnaître la plus grande sous-chaîne correspondant au motif : Aa+ reconnaît la totalité de la chaîne « Aaaaaaa » plutôt qu’une partie « Aaa » (), mais elle ne reconnaît pas la chaîne « aaaA » (sensibilité à la casse).

 

Opérateurs de base

Opérateurs	Description	Exemples
		Expression régulière	Chaînes décrites	Chaînes non décrites
expr1 expr2	Opérateur de concaténation de deux expressions (implicite).	ab	« ab »	« a », « b », chaîne vide
.	Un caractère et un seul	.	« a », « b », …	chaîne vide, « ab »
expr?	Ce quantificateur correspond à ce qui le précède, présent zéro ou une fois. Si de multiples correspondances existent dans un texte, il trouve d’abord ceux placés en tête du texte et retourne alors la plus grande longueur possible à partir de cette position initiale.	a?	chaîne vide, « a »	« aa », « b »
expr+	Ce quantificateur correspond à ce qui le précède, répété une ou plusieurs fois. Si de multiples correspondances existent dans un texte, il trouve d’abord ceux placés en tête du texte et retourne alors la plus grande longueur possible à partir de cette position initiale.	a+	« a », « aa », « aaaaa », …	chaîne vide, « b », « aaab »
expr*	Ce quantificateur correspond à ce qui le précède, répété zéro ou plusieurs fois. Si de multiples correspondances existent dans un texte, il trouve d’abord ceux placés en tête du texte et retourne alors la plus grande longueur possible à partir de cette position initiale.	a*	chaîne vide, « a », « aaa », …	« b », « aaab »
expr1|expr2	C’est l’opérateur de choix entre plusieurs alternatives, c’est-à-dire l’union ensembliste. Il peut être combiné autant de fois que nécessaire pour chacune des alternatives possibles. Il fait correspondre l’une des expressions placées avant ou après l’opérateur. Ces expressions peuvent éventuellement être vides, et donc (x|) équivaut à x?.	a|b	« a », « b »	chaîne vide, « ab », « c »
[liste]	Un des caractères entre crochets (« classe de caractères »)	[aeiou]	« a », « e », « i », …	chaîne vide, « b », « ae »
[^liste]	Un caractère n’étant pas entre crochets (« classe de caractères »)	[^aeiou]	« b », …	chaîne vide, « a », « bc »
(expr)	Groupement de l’expression entre parenthèses	(détecté)	« détecté »	« détect », « détecta », « détectés »
expr{n}	Exactement n occurrences de l’expression précédant les accolades	a{3}	« aaa »	« aa », « aaaa »
expr{n,m}	Entre n et m occurrences de l’expression précédant les accolades	a{2,4}	« aa », « aaa », « aaaa »	« a », « aaaaa »
expr{n,}	Au moins n occurrences de l’expression précédant les accolades	a{3,}	« aaa », « aaaa », « aaaaa »	« aa »
^	Ce prédicat ne correspond à aucun caractère mais fixe une condition nécessaire permettant de trouver un accord sur ce qui le suit en indiquant que ce doit être au début d’une ligne (donc être au début du texte d’entrée ou après un saut de ligne). Il ne peut être considéré ainsi qu’au début de l’expression régulière, ailleurs il est considéré littéralement. Il s’applique comme condition à la totalité du reste de l’expression régulière (et concerne donc toutes les alternatives représentées).	^a trouve « a » en début de ligne mais pas dans « ba ».
$	Ce prédicat ne correspond à aucun caractère mais fixe une condition nécessaire permettant de trouver un accord sur ce qui le précède en indiquant que ce doit être à la fin d’une ligne (donc être à la fin du texte d’entrée ou juste avant un saut de ligne). Il ne peut être considéré ainsi qu’à la fin de l’expression régulière, ailleurs il est considéré littéralement. Il s’applique comme condition à la totalité du reste de l’expression régulière (et concerne donc toutes les alternatives représentées).	a$ trouve « a » en fin de ligne mais pas dans « ab ».

Classe de caractères

Entre les crochets, les métacaractères sont interprétés de manière littérale : [.?*] désigne l’ensemble constitué des caractères « . », « ? » et « * ».

Standardisation et application

 

POSIX		perl, Python	Vim			ASCII	Description
						[\x00-\x7F]	Caractères ASCII
[:alnum:]						A-Za-z0-9	Caractères alphanumériques
		\w	\w			A-Za-z0-9_	Caractères alphanumériques, et « _ »
		\W	\W			^A-Za-z0-9_	Caractères ne composant pas les mots
[:alpha:]			\a			A-Za-z	Caractères alphabétiques
[:blank:]			\s			\t	Espace et tabulation
		\b	\< \>			(?<=\W)(?=\w)|(?<=\w)(?=\W)	Positions de début et fin de mots
		\B				(?<=\W)(?=\W)|(?<=\w)(?=\w)	Positions ne correspondant pas à un début ou une fin de mot
[:cntrl:]						\x00-\x1F\x7F	Caractères de contrôle
[:digit:]		\d	\d			0-9	Chiffres décimaux
		\D	\D			^0-9	Autre chose qu’un chiffre décimal
[:graph:]						\x21-\x7E	Caractères visibles
[:lower:]			\l			a-z	Lettres en minuscule
[:print:]			\p			\x20-\x7E	Caractères imprimables
[:punct:]						][!"#$%&'()*+,./:;<=>?@\^_`{|}~-	Caractères de ponctuation
[:space:]		\s	\_s			\t\r\n\v\f	Caractères d’espacement
		\S	\S			^ \t\r\n\v\f	Autre chose qu’un caractère d’espacement
[:upper:]			\u			A-Z	Lettres capitales
[:xdigit:]			\x			A-Fa-f0-9	Chiffres hexadécimaux
		\A					Début de chaîne de caractère
		\Z					Fin de chaîne de caractère

 

dans le standard POSIX, [[:upper:]ab] fait correspondre un caractère parmi l’ensemble formé par les lettres capitales et les lettres minuscules « a » et « b ». Dans le standard ASCII, cette expression régulière s’écrirait [A-Zab].

Classe d’équivalence

dans la locale FR, la classe [=e=] regroupe l’ensemble des lettres {e, é, è, ë, ê}.

Ceci signifie que lorsqu’elles sont collationnées, les lettres {e, é, è, ë, ê} apparaissent dans le même jeu de caractères, après le d, et avant le f.

Fonctions avancées

Quantificateurs non gloutons : Par défaut, les quantificateurs « + » et « * » recherchent la plus grande séquence correspondant au motif recherché. Ces nouveaux quantificateurs, souvent notés « +? » et « *? », permettent à l’inverse de rechercher la plus petite séquence correspondante. Par exemple, l’expression régulière ab+? appliquée à la chaîne « abbbbc » entre en correspondance avec la sous-chaîne « ab » plutôt que « abbbb ».


 

Capture des groupements : La capture des groupements permet de réutiliser un groupement entré en correspondance pour un traitement ultérieur, par exemple une substitution. Dans la plupart des syntaxes, il est possible d’accéder au n^ème groupement capturé par la syntaxe « \n » ou parfois « $n », où n est un entier.


 

Groupements non capturants : Lorsqu’elle est implémentée, la capture des groupements est souvent le comportement par défaut. Comme elle a un coût algorithmique important, il est parfois possible de désactiver la capture de certains groupements. On peut par exemple citer la syntaxe « (?:groupement) ».


 

Captures nommées : Les longues expressions régulières avec de nombreux groupements peuvent être complexes à lire et à maintenir. Pour faciliter cette tâche, certains moteurs permettent de nommer les groupements, par exemple avec la syntaxe « (?P<nom>groupement) » en Python.


 

Références arrières : Les références arrières permettent de faire référence à un même groupement capturé. Par exemple « b(.)b\1 » entrera en correspondance avec « bébé » et « bobo » mais pas « baby ». Cette fonctionnalité, proposée par la plupart des moteurs, permet de reconnaître des langages non rationnels tels que aⁿbaⁿ pour tout n entier positif.


 

Modificateurs de mode de correspondance : ces modificateurs permettent de faire varier localement le comportement de l’expression régulière. Par exemple, alors qu’elles sont normalement sensibles à la casse, l’expression perl « (?i:nom)-Prénom » entrera en correspondance avec « NOM-Prénom » et « Nom-Prénom » mais pas « Nom-prénom ». Parmi les autres modificateurs, on peut citer le mode multi-lignes, le mode non-gourmand ou le « free-spacing mode ».


 

Conditions : certains moteurs permettent de construire des structures « if … then … else … » au sein-même des expressions régulières. Par exemple, en perl, l’expression « ^(?(?=[abc])[def]|[ghi]) » se lit : « si la chaîne commence par la lettre a, b ou c, chercher à leur suite la lettre d, e ou f, sinon chercher la lettre g, h ou i. »

 

Code embarqué : Lorsqu’une expression régulière est utilisée au sein d’un programme cette fonctionnalité permet de déclencher des actions lorsqu’une partie de la chaîne est entrée en correspondance.

Notations : implémentations et standardisation

Les notations utilisées sont très variables. Ce chapitre regroupe d’une part les notations propres à différentes implémentations, et d’autre part, l’entreprise de normalisation.

POSIX

POSIX ajoute le support pour des plates-formes utilisant un jeu de caractère non basé sur l’ASCII, notamment EBCDIC, et un support partiel des locales pour certains méta-caractères. sed, GNU grep, ed ou vi utilisent par défaut la norme BRE (« Basic Regular Expression ») de POSIX. Dans celle-ci, les accolades, les parenthèses, le symbole « ? » et le symbole « + » ne sont pas des métacaractères : ils ne représentent qu’eux même. Pour prendre leur sémantique de métacaractères, ils ont besoin d’être échappés par le symbole « \ ».

Exemple : l’expression régulière (ab.)+ reconnaît « (abc)+ » mais pas « abcabd », pour laquelle \(ab.\)\+ convient.

Expressions régulières étendues

Les expressions régulières étendues POSIX (ERE pour « Extented Regular Expression ») sont souvent supportées dans les utilitaires des distributions Unix et GNU/Linux en incluant le drapeau -E dans la ligne de commande d’invocation de ces utilitaires. Contrairement aux expressions régulières basiques, elles reconnaissent les caractères vus précédemment comme des métacaractères. Ils doivent ainsi être échappés pour être interprétés littéralement.

La plupart des exemples donnés en présentation sont des expressions régulières étendues POSIX.

Séquences d’échappement

(, ), [, ], ., *, ?, +, ^, |, $ , - et \

Python

Python utilise des expressions régulières basées sur les expressions régulières POSIX, avec quelques extensions ou différences.

Les éléments compatibles POSIX sont les suivants :

opérateurs [ ], ., *, ?, +, |, ( )
caractères \t, \n, \v, \f, \r
\ooo : caractère littéral dont le code octal (entre 0 et 377, sur 1 à 3 chiffres) est ooo.
\xNN : caractère littéral dont le code hexadécimal est NN (sur 2 chiffres).

La séquence \b désigne le caractère de retour arrière (0×08 avec un codage compatible ASCII) lorsqu’elle est utilisée à l’intérieur d’une classe de caractère, et la limite d’un mot autrement.

PHP

PHP supporte deux formes de notations : la syntaxe POSIX et celle, beaucoup plus riche et performante, de la bibliothèque PCRE (Perl Compatible Regular Expression).

Un des défauts reprochés à PHP est lié à son support limité des chaînes de caractères, alors même qu’il est principalement utilisé pour traiter du texte, puisque le texte ne peut y être représenté que dans un jeu de caractères codés sur 8 bits, sans pouvoir préciser clairement quel codage est utilisé. En pratique, il faut donc adjoindre à PHP des bibliothèques de support pour le codage et le décodage des textes, ne serait-ce que pour les représenter en UTF-8. Toutefois, même en UTF-8, le problème se pose immédiatement avec la sémantique des expressions régulières puisque les caractères ont alors un codage de longueur variable, qui nécessite de complexifier les expressions régulières.^{[réf. nécessaire]} Des extensions optionnelles de PHP sont donc développées pour créer un nouveau type de donnée pour le texte, afin de faciliter son traitement (et être à terme compatible avec Perl6 qui, comme Haskell, disposera nativement du support intégral d’Unicode).


Les ensembles de caractères

[a-zA-Z]{6}

permet de sélectionner les parties du texte où il y a 6 lettres consécutives. Celle-ci :

[0-9]{2,4}

permet de sélectionner les parties du texte où il y a entre 2 et 4 chiffres consécutifs. Comme pour les ensembles de caractères, il existe aussi des quantificateurs préconçus.

EXPRESSIONS TYPES

cas pratiques PHP

numéro de téléphone est correcte

rechercher les numéros français, commençant par 0 ou +33 et possédant 9 chiffres sans compter le 0 ou +33. Ainsi, voici une écriture possible de celle-ci :

 

(0|\+33)[1-9]( *[0-9]{2}){4}

 

Peut-être venez vous de remarquer l’apparition de parenthèses. Celles-ci permettent de créer des suites (ou groupe) de caractères et de les stocker en mémoire. Ainsi, si, par exemple, le caractère précédent un quantificateur est en fait une suite de caractère, ce n’est pas le caractère précédent mais la suite de caractère qui sera répétée plusieurs fois. Voici maintenant ce que donne le code PHP entier comprenant la regex :

 

$numero = $_POST['numero'];
if (preg_match('#(0|\+33)[1-9]( *[0-9]{2}){4}#', $numero)) {
    echo "Le numéro de téléphone entré est correct.";
} else {
    echo "Le numéro de téléphone entré est incorrect.";
}

 

Là aussi, 2 remarques sont à faire sur ce code :

la fonction preg_match fait son apparition : celle-ci prend en paramètre la regex ainsi que le texte dans lequel chercher et retourne true si la chaîne a été trouvée dans le texte, false sinon.
l’ajout d’un dièse # avant et après notre regex. Celui, pas forcément un dièse, permet de délimiter le début et la fin de notre regex, et ainsi, offre la possibilité d’ajouter, après le caractère marquant la fin de la regex, des options de recherche comme, par exemple, un i permettant de rendre une regex insensible à la casse

Détecter les liens et les rendre cliquable

Celles-ci commenceront par http ou https, seront suivies de ://, suivies des sous-domaines et du nom de domaine, ne contenant que des chiffres, lettres, tirets et points et une extension de 2 à 4 caractères, suivies enfin du chemin d’accès (facultatif) comprenant tous les caractères sauf l’espace. Voici donc une regex possible pour rechercher des url :

 

https?://[a-zA-Z0-9\.-]+\.[a-zA-Z]{2,4}(/\S*)?

 

\S signifie tout sauf l’espace et où, petit rappel, le ? permet de rendre facultatif le caractère le précédent. Voici maintenant le code entier :

 

$message = $_POST['message'];
$message = preg_replace(
    '#https?://[a-zA-Z0-9-\.]+\.[a-zA-Z]{2,4}(/\S*)?#',
    '<a href="$0" target="_blank">$0</a>',
    $message
);
echo $message;

 

vous remarquer l’apparition d’une nouvelle fonction, preg_replace, permettant de remplacer des caractères dans un texte en utilisant les regex. Celle-ci prend en paramètre la regex, la chaîne de remplacement, et le texte contenant les chaînes à remplacer, et retourne le texte une fois les remplacements effectués.

Vous avez aussi pu remarquer la présence de $0 (appelées référence) dans le second paramètre de cette fonction. Ces références correspondent au texte satisfaisant toute la regex. D’autres références existent comme $1, $2, $3… qui, elles, correspondent au texte satisfaisant la première parenthèse de la regex, la seconde, la troisième… Si vous n’avez pas bien compris le fonctionnement de ces références, je vous conseille de bien regarder les exemples données dans la documentation PHP de cette fonction.

Commentaires

Quelqu’un pourrait me donner une expression régulière pour trouver exactement l’ensemble de formes des verbes "définir et redéfinir" au présent et à l’imparfait?

En 1er tu te crée un array avec tous les mots des 2 verbes :
$aArray[2] = ["définis", "définit"] ; Tu adaptes la taille de ton array en fonction du nombre de mots que tu auras mis dans tes crochets

Ensuite tu crée ton array dans une boucle "For" qui parcours les mots de ton array avec dans ta boucle ta regex qui contiendra en variable ton array.

 

enlever les espaces entre ":" et le début de la réponse…

OS Configuration: Member Workstation
OS Version: 10.0.16299
Site Name: N/A
Roaming Profile: N/A
Local Profile: C:\Users\aregnier
Connected over a slow link?: No

 

[^:]+:\s?[^:]+

ca fonctionne chez moi

 

Bonjour et Merci pour cet article très intéressant. Alors si j’ai bien compris, les regex facilitent beaucoup la recherche de la présence de caractères ou d’une séquence de caractères par contre elles sont limitées dans la mesure ou elles ne permettent pas de détecter l’absence d’un caractère en particulier… par exemple si j’ai un input de type texte dans un formulaire html dans lequel je souhaite n’accepter que les chaines dépourvues d’espace il m’est impossible de l’écrire en thermes de regex ?
Le seul moyen que j’ai trouvé pour y parvenir est d’écrire la déclaration contraire dans ma regex et d’utiliser la négation dans un langage de programmation (JavaScript dans mon cas)

en JavaScript,
var regex = /\s/;

ensuite quelque-chose comme..

if ( !(document.querySelector("input[type='text']")).textContent).match(regex) ){
// suite du traitement
}

est-ce possible de l’écrire entièrement sous forme de regex afin d’éviter d’utiliser la négation , et dans ce cas comment dois-je écrire ma regex ? (dans le cas ou on n’a pas recours à un langage de programmation par exemple).
Merci :)

 

Bonjour,
J’ai un sujet que je n’arrive pas à résoudre avec notepad++ : je dispose d’un texte de plusieurs lignes, terminée par CR LF. Je dois faire en sorte que toutes les lignes soient comblées avec des espaces à la fin jusqu’à 120 caractères au total par ligne. Je ne vois pas comment faire. Auriez-vous une solution svp ? Merci d’avance.

 

Bonjour, J’ai un validation pattern sur un champ email de ce type
^([\w0-9\.\-])+\@(([a-zA-Z0-9\-])+\.)+[a-zA-Z]{2,4}$
comme puis je faire si je veux interdire le domaine sfr et msn par exemple ?

 

Salut
jai une chaine de charchtère en forme XML de type String. comment pourrai je extraire les infos necessaires entre les tag.

"<customer>  <id>18</id>   <firstname>Sylvia</firstname>Fuller</lastname>  <street>158 - 20th Ave.</street>  <city>Paris</city>
<id>23</id>   <firstname>Martin</firstname>Muster</lastname>  <street>2- 10th Ave.</street> <city>Paris</city>
</customer>"

pas compris quel signe utiliser pour exclure les caracteres qu’on recherche du resultat final: ainsi par exemple quand je traite le nom "titre - artsite" avec [-](.*) j’obtiens "- titre" et (.*)[-] j’obtiens "artiste -" … évidemment je veux retirer "- " dans le premier cas et " -" dans le second! d’avance grand merci si solution de votre part! Jean-claude (c’est du sérieux: j’ai 3000 titres à traiter pour la playlist d’une radio!)

 

Vous avez la bonne regex ! Il vous faut simplement récupérer le contenu qui se trouve entre parenthèses.

 

Merci beaucoup Lucas d’avoir examiné ma situation, le souci c’est que je ne suis pas sur notepad , je dois écrire le résultat sur une ligne de code dans le logiciel qui est supposé implémenter les tags mp3 à partir du nom de fichier … en attachement la capture d’écran correspondante, pour plus de clarté! … avec mon souci mis en évidence le " -" et le "- " qui sont extraits.. en même temps que l’info utile recherchée ! (= le nom de l’artiste tout seul et le nom du titre tout seul) bien cordialement Jean-claude

 

Juste, sur cette page : http://forums.mp3tag.de/?sh…, ils utilisent les $1, $2. Je ne connais pas votre logiciel mais peut-être y a-t-il quelque chose à modifier pour les utiliser…

 

Tout d’abord merci pour ce tutoriel qui permet d’avoir un nouvel espoir. Cependant, je n’y arrive pas après avoir essayé différentes regex..
Je dois uniformiser les numéros de téléphones de 6 000 personnes. Le problème est que ces personnes viennent de différents pays et que je dois uniformiser les numéros comme ceci :
00(indicatif tél)+numéro
Certain de ces numéros ont déjà le format demandé, d’autres ont : 033 1 85 14 65 47 ou encore 33 1 54 85 66 55
D’autre encore n’ont tout simplement rien : 01 45 58 54 58 ou 1 45 85 47 45

Auriez-vous une regex qui pourrai m’aider ? L’idéal serait que cette dernière trouve les mauvais formats et qu’elle les modifient pour que le format soit correct.

Merci d’avance pour votre aide qui me sera très précieuse.

 

@^(0|+33)[1-8]([-. ]?[0-9]{2}){4}$@

 

Je n’ai pas beaucoup de temps pour vous répondre. Ce que je ferai : écrire une régex qui sélectionne tous les numéros qui ont le bon format. Ces numéros là, vous pouvez les mettre de côté, ils sont correctes. Puis ensuite, vous repérez les différents formats qui ne sont pas. Vous écrivez une regex pour chacun d’eux afin de les sélectionner puis vous écrivez pour chacun d’eux une régex les transformant du mauvais format vers le bon.

 

C’est pour mon entreprise, je suis stagiaire et je dois rendre ce boulot pour demain/après demain max! Donc si tu as un peu de temps je ne dis pas non. Il y a un ingénieur dans l’entreprise, je lui parlerai de ce que tu m’as dit. Mais n’hésite pas à m’aider :)
Merci pour ta réponse rapide,
Arnaud

 

Lucas Willems si possible j’aurai besoin de ton Skype pour parler Dév si tu voie ce que je veux dire, et bien sure si cela ne te dérange pas,

 

apparament les Regex continuent de faire parler d’eux … pour dire vrai c’est à force de s’exercer avec qu’on finit par avoir le reflex des bonnes Regex comme motif

 

 

je cherche à utiliser regex sous notepad++ pour changer des commentaires dans un fichier CSS
ma ligne est par exemple :
" border: 1px solid red; /*testin*/ border: 1px solid transparent; /*testout*/ "

Je voudrais avec un regex éliminer (remplacer par rien) les /*testin*/ et /*testout*/
pour obtenir
" border: 1px solid red; border: 1px solid transparent; "
Quoi que je fait c’est toujours toute la chaine entre le premier /* et le dernier */ qui est prise.
Cet exemple est plus difficile car / et * sont des caractères qui implique \/ et \*

 

Cette regex va te permettre de sélectionner tous les commentaires de ton fichier : /(\/\*.*?\*\/)/g
Il te faut comprendre le "non-greedily" quand on ajoute un point d’interrogation.

ce regex me permet d’éliminer tous les commentaires de tous mes fichier CSS en un clic

 

Comment interdire les caractère accentué et les caractère spéciaux avant et après le "@" ? exemple: too.foo@émul.com

[a-z0-9._-]+[^éàèô]+@[^éàèô]+[a-z0-9._-]\.[a-z]{2,4} et je pense que cela pourrait t’aider.

Mohamed Amine concernant le pattern d email, je pense que ça ferait l’affaire :

[a-z0-9._-]+@[a-z0-9._-]\.[a-z]{2,4}

[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,4}

Dans ta regex, tu as oublié le 2ème plus pour mettre plusieurs lettres après le @

 

s/(\d*) +/\1 - /

(\d*) va enregistrer la suite de nombre et la mettre dans \1, ensuite " +" va prendre toute suite d’espace
La partie qui vient ensuite est la chaine de remplacement: \1-

\1 correspond donc à ta suite de chiffres précédement enregistrée et - est le caractère de remplacement pour ta suite d’espaces ;)

 

——-

https://regexr.com/

—

Lookahead et Lookbehind

Positive and Negative Lookahead

Negative lookahead is indispensable if you want to match something not followed by something else. When explaining character classes, this tutorial explained why you cannot use a negated character class to match a q not followed by a u. Negative lookahead provides the solution: q(?!u). The negative lookahead construct is the pair of parentheses, with the opening parenthesis followed by a question mark and an exclamation point. Inside the lookahead, we have the trivial regex u.

Positive lookahead works just the same. q(?=u) matches a q that is followed by a u, without making the u part of the match. The positive lookahead construct is a pair of parentheses, with the opening parenthesis followed by a question mark and an equals sign.

You can use any regular expression inside the lookahead (but not lookbehind, as explained below). Any valid regular expression can be used inside the lookahead. If it contains capturing groups then those groups will capture as normal and backreferences to them will work normally, even outside the lookahead. (The only exception is Tcl, which treats all groups inside lookahead as non-capturing.) The lookahead itself is not a capturing group. It is not included in the count towards numbering the backreferences. If you want to store the match of the regex inside a lookahead, you have to put capturing parentheses around the regex inside the lookahead, like this: (?=(regex)). The other way around will not work, because the lookahead will already have discarded the regex match by the time the capturing group is to store its match.

Regex Engine Internals

First, let’s see how the engine applies q(?!u) to the string Iraq. The first token in the regex is the literal q. As we already know, this causes the engine to traverse the string until the q in the string is matched. The position in the string is now the void after the string. The next token is the lookahead. The engine takes note that it is inside a lookahead construct now, and begins matching the regex inside the lookahead. So the next token is u. This does not match the void after the string. The engine notes that the regex inside the lookahead failed. Because the lookahead is negative, this means that the lookahead has successfully matched at the current position. At this point, the entire regex has matched, and q is returned as the match.

Let’s try applying the same regex to quit. q matches q. The next token is the u inside the lookahead. The next character is the u. These match. The engine advances to the next character: i. However, it is done with the regex inside the lookahead. The engine notes success, and discards the regex match. This causes the engine to step back in the string to u.

Because the lookahead is negative, the successful match inside it causes the lookahead to fail. Since there are no other permutations of this regex, the engine has to start again at the beginning. Since q cannot match anywhere else, the engine reports failure.

Let’s take one more look inside, to make sure you understand the implications of the lookahead. Let’s apply q(?=u)i to quit. The lookahead is now positive and is followed by another token. Again, q matches q and u matches u. Again, the match from the lookahead must be discarded, so the engine steps back from i in the string to u. The lookahead was successful, so the engine continues with i. But i cannot match u. So this match attempt fails. All remaining attempts fail as well, because there are no more q’s in the string.

Positive and Negative Lookbehind

Lookbehind has the same effect, but works backwards. It tells the regex engine to temporarily step backwards in the string, to check if the text inside the lookbehind can be matched there. (?<!a)b matches a "b" that is not preceded by an "a", using negative lookbehind. It doesn’t match cab, but matches the b (and only the b) in bed or debt. (?<=a)b (positive lookbehind) matches the b (and only the b) in cab, but does not match bed or debt.

The construct for positive lookbehind is (?<=text): a pair of parentheses, with the opening parenthesis followed by a question mark, "less than" symbol, and an equals sign. Negative lookbehind is written as (?<!text), using an exclamation point instead of an equals sign.

More Regex Engine Internals

Let’s apply (?<=a)b to thingamabob. The engine starts with the lookbehind and the first character in the string. In this case, the lookbehind tells the engine to step back one character, and see if a can be matched there. The engine cannot step back one character because there are no characters before the t. So the lookbehind fails, and the engine starts again at the next character, the h. (Note that a negative lookbehind would have succeeded here.) Again, the engine temporarily steps back one character to check if an "a" can be found there. It finds a t, so the positive lookbehind fails again.

The lookbehind continues to fail until the regex reaches the m in the string. The engine again steps back one character, and notices that the a can be matched there. The positive lookbehind matches. Because it is zero-length, the current position in the string remains at the m. The next token is b, which cannot match here. The next character is the second a in the string. The engine steps back, and finds out that the m does not match a.

The next character is the first b in the string. The engine steps back and finds out that a satisfies the lookbehind. b matches b, and the entire regex has been matched successfully. It matches one character: the first b in the string.

—

https://www.google.fr/search?ei=54a8XIDbPMWJlwSb_obYBg&q=regex+assertion+example

—

Les assertions… moins simple !

l’assertion \b ou limite de mot \b ne consomme pas de caractère.

On peut donc considérer une assertion simple comme un pointeur qui se trouverait, non pas sur un caractère ou un autre, mais juste entre les deux.
Ce qui en clair signifie que l’assertion simple ne cherche pas à trouver une concordance mais bien à vérifier une position.

Nous allons travailler maintenant avec les assertions proprement dite.
Comme pour les assertions simples, elles se positionnent à un certain endroit et analysent les caractères suivants ou précédents. (lookahead et lookbehind)

/!\ Vous vous souvenez sûrement que j’ai dit de ne pas utiliser le ! comme délimiteur
des PCRE parce qu’il était utilisé dans les assertions.
Vous y êtes là, regardez !
Les assertions sont au nombre de 4 :

Type	Motif	Résultat
Assertion avant positive	(?=motif)	Vrai si le motif est vérifié
Assertion avant negative	(?!motif)	Vrai si le motif échoue
Assertion arrière positive	(?<=motif)	Vrai si le motif est vérifié
Assertion arrière négative	(?<!motif)	Vrai si le motif échoue

Assertion avant => lookahead => déplace le pointeur vers l’avant.
Assertion arrière => lookbehind => déplace le pointeur vers l’arrière.

C’est parti, on va mettre ça en pratique ce sera mieux !

Cela faisait bien longtemps que je vous parlais de l’assertion et de l’emploi de ! comme délimiteur de regex PCRE. Vous ne saviez pas pourquoi et à de multiples reprises vous m’avez demandé de faire un article afin de définir correctement le problème du délimiteur de regex.

Exemple d’une assertion arrière négative :

<?php
$texte = ‘exemple de texte avec des noms des surnoms et des prenoms’;

preg_match(‘#((?<!pre)noms)#’, $texte);

L’exemple suivant va matcher ceci : exemple de texte avec des noms des surnoms et des prenomshttps://www.google.fr/search?ei=54a8XIDbPMWJlwSb_obYBg&q=regex+assertion+example&oq=regex+assertion+exempl&gs_l=psy-ab.1.0.0i22i30j0i13i5i30j0i8i13i30l2.16106963.16115261..16118126…0.0..0.396.4308.2-4j9……0….1..gws-wiz…….0i71j0j0i203j0i22i10i30j33i21j33i160.s0xMZQtRGBo

—

 

l’expression (?:a{6})* valide toutes les chaînes composées d’un nombre de caractères ‘a’ multiple de six.

Les caractères spéciaux sont :

. tout caractère sauf le saut de ligne. Si l’option DOTALL a été spécifiée, il valide tout caractère, saut de ligne compris.

? pour 0 ou 1 répétition de l’expression qui précède. ab? correspondra à “a” ou “ab”.

*?, +?, ?? Les qualificateurs *, + et ? sont gourmands ; ils valident autant de texte que possible. Parfois ce comportement n’est pas désiré ; si l’expression rationnelle <.*> est testée avec la chaîne ‘<a> b <c>’, cela correspondra à la chaîne entière, et non juste à ‘<a>’. Ajouter ? derrière le qualificateur lui fait réaliser l’opération de façon non-greedy (ou minimal) ; le moins de caractères possibles seront validés. Utiliser l’expression rationnelle <.*?> validera uniquement ‘<a>’.

{m} Spécifie qu’exactement m copies de l’expression rationnelle qui précède devront être validées ; un nombre plus faible de correspondances empêche l’expression entière de correspondre. Par exemple, a{6} correspondra exactement à six caractères ‘a’, mais pas à cinq.

{m,n} Fait valider par l’expression rationnelle résultante entre m et n répétitions de l’expression qui précède, cherchant à en valider le plus possible. Par exemple, a{3,5} validera entre 3 et 5 caractères ‘a’. Omettre m revient à spécifier 0 comme borne inférieure, et omettre n à avoir une borne supérieure infinie. Par exemple, a{4,}b correspondra à ‘aaaab’ ou à un millier de caractères ‘a’ suivis d’un ‘b’, mais pas à ‘aaab’. La virgule ne doit pas être omise, auquel cas le modificateur serait confondu avec la forme décrite précédemment.

{m,n}? Fait valider par l’expression rationnelle résultante entre m et n répétitions de l’expression qui précède, cherchant à en valider le moins possible. Il s’agit de la version non gourmande du précédent qualificateur. Par exemple, dans la chaîne de 6 caractères ‘aaaaaa’, a{3,5} trouvera 5 caractères ‘a’, alors que a{3,5}? n’en trouvera que 3.

\ Échappe les caractères spéciaux (permettant d’identifier des caractères comme ‘*’, ‘?’ et autres) ou signale une séquence spéciale ; les séquences spéciales sont décrites ci-dessous. Si vous n’utilisez pas de chaînes brutes pour exprimer le motif, souvenez-vous que Python utilise aussi le backslash comme une séquence d’échappement dans les chaînes littérales ; si la séquence d’échappement n’est pas reconnue par l’interpréteur Python, le backslash et les caractères qui le suivent sont inclus dans la chaîne renvoyée. Cependant, si Python reconnait la séquence, le backslash doit être doublé (pour ne plus être reconnu). C’est assez compliqué et difficile à comprendre, c’est pourquoi il est hautement recommandé d’utiliser des chaînes brutes pour tout sauf les expressions les plus simples.

[]Utilisé pour indiquer un ensemble de caractères. Dans un ensemble :

- Les caractères peuvent être listés individuellement, e.g. [amk] correspondra à ‘a’, ‘m’ ou ‘k’.

- Des intervalles de caractères peuvent être indiqués en donnant deux caractères et les séparant par un ‘-’, par exemple [a-z] correspondra à toute lettre minuscule ASCII, [0-5][0-9] à tous nombres de deux chiffres entre 00` et ``59, et [0-9A-Fa-f] correspondra à n’importe quel chiffre hexadécimal. Si ‘-’ est échappé ([a\-z]) ou s’il est placé comme premier ou dernier caractère (e.g. [-a] ou [a-]), il correspondra à un ‘-’ littéral.

- Les caractères spéciaux perdent leur sens à l’intérieur des ensembles. Par exemple, [(+*)] validera chacun des caractères littéraux ‘(‘, ‘+’, ‘*’ ou ‘)’.

Les classes de caractères telles que \w ou \S (définies ci-dessous) sont aussi acceptées à l’intérieur d’un ensemble, bien que les caractères correspondant dépendent de quel mode est actif entre ASCII et LOCALE.

Les caractères qui ne sont pas dans un intervalle peuvent être trouvés avec l’ensemble complémentaire (complementing). Si le premier caractère de l’ensemble est ‘^’, tous les caractères qui ne sont pas dans l’ensemble seront validés. Par exemple, [^5] correspondra à tout caractère autre que ’5′ et [^^] validera n’importe quel caractère excepté ‘^’. ^ n’a pas de sens particulier s’il n’est pas le premier caractère de l’ensemble.

Pour insérer un ‘]’ littéral dans un ensemble, il faut le précéder d’un backslash ou le placer au début de l’ensemble. Par exemple, [()[\]{}] et []()[{}] vont tous deux correspondre à une parenthèse, un crochet ou une accolade.

 

Pour valider un ‘|’ littéral, utilisez \|, ou enveloppez-le dans une classe de caractères, comme [|].

 

(…)Valide n’importe quelle expression rationnelle comprise entre les parenthèses, et indique le début et la fin d’un groupe ; le contenu d’un groupe peut être récupéré après qu’une analyse a été effectuée et peut être réutilisé plus loin dans la chaîne avec une séquence spéciale \number, décrite ci-dessous. Pour écrire des ‘(‘ ou ‘)’ littéraux, utilisez \( ou \), ou enveloppez-les dans une classe de caractères : [(], [)].

 

(?…)Il s’agit d’une notation pour les extensions (un ‘?’ suivant une ‘(‘ n’a pas de sens autrement). Le premier caractère après le ‘?’ détermine quel sens donner à l’expression. Les extensions ne créent généralement pas de nouveaux groupes ; (?P<name>…) est la seule exception à la règle. Retrouvez ci-dessous la liste des extensions actuellement supportées.

 

(?aiLmsux) (Une lettre ou plus de l’ensemble ‘a’, ‘i’, ‘L’, ‘m’, ‘s’, ‘u’, ‘x’.) Le groupe valide la chaîne vide ; les lettres activent les modes correspondant : re.A (validation ASCII seulement), re.I (ignorer la casse)`, re.L (dépendant de la locale), re.M (multi-ligne), re.S (les points correspondent à tous les caractères), re.U (support d’Unicode) et re.X (verbeux), pour l’ensemble de l’expression rationnelle. (Les options dans décrites dans la section Contenu du module.) C’est utile si vous souhaitez préciser l’option dans l’expression rationnelle, plutôt qu’en passant un argument flag à la fonction re.compile(). Les options devraient être spécifiées en premier dans la chaîne de l’expression.

 

(?:…) Une version sans capture des parenthèses habituelles. Valide n’importe quelle expression rationnelle à l’intérieur des parenthèses, mais la sous-chaîne correspondant au groupe ne peut pas être récupérée après l’analyse ou être référencée plus loin dans le motif.

 

(?imsx-imsx:…)(Zéro lettres ou plus de l’ensemble ‘i’, ‘m’, ‘s’, ‘x’, optionnellement suivies par ‘-’ ainsi qu’une ou plusieurs lettres du même ensemble.) Les lettres activent ou désactivent les options correspondantes : re.I (ignorer la casse), re.M (multi-ligne), re.S (les points correspondent à tous les caractères) et re.X (verbeux), pour cette partie de l’expression. (Les options sont décrites dans la section Contenu du module.)

Nouveau dans la version 3.6.

 

(?P<name>…) Similaires aux parenthèses habituelles, mais la sous-chaîne validée par le groupe est accessible via le nom name du groupe symbolique. Les noms de groupes doivent être des identifiants Python valides, et chaque nom de groupe ne doit être défini qu’une seule fois dans une expression rationnelle. Un groupe symbolique est aussi un groupe numéroté, de la même manière que si le groupe n’était pas nommé.

Les groupes nommés peuvent être référencés dans trois contextes. Si le motif est (?P<quote>['"]).*?(?P=quote) (i.e. correspondant à une chaîne entourée de guillemets simples ou doubles) :

 

lui-même dans le même motif

• (?P=quote) (comme vu)
• \1

en analysant l’objet résultat m

• m.group(‘quote’)
• m.end(‘quote’) (etc.)

dans une chaîne passée à l’argument repl de re.sub()

• \g<quote>
• \g<1>
• \1

 

(?P=name) Une référence arrière à un groupe nommé ; elle correspond à n’importe quel texte validé plus tôt par le groupe nommé name.

(?#…) Un commentaire ; le contenu des parenthèses est simplement ignoré.

(?=…) Valide si … valide la suite, mais ne consomme rien de la chaîne. On appelle cela une assertion lookahead. Par exemple, Isaac (?=Asimov) correspondra à la chaîne ‘Isaac’ `` seulement si elle est suivie par ``’Asimov’.

(?!…) Valide si … ne valide pas la suite. C’est une assertion negative lookahead. Par exemple, Isaac (?!Asimov) correspondra à la chaîne ‘Isaac ‘ seulement si elle n’est pas suivie par ‘Asimov’.

(?<=…) Valide si la position courante dans la chaîne est précédée par une correspondance sur … qui se termine à la position courante. On appelle cela une positive lookbehind assertion. (?<=abc)def cherchera une correspondance dans ‘abcdef’, puisque le lookbehind* mettra de côté 3 caractères et vérifiera que le motif contenu correspond. Le motif ne devra correspondre qu’à des chaînes de taille fixe, cela veut dire que abc ou a|b` sont autorisées, mais pas ``a* ou a{3,4}. Notez que les motifs qui commencent par des assertions lookbehind positives ne peuvent pas correspondre au début de la chaîne analysée ;

 

(?<!…) Valide si la position courante dans la chaîne n’est pas précédée par une correspondance sur …. On appelle cela une negative lookbehind assertion. À la manière des assertions lookbehind positives, le motif contenu ne peut que correspondre à des chaînes de taille fixe. Les motifs débutant par une assertion lookbehind négative peuvent correspondre au début de la chaîne analysée.

 

(?(id/name)yes-pattern|no-pattern) Essaiera de faire la correspondance avec yes-pattern si le groupe indiqué par id ou name existe, et avec no-pattern s’il n’existe pas. no-pattern est optionnel et peut être omis. Par exemple, (<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) est un motif simpliste pour identifier une adresse courriel, qui validera ‘<user@host.com>’ ainsi que ‘user@host.com’ mais pas ‘<user@host.com’ ni ‘user@host.com>’.

Les séquences spéciales sont composées de ‘\’ et d’un caractère de la liste qui suit. Si le caractère ordinaire n’est pas un chiffre ASCII ou une lettre ASCII, alors l’expression rationnelle résultante validera le second caractère de la séquence. Par exemple, \$ correspond au caractère ‘$’.

 

\number contenu du groupe du même nombre. Les groupes sont numérotés à partir de 1. Par exemple, (.+) \1 correspond à ‘the the’ ou ’55 55′, mais pas à ‘thethe’ (notez l’espace après le groupe). Cette séquence spéciale ne peut être utilisée que pour faire référence aux 99 premiers groupes. Si le premier chiffre de number est 0, ou si number est un nombre octal de 3 chiffres, il ne sera pas interprété comme une référence à un groupe, mais comme le caractère à la valeur octale number. À l’intérieur des ‘[' et ']‘ d’une classe de caractères, tous les échappements numériques sont traités comme des caractères.

 

\A uniquement au début d’une chaîne de caractères.

 

\b chaîne vide, mais uniquement au début ou à la fin d’un mot. Un mot est défini comme une séquence de « caractères de mots ». Notez que formellement, \b est défini comme la liaison entre \w et \W (et inversement), ou entre \w et le début/fin d’un mot. Cela signifie que r’\bfoo\b’ validera ‘foo’, ‘foo.’, ‘(foo)’ ou ‘bar foo baz’ mais pas ‘foobar’ ou ‘foo3′.

Les caractères alphanumériques Unicode sont utilisés par défaut dans les motifs Unicode, mais cela peut être changé en utilisant l’option ASCII. Les délimitations de mots sont déterminées par la locale si l’option LOCALE est utilisée. À l’intérieur d’un intervalle de caractères, \b représente le caractère backspace, par compatibilité avec les chaînes littérales Python.

 

\B Correspond à la chaîne vide, mais uniquement quand elle n’est pas au début ou à la fin d’un mot. Cela signifie que r’py\B’ valide ‘python’, ‘py3′ ou ‘py2′, mais pas ‘py’, ‘py.’ ou ‘py!’. \B est simplement l’opposé de \b, donc les caractères de mots dans les motifs Unicode sont les alphanumériques et tirets bas Unicode, bien que cela puisse être changé avec l’option ASCII. Les délimitations de mots sont déterminées par la locale si l’option LOCALE est utilisée.

 

\d n’importe quel chiffre décimal [0-9]

 

\D tout caractère qui n’est pas un chiffre décimal. C’est l’opposé de \d.

 

\s caractères d’espacement ([ \t\n\r\f\v] et bien d’autres, comme les espaces insécables).

 

\S tout caractère qui n’est pas un caractère d’espacement. c’est l’opposé de \s.

 

\w caractères de mot ; cela inclut aussi les nombres et les tirets bas. [a-zA-Z0-9_]

 

\W tout caractère qui n’est pas un caractère de mot. C’est l’opposé de \w.

 

\Z Correspond uniquement à la fin d’une chaîne de caractères.

La plupart des échappements standards supportés par les chaînes littérales sont aussi acceptés par l’analyseur d’expressions rationnelles :

 

\a      \b      \f      \n
\r      \t      \u      \U
\v      \x      \\

(Notez que \b est utilisé pour représenter les bornes d’un mot, et signifie « backspace » uniquement à l’intérieur d’une classe de caractères.)

 

\u et \U sont seulement reconnues dans les motifs Unicode. Dans les motifs de byte, ce sont des erreurs.

Les séquences octales d’échappement sont incluses dans une forme limitée. Si le premier chiffre est un 0, ou s’il y a trois chiffres octaux, la séquence est considérée comme octale. Autrement, il s’agit d’une référence vers un groupe. Comme pour les chaînes littérales, les séquences octales ne font jamais plus de 3 caractères de long.