![](\"https://miro.medium.com/max/4968/1*m3wegA5h10b8aM5U64xtSA.png\")
Source de l'image :
"}],[{"text":"La numérotation se fait de gauche à droite, et pour un groupe, elle est égale au nombre total de parenthèses ouvrantes qui le précède.
#!/usr/bin/python3
import re
texte = \" abcdefghijklmnopqrstuvwxyz \"
patron = \"abc(def(ghi)(jkl))(mno)pqr\"
cpatron = re.compile(patron)
res = cpatron.search(texte)
if res :
try:
for i in range (99) : # maximum de 99 groupes
print (\"groupe\", i , \":\", res.group(i))
except:
pass
Ecrire et tester le code.
Justifier les résultats.
Attention : Si le patron comporte un ou logique la règle de numérotation continue à s'appliquer. Par exemple, le patron \"ab(c)d|xy(z)\" comporte deux groupes : numérotés 1 (c) et 2 (z).
Il est possible de donner un nom à un groupe au moment où on le définit. Le nom doit être un identificateur Python valide.
Il n'y a aucune interférence avec la numérotation.
La syntaxe est
(?P<nom du groupe>expression régulière)
Exemple :
#!/usr/bin/python3
import re
texte = \" abcdefghijklmnopqrstuvwxyz \"
patron = \"abc(?P<gr1>def(?P<gr2>ghi)(?P<gr3>jkl))(?P<gr4>mno)pqr\"
cpatron = re.compile(patron)
res = cpatron.search(texte)
if res :
for i in range (1, 99) :
try :
print (\"groupe \"+str(i), res.group(\"gr\"+str(i)))
except :
pass
Ecrire et tester le code.
Lorsqu'un groupe est identifié à un segment de chaîne, la valeur de la sous-chaîne identifiée peut être \"capturée\", et utilisée dans l'expression régulière et dans la fonction de remplacement sub().
La valeur reconnue se désigne dans l'expression régulière par un antislash suivi de son numéro
(exemple : \\5 pour la chaîne du groupe 5) ou par la convention de nommage :
(?P=identificateur)
Mais l'antislash suivi d'un chiffre peut avoir une signification en Python, il faut donc doubler l'antislash dans la chaîne Python. Par ailleurs, cette notation devient ambiguë avec les valeurs au delà de 10.
Comment
est interprèté \\14 ? groupe 1 suivi de 4 ou groupe 14 ? Dans le patron le nombre à deux chiffres est correctement interprété comme \"groupe 14\" ; le groupe 1 suivi de 4 doit s'écrire par exemple \\\\1[4].
Problème : trouver les mots d'un texte qui commencent et se terminent par la même lettre.
import re
texte = \"J'ai été en sursis et j'irai bien désormais\"
patron = \"\\\\b(\\w).*?\\\\1\\\\b\"
cpatron = re.compile(patron)
while True :
print (texte)
res = cpatron.search(texte)
if res :
print (res.group(0))
texte = texte [res.end():]
else: break
On a figuré le groupe et la chaîne dont l'identification relève de l'analyse syntaxique.
#!/usr/bin/python3
import re
texte = \"J'ai été en sursis et j'irai bien désormais\"
patron = \"\\\\b(?P<premiereLettre>\\w)\\w*(?P=premiereLettre)\\\\b\"
cpatron = re.compile(patron)
while True :
res = cpatron.search(texte)
if res :
print (res.group(0))
texte = texte [res.end():]
else:
break
Ecrire et tester le code.
Justifier les résultats.
","title":"Usage de la convention de nommage. exemple"},{"edit":" "}],[{"text":"On peut utiliser les éléments capturés dans la chaîne de remplacement.
Les conventions de nommage sont alors :
\\g<identificateur>
\\g<numéro>
Les symboles < et > ne sont pas indispensables si le numéro n'a qu'un chiffre ; mais cette facilité est à éviter à cause de l'ambiguïté qui naît avec les valeurs à deux chiffres.
Voici un problème d'illustration : on dispose d'un texte html, et on veut remplacer l'expression align=center par une autre chaîne, mais uniquement dans les balises de bloc de texte, c'est-à-dire commençant par h0,h1 ...h9 ou p.
De plus, on veut éliminer tout le reste des attributs de ces balises.
import re
texte = \"\"\"<h1 name=\"titre\"
align=CENTER>align=center</h1>
<img src=\"kw154.png\" align = center>
<p align = center id=\"zazozi\" >wawawa</p>
<h2 align= center>fin de texte</h2>\"\"\"
print(\"La page html :\", texte)
patron = \"\"\"
(<h\\d|<p) # balise commençant par <h avec chiffre ou <p
.*? # suite non gourmande de caractères
align\\s*=\\s*center # suivie du motif recherché
.*? # suite non gourmande de caractères
(>) # terminée par >
\"\"\"
# le patron comporte deux groupes
cpatron = re.compile(patron, re.I+re.S+re.X) # IGNORECASE+DOTALL+VERBOSE
print(cpatron.findall(texte),\"\\n\")
# les deux groupes sont utilisés dans la chaîne de remplacement.
res = cpatron.sub('\\g<1> style=\\'align:center;\\' \\g<2>', texte)
print(res)
Ecrire et tester le code ci-dessous.
Justifier le résultat.
Le problème :
Supposons que l'on dispose de l'expression régulière patron mais que l'on veuille chercher une correspondance conditionnelle : seulement si l'expression à trouver est \"suivie\" (ou n'est pas suivie) d'une expression trouvée avec une autre expression régulière hpatron.
Par exemple, on cherche la chaîne \"Isaac\" suivie par \"Newton\" ou \"Asimov\". Ou le contraire. Évidemment, on peut compliquer un peu.
Une telle recherche s'appelle un lookahead. Sa caractéristique essentielle est qu'elle ne consomme que la chaîne recherchée, pas la chaîne conditionnelle.
La syntaxe est la suivante :
(?=expression lookahead recherchée) (?!expression lookehaed rejetée)
Lookahead postposé
#!/usr/bin/python3
import re
texte = \"isaac jacob, Isaac Newton, Isaac Asimov,\\
isaac isaac\\n, isaac Isaac\"
print(\"le texte :\", texte)
patron =\"Isaac\\s(?=Asimov|Newton)\"
cpatron = re.compile(patron, re.IGNORECASE)
print (cpatron.findall(texte))
patron =\"Isaac(?:\\s|$)(?!Asimov|Newton)\"
cpatron = re.compile(patron, re.IGNORECASE)
print (cpatron.findall(texte))
Ecrire et tester le code.
Justifier les résultats.
Remarques :
- \\s pour un blanc (espace, fin de ligne).
- on voit bien sur le second cas qu'il n'y a pas consommation du lookahead.
lookahead préposé. exemple 2 :
#!/usr/bin/python3
import re
texte = \"isaac jacob, IsaacNewton, Isaac Asimov, bellisaac\"
patron =\"(?=\\\\bisa\\w*\\\\b)isaac\"
cpatron = re.compile(patron, re.IGNORECASE)
print (cpatron.findall(texte))
Ecrire et tester le code ci-dessus.
Quelle est la différence avec l'exemple précédent.
Remarque :
e patron du lookahead est d'abord recherché ; s'il est trouvé, la recherche de la seconde partie du patron se fait à partir du premier élément trouvé, qui est ici un début de mot. On dit qu'il y a chevauchement.
Une recherche de correspondance avec comme condition de suivre (ou non) une correspondance définie par une autre expression régulière est un lookbehind.
Le lookbehind consomme l'expression précédente, mais ne la retourne pas. Il n'y a pas de chevauchement avec le lookbehind, car la chaîne conditionnelle est avant la chaîne recherché.
Restriction :
- l'expression qui sert de condition doit avoir une longueur préfixée;
- on ne peut avoir de .* ou \\w* ;
- on peut avoir toto|titi.
Sinon, Il y a erreur à la compilation.
La syntaxe est la suivante:
(?<=expression lookbehind recherchée)
(?<!expression lookbehind rejetée)
Lookbehind préposé exemple 1 :
#!/usr/bin/python3
import re
texte = \"isaac jacob, IsaacNewton, IsaacAsimov, isaac\"
print(\"Le texte :\",texte)
patron =\"(?<=isaac)[a-z]+\"
cpatron = re.compile(patron, re.IGNORECASE)
print(cpatron.findall(texte))
Lookbehind préposé exemple 2 :
#!/usr/bin/python3
import re
texte = \"isaac jacob, IsaacNewton, IsaacAsimov, mimieDany\"
patron =\"(?<=isaac|m[a-z]{4})[a-z]+\"
cpatron = re.compile(patron, re.IGNORECASE)
print (cpatron.findall(texte))
Ecrire et tester les 2 codes précédents.
Problème : Dans une liste de noms/prénoms, sortir les noms de 6 lettres précédées par un prénom de
5 lettres.
#!/usr/bin/python3
import re
texte = \"isaac jacob, Isaac Newton, Isaac Léa, Isaac Asimov\"
motif =\"\\w{6}(?<=\\w{5}\\s\\w{6})\"
cmotif = re.compile(motif, re.IGNORECASE)
print (cmotif.findall(texte))
Le mécanisme est le suivant :
- il y a d'abord recherche d'un mot de 6 lettres ;
- puis, à partir du dernier élément consommé, évaluation de la condition lookbehind qui doit se terminer sur ce dernier élément consommé.
Il n'y a pas chevauchement puisque tout se passe avant le dernier élément consommé, pas après comme dans le lookahead.
On a donc les 4 schémas possibles suivants quand on veut utiliser des conditions :
![\"regex.png](\"https://sciencesappliquees.com/images/nsi/regex.png\")
Write a Python program to check that a string contains only a certain set of characters (in this case a-z, A-Z and 0-9). Go to the editor
","title":"Exercice 1"},{"edit":"Ecrire votre réponse ici.
"}],[{"text":"Write a Python program that matches a string that has an a followed by one or more b's. Go to the editor
","title":"Exercice 2"},{"edit":"Ecrire votre réponse ici.
"}],[{"text":"Write a Python program that matches a string that has an a followed by three 'b'. Go to the editor
Ecrire votre réponse ici.
"}],[{"text":"Write a Python program to find sequences of lowercase letters joined with a underscore. Go to the editor
Ecrire votre réponse ici.
"}],[{"text":"Write a Python program that matches a word at the end of string, with optional punctuation. Go to the editor
","title":"Exercice 5"},{"edit":"Ecrire votre réponse ici.
"}],[{"text":"Write a Python program where a string will start with a specific number. Go to the editor
","title":"Exercice 6"},{"edit":"Ecrire votre réponse ici.
"}],[{"text":"Write a Python program to search a literals string in a string and also find the location within the original string where the pattern occurs. Go to the editor
Sample text : 'The quick brown fox jumps over the lazy dog.'
Searched words : 'fox'
Ecrire votre réponse ici.
"}],[{"text":"Write a Python program to remove all whitespaces from a string. Go to the editor
","title":"Exercice 8"},{"edit":"Write a Python program to remove the parenthesis area in a string. Go to the editor
Sample data : [\"example (.com)\", \"w3resource\", \"github (.com)\", \"stackoverflow (.com)\"]
Expected Output:
example
w3resource
github
stackoverflow
Click me to see the solution
Ecrire votre réponse ici.
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.