nsi json sequence 33 regex 2/3

[[{"text":"Remplir les champs ci-dessous :","title":"Python : Les expressions régulières 2/3","posi":0},{"edit":"Nom : "},{"edit":"Prénom : "},{"edit":"Classe : "},{"text":"

Source de l'image :

https://medium.com/better-programming/working-with-regular-expressions-regex-in-javascript-6c7dd951574a

"}],[{"text":"

Les opérateurs vus dans la séquence précédente permettent de répondre aux problèmes liés à la répétition d'un caractère. Le seul joker dont on dispose est le point (sous deux acceptions, avec ou sans fin de ligne). La première extension souhaitable est de diversifier les jokers.

","title":"Introduction"},{"edit":"

"}],[{"text":"

Les. jeux de caractères définis ou classes.

Au lieu de dire \"tout caractère\" comme avec le joker \"point\", on peut définir en extension un jeu de caractères. La syntaxe est simple :

[caractères du jeu]

Les caractères sont écrits en suivant, dans une suite sans espacements :

[abcABC$*+]

est le jeu (la classe) des 9 caractères a,b,c,A,B,C,$,*,+

Il n'est pas utile d'échapper les caractères litigieux des expressions régulières comme *, +, . etc.

C'est une bonne méthode de protection : on écrit [*] au lieu de \\*

Il existe une forme abrégée pour les séquences :

premier et dernier caractère séparés par un trait

d'union : [a-z] pour une minuscule, [A-Z] pour une majuscule, [0-9] pour un chiffre.

C'est ainsi que [a-zA-Z] équivaut à \"toute lettre ASCII\".

Le jeu [À-ÿ] est tout à fait valide.

Une définition de jeu peut être définie par exclusion :

il suffit de commencer par ^.

Par exemple :

- le jeu [^5] définit tout caractère sauf 5.

- [^0-9] : tout caractère sauf un chiffre.

Pour éviter certaines protections lourdes, on peut définir des jeux à un caractère :

[*], ou [+], ou [\\\\] ; cela remplace avantageusement \\* \\+ ou \\\\\\\\

Remarque : Le caractère ^ doit être protégé lorsque son utilisation est littérale, soit en début d'expression, soit en début de jeu de caractère : [\\^abcd]; [\\^]. On ne peut pas écrire [^].

","title":"Diversifier les jokers et marqueurs"},{"edit":"

"}],[{"text":"

Certaines classes sont prédéfinies, ainsi que certains marqueurs :

Jeu prédéfini	Signification
\\A	trouver uniquement au début de la chaîne. Ressemble à ^ mais n'est pas affecté par la directive MULTILINE.
\\b	\\b est réservé en python (c'est le backspace) ; il faut donc écrire \\\\b pour utiliser dans une chaîne Python. Le caractère qui suit est en début ou fin de mot.
\\B	le caractère qui suit n'est ni en début de mot, ni en fin de mot.
\\d	équivalent de [0-9]
\\D	tout caractère sauf un chiffre
\\s	équivaut à [ \\b\\t\\n\\r\\f\\v], espace, backspace, tabulation, fin de ligne(LF), début de ligne (CR), à la ligne (FF), tabulation verticale. On désigne parfois ces caractères comme des blancs.
\\S	tout caractère sauf ceux de \\s
\\w	équivalent à [a-zA-Z0-9_], caractères alphanumériques. Peut être affecté par la directive LOCALE.
\\W	tout caractère non alphanumérique
\\Z	trouve uniquement en fin de la chaîne. Ressemble à $ mais est insensible à la directive MULTILINE.

","title":"Classes et marqueurs usuels prédéfinis"},{"edit":"

"}],[{"text":"

En calcul numérique, on utilise les parenthèses pour hiérarchiser les opérations. Il en est de même pour les expressions régulières.

On peut parenthéser une sous-expression régulière et lui appliquer les opérateurs d'itération vus pour les caractères.

ATTENTION : Le parenthésage a une syntaxe peu intuitive et déroutante :

(?:expression régulière)

","title":"Parenthésage : analogie mathématique"},{"edit":"

"}],[{"text":"

Problème : examiner si une chaîne est une adresse mail valide.

Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.

Une adresse mail comporte une ou deux chaînes alphanumériques ; dans ce second cas, un point les sépare.

Le caractère @ suit. La seconde partie est constituée d'une suite d'au moins deux chaînes alphanumériques séparées par un point.

import re

textes1 = [Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.', \"Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.\",

\"Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.\",'zorlubfree.fr']

textes2 = ['zorlub@free', \"Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.\",

\"Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.. fr\",\"Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser. \"]

g_patron = \"^\\w+(?:[.]\\w+)?\" # partie gauche

d_patron = \"\\w+(?:[.]\\w+)+$ \"# partie droite

cpatron = re.compile(g_patron+\"@\"+d_patron)

#teste les 2 listes de mails

for x in textes1 + textes2:

res = cpatron.search(x)

if res:

print (x, \"est correct\")

else:

print (x, \"n'est pas une adresse valide\")

Ecrire et tester le code ci-dessous.

Justifier la forme de l'expression régulière.

","title":"Application"},{"edit":"

Ecrire les résultats ici.

"}],[{"text":"

Deux analyses en pipeline.

Que se passe-t-il entre la lecture du source d'une expression régulière et l'édition d'un patron compilé qui est utilisé par les méthodes search(), match(), findall(), sub() et split()?

patron = chaîne_source

cpatron = compile(patron)

Il y a deux étapes au niveau lexical : l'analyseur de chaîne Python lit la chaîne source et la traite :

il en sort une chaîne interne dans le format de stockage de Python. C'est à ce niveau que sont traités les caractères spéciaux comme le backslash (\\b) et la fin de ligne (\\n).

Puis l'analyseur lexical de la machine d'analyse des expressions régulières prend le relai et isole les unités lexicales que comprend l'analyseur d'E.R.. Les jokers, les marqueurs, les expressions sont de telles unités lexicales.

On a figuré deux éléments qui relèvent de l'analyse syntaxique (classe, chaîne).

","title":"La double analyse lexicale"},{"edit":"

"}],[{"text":"

Lorsque Python réalise l'analyse lexicale d'une chaîne littérale pour en créer la représentation interne, il lit la représentation littérale (flot d'entrée) de gauche à droite pour en dégager les unités lexicales, qui seront ensuite codées comme un caractère (flot de sortie) :

- l'antislash en fin de ligne est ignoré (chaînes sur plusieurs lignes). Le changement de ligne qui suit est ignoré également.

Un analyseur lexical prend un flot de caractères sur son entrée standard, isole les unités lexicales, et envoie un flot d'unités lexicales sur sa sortie standard. Une unité lexicale peut être un identificateur, un mot réservé du langage, un signe (+ - * / ! etc), un délimiteur (parenthèse, accolade, crochet, /*, */ etc), c'est-à-dire toute unité pertinente pour l'analyse syntaxique.

- les unités lexicales tiennent en général sur un seul caractère ; c'est le cas des caractères alphanumériques ou des caractères accentués ou de la ponctuation par exemple.

- certaines unités ont besoin de deux caractères dans la chaîne littérale : par exemple la fin de ligne est notée \\n, le backspace \\b, la tabulation \\t. Ces couples correspondent à une seule unité lexicale (un caractère dans la chaîne interne).

- certaines peuvent tenir sur un ou deux caractères sans poser de difficulté : \\\" et \\'. En effet, les caractères \" et ' étant des délimiteurs, leur échappement par l'antislash permet de les considérer comme des littéraux. Ainsi si on pose :

maChaine ='papa \"Noël\" s\\'est envolé'

taChaine = 'papa \\\"Noël\\\" s\\'est envolé'

saChaine ='papa \\\"Noël\" s\\'est envolé'

print (maChaine==taChaine,maChaine==saChaine)

on peut vérifier que les trois chaînes sont similaires.

- la difficulté apparaît lorsque l'on utilise l'antislash. L'antislash peut s'échapper lui-même : c'est sans ambigüité ; même chose pour \" et '. Mais qu'en est-il s'il précède un caractère qui ne peut être échappé. Comme par exemple un espace,les caractères c, d, w, ...

L'antislash est alors considéré comme littéral !

exemple :

print(\"\\c\\d\\w\") donne : \\c\\d\\w

- enfin, plus délicat encore certaines séquences antislashées introduisent des séquences spécifiques, comme par exemple des séquences unicodes ou numériques (cas de \\u \\U \\x \\N)

Voici ce que dit la documentation officielle :

Escape Sequence	Meaning
\\newline	Backslash and newline ignored
\\\\	Backslash (\\)
\\'	Single quote (')
\\\"	Double quote (\")
\\a	ASCII Bell (BEL)
\\b	ASCII Backspace (BS)
\\f	ASCII Formfeed (FF)
\\n	ASCII Linefeed (LF)
\\r	ASCII Carriage Return (CR)
\\t	ASCII Horizontal Tab (TAB)
\\v	ASCII Vertical Tab (VT)
\\ooo	Character with octal value ooo
\\xhh	Character with hex value hh

Escape sequences only recognized in string literals are:

Escape Sequence	Meaning
\\N{name}	Character named name in the Unicode database
\\uxxxx	Character with 16-bit hex value xxxx
\\Uxxxxxxxx	Character with 32-bit hex value xxxxxxxx

Applications :

La chaîne \"\\123\" donne le caractère de code octal 123 en Unicode, soit S (code 64+2x8+3 = 83) :

print(ord(\"\\123\"), \"123\")

La chaîne \"\\u00b5\" donne le μ de code 181 :

print(ord(\"\\u00b5\"), \"\\u00b5\")

Tester et verifier les résultats des instructions ci-dessus.

Chaque caractère unicode a un nom (importer le module unicode):

import unicodedata

print (ord(\"\\u00b5\"), \"\\u00b5\", unicodedata.name(\"\\u00b5\"))

Tester le code précédent.

D'où la liste des caractères alphanumériques pour lesquelles l'antislash n'est pas un littéral

On insiste bien sur le fait que l'analyse lexicale de Python s'applique à tout ce qui se trouve sur le flot d'entrée de l'analyseur, texte comme patron.

","title":"L'échappement dans les chaînes en Python."},{"edit":"

Ecrire les résultats ici.

"}],[{"text":"

Lors de la compilation, c'est la chaîne interne de Python qui est examinée par l'analyseur lexical du moteur d'analyse des expressions régulières.

Il y a alors le second niveau d'analyse, qui lui aussi utilise l'antislash pour caractère d'échappement ! Cela ne pose pas de problème avec ^, ( , ) , { , }, w, W, B, 8, 9, $. Il y en a un avec les caractères particuliers qu'il faut échapper à l'aide d'un \\\\ lors de la première analyse lexicale. Il faut prêter une attention particulière aux caractères b, 0, 1, 2, 3, 4, 5, 6, 7.

Quand à l'antislash, comme il est doublement caractère d'échappement, pour l'utiliser comme littéral, il vaut mieux l'échapper pour Python, puis pour l'analyse re, ce qui fait quatre antislash ! \\\\\\\\

","title":" L'échappement des expressions régulières"},{"edit":"

Ecrire ici vos résultats.

"}],[{"text":"

Le problème : les expressions régulières sont particulièrement indigestes. Parmi les faits qui

concourent à une lecture difficile on peut citer :

- l'absence de caractères d'aération, ce que l'on appelle parfois \"les blancs\" : espaces, tabulation, saut de ligne ;

- l'absence de commentaires explicatifs insérés dans l'expression ;

- les difficultés liées au fait que l'on cumule deux niveaux d'analyse : l'analyse lexicale de Python qui donne une première représentation de l'expression, puis l'analyse lexicale du moteur d'expressions régulières. La multiplication des échappements est liée à cet aspect de la question.

Cette difficulté de lecture peut être en partie levée par l'utilisation de techniques appartenant à l'un ou l'autre des analyseurs lexicaux.

Remarque : Dans les exemples qui suivent, la signification des expressions régulières n'a pas à être examinée. Ces exemples illustrent l'aération du patron.

- Caractères particuliers pour l'échappement N U u x 01 2 3 4 5 6 7 a b f n r v

","title":"Donner de l'air aux expressions régulières"},{"edit":"","css":"","js":""}],[{"text":"

En Python, on peut saisir une chaîne sur plusieurs lignes physiques ; il suffit de terminer chaque élément significatif du texte par un antislash suivi d'un passage à la ligne. Attention, après l'antislash il ne doit rien y avoir !

Il y a alors concaténation des segments de texte à l'analyse lexicale.

Application :

import re

textes = \"Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.,Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.,Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.,\\

Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.,Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.,Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.\"

patron = \"\\\\b\\

\\w+\\

(?:[.]\\w+)?\\

@\\

\\w+\\

(?:[.]\\w+)*\\

[.](?:fr|com)\\

\\\\b\"

print(patron,\"\\n\")

cpatron = re.compile(patron)

print (cpatron.findall(textes))

Ecrire et tester le code ci-dessus.

Justifier la mise en forme du code.

","title":"La saisie multiligne des chaînes"},{"edit":"

Ecrire ici le résultat.

"}],[{"text":"

La syntaxe est (?# texte )

Le texte est un commentaire ; il est ignoré.

On doit prendre garde à ce que le commentaire en ligne est un élément de l'expression régulière ; il ne faut pas introduire d'espaces qui seraient pris comme des caractères constitutifs de l'expression.

Application ;

#!/usr/bin/python3

import re

patron = \"\\\\b(?# début de mot)\\

\\w+(?:[.]\\w+)?(?# un ou deux mots séparés par un point)\\

@\\

\\w+(?:[.]\\w+)*(?# un, ou plusieurs mots séparés par un point)\\

[.]\\

(?:fr|com)(?# le dernier étant soit fr soit com)\\

\\\\b(?# fin de mot)\"

print (patron,\"\\n\")

cpatron = re.compile(patron)

print (cpatron.findall(textes))

Ecrire et tester le code ci-dessous.

Quel est l'intérêt de mettre des commentaires dans les expressions régulières?

* On a ici combiné les deux méthodes : le gain de lisibilité est réel mais ce n'est pas encore le grand confort : il manque une aération par des espaces par exemple.

D'autre part, la méthode de l'antislash terminal peut introduire des erreurs peu visibles si on ajoute malencontreusement des blancs.

","title":"Le commentaire en ligne"},{"edit":"

Ecrire ici les résultats.

"}],[{"text":"

La directive VERBOSE a comme effet d'occulter tous les blancs (espaces, tabulations, fin de ligne...) de la chaîne de saisie.

De plus, l'introduction dans une ligne du symbole # a le même effet qu'en Python : il supprime la fin de ligne physique à partir du hashtag (dièse pour les vieux). Encore faut-il qu'il y ait fin de ligne!

La triple quote ( \"\"\" ) s'impose alors ;

- la chaîne délimitée ainsi est prise littéralement, avec ses fins de lignes.

On dispose de l'aération souhaitée, mais au prix d'une perte des blancs et du dièse. Il suffit en général d'utiliser le joker \\s pour résoudre le problème, ou alors de protéger le caractère dans une classe ou avec un antislash.

Application :

#!/usr/bin/python3

import re

patron = \"\"\"

\\\\b # début de mot)

\\w+(?:[.]\\w+)? # un ou deux mots séparés par un point

@\\

\\w+(?:[.]\\w+)* # un, ou plusieurs mots mots séparés par un point

[.]\\

(?:fr|com) # le dernier étant soit fr soit com

\\\\b # fin de mot

\"\"\"

print (patron,\"\\n\")

cpatron = re.compile(patron, re.VERBOSE)

print (cpatron.findall(textes))

Ecrire et tester le code ci-dessous.

Justifier le résultat.

","title":"La directive VERBOSE."},{"edit":"

Ecrire ici vos réponses.

"}],[{"text":"

#!/usr/bin/python3

import re

textes = \"Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser., Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser., Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.,\\

Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser., Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser., Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.\"

cpatron = re.compile(

\"\\\\b\" # début de mot

\"\\w+\" # suite de caractères alphamériques

\"(?:[.]\\w+)?\" # 0 ou 1 point et suite de caractères alphanumériques

\"@\" #

\"\\w+\" # suite de caractères alphamériques

\"(?:[.]\\w+)*\" # x point et suite de caractères alphanumériques

\"[.](?:fr|com)\" # suffixe en fr ou en com

\"\\\\b\" # fin de mot

)

print (cpatron.findall(textes))

On joue ici triplement sur l'implicite : dans une parenthèse, les nouvelles lignes ne sont pas prises en compte ; les commentaires sont ignorés à l'analyse lexicale ; deux chaînes littérales juxtaposées sont concaténées... Cela fonctionne, mais c'est dangereux !

Ecrire et tester le code.

","title":"Jouer sur l'implicite."},{"edit":""}],[{"text":"

Il existe un opérateur de chaîne, r, qui permet de court-circuiter l'analyse lexicale de Python. Il suffit alors de fournir comme patron la chaîne d'entrée de l'analyseur du moteur d'évaluation des expressions régulières.

On y gagne quelques antislashes

#!/usr/bin/python3

import re

patron = r\"\\b\\w+(?:[.]\\w+)?@\\w+(?:[.]\\w+)*[.](?:fr|com)\\b\"

cpatron = re.compile(patron)

print (cpatron.findall(textes))

Ecrire et tester le code ci-dessous.

Conclure sur les différentes manières d'écrire une expression régulière.

","title":"L'opérateur de chaîne r."},{"edit":"

Ecrire ici les résultats.

"}],[{"text":"

Jusque là, on n'a rencontré que des expressions régulières \"additives\". C'est à dire, tout l'ensemble décrit doit correspondre à une sous-chaîne pour que la correspondance soit reconnue.

On peut avoir besoin de chercher une correspondance avec l'une ou l'autre de deux expressions régulières.

Dans ce cas, on les sépare par le symbole | (barre verticale, le Alt gr 6 du clavier / valeur ASCII 124).

On écrit A|B avec A et B comme expressions régulières.

Plusieurs questions se posent avec le ou logique :

- les deux conditions peuvent-elles être satisfaites en même temps ? Cela n'est pas interdit. - dans quel ordre se fait l'évaluation des expressions régulières ? De gauche à droite.

- lorsque l'évaluation de la première expression est satisfaite, la seconde est-elle testée ? La réponse est non. Cette absence de gourmandise peut parfois causer des surprises, puisque la seconde évaluation aurait pu apporter une solution plus \"complète\".

- où s'arrête l'analyse lorsqu'une correspondance est détectée ? l'analyse s'arrête sur le premier caractère non reconnu (ou la fin de chaîne).

- peut-on avoir cet opérateur en série (succession de ou logiques) ou en cascade (insertion d'une expression avec un ou plusieurs ou dans une expression complexe. La réponse est oui. Dans la série, la règle \"de gauche à droite\" s'applique.

note. le caractère | doit être protégé \\| ou constituer un jeu de caractère [|] s'il est littéral 5.2. un exemple sans parenthésage.

Application : On dispose d'un texte comportant des noms de communes. On veut en extraire la liste des noms qui comportent le mot ville (ou Ville) en tant que chaîne terminale, c'est-à-dire suivi par un trait d'union ou en fin de nom. Par exemple Villers n'est pas admis ; mais Maville, Pont-Ville, Hauteville-Cajun, Ville-Sur-Cher le sont.

#!/usr/bin/python3

import re

texte =\"Ablon\\nAcqueville\\nAgy\\nAigner-Ville\\nAiran\\nAmaville-sur-Ville\\

\\nAmblie\\nTrouville\\nAngervillers\\nAngoville\\nArganchy\\

\\nAsnelles\\nAsnières-Surville\\nVille\\nVilleneuve\"

print(\"Liste des villes : \",texte,\"\\n\\n\")

patron = \"^.*ville-.*|^.*ville$\"

cpatron = re.compile (patron,re.MULTILINE+re.IGNORECASE)

resultat = cpatron.findall(texte)

print(\"Resultat : \",resultat)

Ecrire et tester le code ci-dessous.

Remarques :

- le point ne peut être un \\n. En faisant .* on s'arrête automatiquement en fin de ligne si on l'atteint. Par contre dans la seconde partie de l'alternative, le $ est nécessaire.

- dans le cas de Amaville-sur-Ville, seule la première expression est évaluée.

","title":"Expression avec un ou logique"},{"edit":"

Ecrire ici les résultats.

"}],[{"text":"

Exemple 1:

Rechercher dans une liste Python des adresses mail correctes qui ont pour extension terminale .fr ou .com . On rejètera les adresses incorrectes et celles qui n'ont pas la bonne extension.

#!/usr/bin/python3

import re

textes = [\"Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.\",\"Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.\",\"Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.\",

\"Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.\", \"Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.\" ]

patron = \"^\\w+(?:[.]\\w+)?@\\w+(?:[.]\\w+)*[.](?:fr|com)$\"

cpatron = re.compile(patron)

for x in textes:

res = cpatron.search(x)

if res:

print (x)

Ecrire et tester le code ci-dessous.

Exemple 2 :

Le même programme mais en utilisant findall().

#!/usr/bin/python3

import re

patron = \"\\\\b\\w+(?:[.]\\w+)?@\\w+(?:[.]\\w+)*[.](?:fr|com)\\\\b\"

cpatron = re.compile(patron)

print(cpatron.findall(textes))

Ecrire et tester le code ci-dessous.

Expliquer les 2 programmes.

","title":"Exemples avec parenthésage. "},{"edit":"

Ecrire ici les résultats.

"}],[{"text":"

On peut insérer les directives dans le patron.

La syntaxe est la suivante :

(?iLmsuxa)

où une ou plusieurs lettres peuvent être absentes :

i pour IGNORECASE,

L pour LOCALE,

m pour MULTILINE,

s pour DOTALL,

u pour UNICODE,

x pour VERBOSE,

a pour ASCII.

Étant donné le processus que nous avons recommandé, l'usage en est rare.

Par contre, il n'en est pas de même si on avait choisi une autre méthodologie, par exemple celle des fonctions du module re (fonction re.search(), re.findall() etc).

","title":"Les directives insérées dans les expressions"},{"edit":"

"}],[{"text":"

On a déjà rencontré un mode de groupement en utilisant le \"parenthésage\".

Il existe un second système appelé groupe, qui a, en plus des propriétés du parenthésage, des propriétés très spécifiques.

On prendra garde que le \"groupe\" n'est pas l'équivalent du parenthésage mathématique.

","title":"Les groupes"},{"edit":"

"}],[{"text":"

Un patron est un groupe. En effet, c'est le groupe de niveau le plus bas, le niveau 0.

Si on veut définir des sous-groupes, il suffit de parenthéser des sous-expressions régulières constituant l'expression globale.

Les groupes sont numérotés :

- 0 pour le patron;

- 1, 2,... pour les sous-groupes.

La numérotation se fait de gauche à droite, et pour un groupe, elle est égale au nombre total de parenthèses ouvrantes qui le précède.

On récupère les groupes en analysant l'objet SRE_Pattern retourné par search() .

Quant à la méthode findall() elle retourne une liste groupes ou de tuples (n-uplets) de groupes (voir exemple ci-dessous).

note. Les littéraux ( et ) doivent être protégés. Mais attention ! Le point d'interrogation ne peut suivre la parenthèse ouvrante ; il faut aussi le protéger :

(? se code \\(\\?.

Les opérateurs comme *, +, ?, |, qui s'appliquent à un caractère ou une expression paranthésée s'appliquent à un groupe.

","title":"Groupement de sous-expressions régulières"},{"edit":"

"}],[{"text":"

Exemple 1:

#!/usr/bin/python3

import re

texte =\"Ablon\\nAcqueville\\nAgy\\nAigner-Ville\\nAiran\\nAmayé-sur-Orne\\

\\nAmblie\\nAmfreville\\nAngervillers\\nAngoville\\nArganchy\\nArgences\\

\\nArromanches-les-Bains\\nAsnelles\\nAsnières-Surville\"

patron = \"(.*)ville$\"

cpatron = re.compile (patron,re.MULTILINE)

resultat = cpatron.search(texte)

print (resultat.start(0),resultat.end(0), resultat.group(0))

print (resultat.start(1),resultat.end(1), resultat.group(1))

Exemple 2:

#!/usr/bin/python3

import re

texte =\"Ablon\\nAcqueville\\nAgy\\nAigner-Ville\\nAiran\\nAmayé-sur-Orne\\

\\nAmblie\\nAmfreville\\nAngervillers\\nAngoville\\nArganchy\\nArgences\\

\\nArromanches-les-Bains\\nAsnelles\\nAsnières-Surville\"

patron = \"(.*)(vi\\w*)$\"

cpatron = re.compile (patron,re.MULTILINE)

resultat = cpatron.search(texte)

print (resultat.start(0),resultat.end(0), resultat.group(0))

print (resultat.start(1),resultat.end(1), resultat.group(1))

print (resultat.start(2),resultat.end(2), resultat.group(2))

Ecrire et tester les 2 codes ci-dessous.

Expliquer les codes.

","title":"Exemples avec search()"},{"edit":"

Ecrire ici les résultats.

"}],[{"text":"

findall() ne reprend pas ce qu'on a trouvé avec le patron, mais ses sous-groupes.

Exemple 1

#!/usr/bin/python3

import re

texte =\"Ablon\\nAcqueville\\nAgy\\nAigner-Ville\\nAiran\\nAmayé-sur-Orne\\

\\nAmblie\\nAmfreville\\nAngervillers\\nAngoville\\nArganchy\\nArgences\\

\\nArromanches-les-Bains\\nAsnelles\\nAsnières-Surville\"

patron = \"(.*)vi\\w*$\"

cpatron = re.compile (patron, re.MULTILINE)

resultat = cpatron.findall(texte)

print (resultat)

Exemple 2 :

Avec deux sous-groupes.

#!/usr/bin/python3

import re

texte =\"Ablon\\nAcqueville\\nAgy\\nAigner-Ville\\nAiran\\nAmayé-sur-Orne\\

\\nAmblie\\nAmfreville\\nAngervillers\\nAngoville\\nArganchy\\nArgences\\

\\nArromanches-les-Bains\\nAsnelles\\nAsnières-Surville\"

patron = \"(.*)(vi\\w*)$\"

cpatron = re.compile (patron, re.MULTILINE+re.IGNORECASE)

resultat = cpatron.findall(texte)

print(resultat)

Exemple 3:

On reprend l'exemple précédent, mais en transformant chaque alternative en groupe. La méthode findall() continue à donner l'évaluation des deux groupes.

Cependant, si c'est le premier groupe qui est reconnu, le second n'est pas évalué (absence de gourmandise) : il est vide ; si c'est le second qui est reconnu, le premier est vide parce que non reconnu.

#!/usr/bin/python3

import re

texte =\"Ablon\\nAcqueville\\nAgy\\nAigner-Ville\\nAiran\\nAmaville-sur-Ville\\

\\nAmblie\\nTrouville\\nAngervillers\\nAngoville\\nArganchy\\

\\nAsnelles\\nAsnières-Surville\\nVille\\nVilleneuve\"

patron = \"(^.*ville-.*)|(^.*ville$)\"

cpatron = re.compile (patron,re.MULTILINE+re.IGNORECASE)

resultat = cpatron.findall(texte)

print (resultat)

Ecrire et tester les codes ci-dessous.

Quelles sont les différences pour les résultats affichés.

","title":"Exemples avec findall()."},{"edit":"

Ecrire ici les résultats.

"}],[{"text":"

Faites suivant et envoyez votre travail au format pdf à l'adresse mail ci-dessous :

Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.

Source : http://ateliers.mse.free.fr/regex/regex-python.pdf

","title":"Envoyer votre travail"},{"edit":""}]]

Détails: Écrit par : Richard GAUTHIER; Création : 13 Mai 2020; Mis à jour : 13 Mai 2020; Clics : 1381

1ère Générale NSI

Term. Générale NSI

Terminale STI2D SIN

Bts Ccst

Technico-commercial 3.0

Vidéos YouTube

nsi json sequence 33 regex 2/3