nsi json expression régulière

[[{"text":"Remplir les champs ci-dessous :","title":"Python : Les expressions régulières","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":"

On dispose d'un texte, c'est à dire pour Python d'une chaîne de caractères (string).

Par ailleurs, on propose d'un motif, qui est lui aussi une chaîne de caractères.

Le problème consiste à détecter la présence du motif dans le texte, et éventuellement de remplacer ce motif par un autre..

","title":"Poser le problème."},{"edit":"

"}],[{"text":"

Nous avons des fonctions définies oar python.

str.find(sub[, start[, end]])

retourne le premier indice de la chaîne où la sous-chaîne sub est trouvée ; si start et end sont précisés, le domaine de recherche est la sous-chaîne formée des caractères dont l'indice est entre les valeurs de start et de end (la tranche commence avec start et se termine avant end). La méthode retourne -1 en cas d'échec de la recherche.

str.index(sub[, start[, end]])

comme find(), mais lève une exception ValueError si la sous-chaîne n'est pas trouvée.

Cela permet de programmer les ruptures de séquences avec des exceptions. str.rfind(sub[, start[, end]])

comme find(), mais commence par la fin de la chaîne.

str.rindex(sub[, start[, end]])

comme rfind() mais lève une exception ValueError si la sous-chaîne n'est pas trouvée.

str.count(sub[, start[, end]])

retourne le nombre d'occurrences de la sous-chaîne sub dans la tranche [start,end]

","title":"Trouver"},{"edit":"

"}],[{"text":"

On a la chaine de caractère suivante :

texte = \"\"\"Un IDE ou environnement de développement est un logiciel constitué d'outils qui facilitent l'écriture et les tests dans un ou plusieurs langages de programmation.

Cet IDE comporte en général un éditeur avec coloration syntaxique,

un système de gestion de fichiers (sauvegarde/chargement),

un compilateur, un exécuteur de programme, un système d'aide en ligne,\\

des indicateurs de syntaxe etc.

Le plus connu est peut être Éclipse.

\"\"\"

# première occurence du motif / numérotation qui commence à 0

motif = \"IDE\"

resultat = texte.find(motif)

print (\"première occurence du motif :\", resultat)

# nombre d'occurrences du motif

resultat= texte.count (motif)

print (\"nombre d'occurrences du motif :\",resultat)

# recherche d'un motif avec problème de casse

motif = \"éclipse\"

resultat = (texte.upper()).find(motif.upper())

print (motif, \"est présent comme\",texte[resultat:resultat+len(motif)])

résultat :

","title":"Exercice"},{"edit":"

Ecrire ici le résultat.

"}],[{"text":"

ce que dit la documentation.

str.replace(old, new[, count])

retourne une copie de la chaîne où toutes les occurrences de la sous-chaîne old sont remplacées par la chaîne new. Si la valeur count est précisée, seules les count premières occurrences sont remplacées.

","title":"Remplacer."},{"edit":"

Répondre ici.

"}],[{"text":"

3.2. un exemple.

>>>

première occurrence du motif : 3

nombre d'occurrences du motif : 2

éclipse est présent comme Éclipse

>>>

#!/usr/bin/python3

# remplacer dans une chaîne

texte = \"Un IDE ou \\\"environnement de développement\\\" est un logiciel \\

E.R. en Python 3

fiche 0 : trouver et remplacer dans une chaîne.

page 4

constitué d'outils qui facilitent l'écriture et les tests dans un \\

langage défini, voire plusieurs.\\

\\nCet IDE comporte en général un éditeur avec coloration syntaxique,\\

un système de gestion de fichiers (sauvegarde/chargement),\\

un compilateur, un exécuteur de programme, un système d'aide en ligne,\\

des indicateurs de syntaxe etc. \\

\\nLe plus connu est peut être Éclipse.\"

# remplacement

motif = \"\\n\"

resultat = texte.replace(motif, \" \")

print (resultat)

résultat :

>>>

Un IDE ou \"environnement de développement\" est un logiciel constitué

d'outils qui facilitent l'écriture et les tests dans un langage défini,

voire plusieurs. Cet IDE comporte en général un éditeur avec coloration

syntaxique,un système de gestion de fichiers (sauvegarde/chargement),un

compilateur, un exécuteur de programme, un système d'aide en ligne,des

indicateurs de syntaxe etc. Le plus connu est peut être Éclipse.

>>>

","title":"Exercices"},{"edit":"

Ecrire les résultats ici.

"}],[{"text":"

4. Découper.

4.1. ce que dit la documentation.

str.split([sep[, maxsplit]])

retourne une liste de mots de la chaîne, en utilisant sep comme délimiteur. Si maxsplit est

donné, il y a au plus maxsplit coupures (et la liste a au plus maxsplit+1 éléments).

En l'absence de séparateur spécifié, ou avec le séparateur None, l'espace est considéré

comme séparateur.

str.splitlines([keepends])

retourne une liste des lignes de la chaîne. En principe, le séparateur de ligne n'est pas gardé, sauf si keepend est posé à True.

","title":"Découper."},{"edit":"

Ecrire les résultats ici.

"}],[{"text":"

4.2. exemples.

#!/usr/bin/python3

# couper une chaîne

texte = \"123,,456,\"

# split

liste = texte.split (\",\")

print (\"texte :\",texte, \"\\nliste :\", liste,\"\\n\\n\")

# splitline

texte = \"\\nABC\\nDEF\\nGHI\"

liste = texte.splitlines()

print (\"texte :\",texte, \"\\nliste :\", liste,\"\\n\\n\")

E.R. en Python 3

fiche 0 : trouver et remplacer dans une chaîne.

page 5

# splitline avec keepend

texte = \"\\nABC\\nDEF\\nGHI\"

liste = texte.splitlines(True)

print (\"texte :\",texte, \"\\nliste :\", liste,\"\\n\\n\")

résultats :

>>>

texte : 123,,456,

liste : ['123', '', '456', '']

texte :

ABC

DEF

GHI

liste : ['', 'ABC', 'DEF', 'GHI']

texte :

ABC

DEF

GHI

liste : ['\\n', 'ABC\\n', 'DEF\\n', 'GHI']

>>>

E.R. en Python 3

fiche 0 : trouver et remplacer dans une chaîne.

page 6

","title":"Exercice"},{"edit":"

Ecrire les résultats ici.

"}],[{"text":"

Les «expressions régulières » en Python 3 peuvent être abordées à l'aide du module re :

import re # module des expressions régulières

Les fichiers du module re.py, re.pyc, re.pyo, respectivement le fichier source, le fichier compilé, le fichier optimisé se trouvent dans le répertoire des librairies Lib, à la racine. Il n'y a donc aucun problème particulier pour son utilisation. C'est là que la machine Python cherche les modules (après le répertoire actuel, évidemment).

Dans les fiches qui suivent, on utilise l'importation sous la forme import ; il faut donc qualifier systématiquement les éléments constitutifs du module. En production, il se peut qu'il soit intéressant, pour éviter des lourdeurs de code, d'utiliser la forme from... import et de définir des alias. C'est évidemment tout à fait possible, mais ce n'est pas ici le lieu d'en discuter.

","title":"Les «expressions régulières »"},{"edit":"

Ecrire ici vos résultats.

"}],[{"text":"

1. Matching et Searching. 1.1. vocabulaire.

Pour la clarté de l'exposé, nous traduirons le verbe to match par correspondre à, et to search par rechercher et donc matching par correspondance et searching par recherche. Il ne faut pas chercher de signification \"intuitive\" à ces concepts qui ont dans chacun des langages comme C, Java ou Python un sens précis, mais malheureusement pas le même d'un langage à l'autre.

"},{"edit":"

Ecrire ici vos résultats.

","css":"","js":""}],[{"text":"

1.2. poser le problème.

Problème : On dispose d'un texte, c'est à dire pour Python une chaîne de caractères ; par ailleurs, on propose un patron (ou motif), qui est lui aussi une chaîne de caractères. Le problème consiste à détecter une sous-chaîne respectant le patron dans le texte et éventuellement à remplacer par une chaîne prédéfinie la (ou les) sous-chaînes(s) trouvées. D'autres opérations sont possibles, qui seront vues en leur temps.

Le texte se présente sous forme d'une chaîne de caractères en mémoire vive (variable, chaîne littérale) ; on ne se pose pas de problème d'encodage (UNICODE par défaut en version 3 ; en versions 2.x, le code est le code local. On peut définir la norme de l'encodage par une clause -code-). Si on dispose d'un fichier de texte, le problème de l'encodage se pose lors du chargement !

Le patron est pour l'instant une chaîne, avec quelques problèmes : comme d'habitude, les sauts de lignes sont codés \\n, l'antislash est codé \\\\. L'antislash protège les quotes. Mais il doit aussi protéger un certain nombre de caractères usuels comme le point, ^, $, + , ?, * . Cela sera explicité plus complètement dans les fiches qui suivent.

","title":"La fonction dir"},{"edit":"

Ecrire ici le résultat.

"}],[{"text":"

1.3. compiler le patron.

La syntaxe est la suivante :

cpatron = re.compile(patron, directives)

Le type (classe) de cpatron est : '_sre.SRE_Pattern'

_sre est le module appelé dans le module re ; SRE_Pattern est le nom de la classe.

Les directives se présentent sous forme d'un entier : chaque directive est une puissance de deux, et le paramètre directives est la somme de directives particulières.

E.R. en Python 3

fiche 1 : le module Python RE

page 7

constante

abrégé

valeur

signification

IGNORECASE

ignorer la casse ; fonctionne avec les lettres accentuées

LOCALE

définir comme \"lettre\" ce que la langue locale définit comme tel dans la variable système.;

MULTILINE

considèrer le texte comme décomposé en lignes (le caractère \\n est le début de chaque ligne)

DOTALL

considèrer le saut de ligne comme un caractère ordinaire.

UNICODE

obsolète dans Python 3

VERBOSE

permettre d'écrire des commentaires dans les patrons.

ASCII

256

permettre de travailler en ASCII

On peut écrire indifféremment re.IGNORECASE+re.MULTILINE ou re.I+re.M

En pratique, dans le début du travail, seules les directives IGNORECASE, MULTILINE et DOTALL

sont à prendre en compte. On verra plus tard la directive VERBOSE. 1.4. comparer et chercher.

* La syntaxe des fonctions est la suivante :

cpatron.search (texte)

cpatron.match (texte)

* La recherche (search()) consiste à parcourir le texte depuis le début ; si le patron n'est pas identifiable dans le texte, la fonction retourne None. Sinon, elle retourne une instance de l'objet MatchObject, appartenant lui aussi au module _sre.

La comparaison (match()) consiste à identifier le début du texte au patron. Elle retourne None si aucune comparaison n'est possible. Sinon elle retourne une instance MatchObject.

* l'objet : MatchObject

Cet objet peut être interrogé par ses méthodes. Pour l'instant, les méthodes start() (premier caractère reconnu) et stop() (position après le dernier caractère reconnu)

#!/usr/bin/python3

import re

texte = \"Un IDE ou \\\"environnement de développement\\\" est un logiciel \\

constitué d'outils qui facilitent l'écriture et les tests dans un \\

langage défini, voire plusieurs.\\

\\nCet IDE comporte en général un éditeur avec coloration syntaxique,\\

un système de gestion de fichiers (sauvegarde/chargement),\\

un compilateur, un exécuteur de programme, un système d'aide en ligne,\\

des indicateurs de syntaxe etc. \\

\\nLe plus connu est peut être Éclipse.\"

# recherche du patron dans le texte ; résultat affiché : 158 165

patron = \"Cet IDE\"

cpatron = re.compile(patron)

resultat = cpatron.search(texte)

E.R. en Python 3

fiche 1 : le module Python RE

page 8

if resultat :

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

else:

print (resultat)

# comparaison du patron au texte ; résultat affiché : None

resultat = cpatron.match(texte)

if resultat :

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

else :

print (resultat)

# comparaison du patron au texte ; résultat affiché : 0 6

patron = \"Un IDE\"

cpatron = re.compile (patron)

resultat = cpatron.match(texte)

if resultat :

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

else :

print (resultat)

# recherche en ignorant la casse ; résultat affiché : 413 420

patron = \"éclipse\"

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

resultat = cpatron.search(texte)

if resultat :

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

else:

print (resultat)

note. Il existe plusieurs présentations syntaxiques pour les méthodes comme search(). Dans le script ci-dessus, search() est une méthode de l'objet SRE_Pattern. Mais Python l'a également redéfini comme une fonction du module re :

exemple : re.search(patron, texte, re.IGNORECASE))...

Pour la clarté de l'exposé, on s'en tient à une seule syntaxe, celle du script ci-dessus, qui a l'avantage

de ressembler à ce qui se fait en java.

","title":"compiler le patron."},{"edit":"

Ecrire ici le résultat.

"}],[{"text":"

2. Expression régulière.

2.1. remarques sur la section précédente.

La section qui précède a pour objectif de spécifier une syntaxe : celle requise par le module re pour faire des opérations assez semblables à celles réalisées avec plus de simplicité par les méthodes de la classe str.

Quel est l'apport du module re pour les opérations de recherche, de comparaison, de substitution, de découpage de chaînes ? Lorsque l'on fait une recherche ou une substitution dans un traitement de texte ou un éditeur, la chaîne recherchée doit être explicite. On peut imposer de ne pas différencier majuscules et minuscules, ou de ne rechercher que des mots entiers ; ces aménagements sont insuffisants.

note : les éditeurs et traitements de texte actuels peuvent travailler différemment !

On peut souhaiter disposer, pour écrire les patrons, de jokers (comme le * ou le ? dans les shells des

E.R. en Python 3

fiche 1 : le module Python RE

page 9

systèmes d'exploitation) ou de conditions (exemple : trouver les virgules qui sont suivies d'un caractère alphabétique ; trouver les espaces multiples ; se limiter aux caractères alphanumériques). Les expressions régulières sont des chaînes comportant des jokers et des éléments de description de chaînes de caractères.

","title":"L'héritage de classe"},{"edit":"

Ecrire ici les résultats.

"}],[{"text":"

2.2. les jokers et marqueurs fondamentaux.

signe

signification générale

signification sous directive

le point remplace tout caractère sauf le saut de ligne (\\n).

sous DOTALL, le point représente tout caractère, y compris le saut de ligne.

Le chevron (circonflexe) représente le début de la chaîne analysée.

sous MULTILINE, représente en plus la position après le saut de ligne

Le dollar représente la fin de la chaîne analysée.

sous MULTILINE, représente en plus la position avant le saut de ligne.

exemples d'expressions régulières :

\"azer.tyiop\" : cette expression régulière correspond à : azer suivi de n'importe quel

caractère, suivi de tyiop sur une ligne. En mode DOTALL, le caractère peut être le saut de ligne.

En recherche, azeratyiop, azerAtyiop, azer(tyiop, azer.tyiop satisfont au

modèle proposé.

\"^aze\" : le patron \"aze\" doit être recherché en début de texte uniquement en début de texte.

En mode MULTILINE, il est aussi recherché en début de chaque ligne. \"tyiop$\" : le patron \"tyiop\" est recherché en fin de texte.

En mode MULTILINE, il est aussi recherché en fin de chaque ligne. \"^$\" : recherche d'un texte vide ou en mode MULTILINE d'une ligne vide.

2.3. répétitions d'un caractère.

itérateur

interprétation

zéro, une ou plusieurs fois le caractère qui précède

une ou plusieurs fois le caractère qui précède

zéro ou une fois le caractère qui précède

{m}

exactement m fois le caractère qui précède

{m,}

au moins m fois le caractère qui précède

{m,n}

au moins m fois et au plus n fois le caractère qui précède

exemples :

exp. reg.

chaînes reconnues

ab*c

ac, abc, abbc, abbbc, ...

ab+c

abc, abbc, abbbc, ...

E.R. en Python 3

fiche 1 : le module Python RE

page 10

ab?c

ac, abc

ab{2,}c

abbc, abbbc, abbbbc, ....

ab{2,4}c

abbc, abbbc, abbbbc

","title":"les jokers et marqueurs fondamentaux"},{"edit":"Ecrire ici les résultats.

"}],[{"text":"

2.4. consommation.

Lorsqu'une recherche est couronnée de succès, la partie de la chaîne comprise entre le début de celle-ci et la fin de la sous-chaîne trouvée est consommée. Ce qui signifie par exemple que la fonction findall() commence la recherche à partir du caractère suivant le dernier caractère consommé. La recherche est séquentielle et elle ne fait aucun retour en arrière.

","title":"consommation"},{"edit":"

Ecrire ici les résultats.

"}],[{"text":"

2.5. gourmandise.

les itérateurs *, +, ? sont gourmands. C'est-à-dire que dans une recherche, ils ont un comportement qui conduit à reconnaître la plus grande chaîne possible. Ils consomment la chaîne au maximum, même si une correspondance a déjà été trouvée sur le patron proposé.

Par exemple, supposons que l'on ait :

texte = \"<h1>Expressions Régulières</h1>\"

patron = \"<.*>\"

Le sous-motif .* conduit à avoir le plus grand texte possible : l'expression régulière s'identifie à tout le texte. Il faut lire patron comme :

le caractère < pour commencer ; un maximum de caractères ; le caractère > pour finir. On aurait pu souhaiter au contraire une identification à <h1>, c'est-à-dire :

le caractère < pour commencer ; un minimum de caractères ; le caractère >. Une nouvelle classe d'itérateurs réalisent ces opérations :

itérateur

interprétation

zéro, une ou plusieurs fois le caractère qui précède ; non gourmand. Dans une expression, *? s'identifie à la plus petite chaîne possible.

une ou plusieurs fois le caractère qui précède ; non gourmand.

zéro ou une fois le caractère qui précède ; non gourmand.

{m,n}?

le caractère qui précède m fois.

exemple :

import re

texte = \"<<aaAAabbbccaaannn\"

patron = \"a{2,3}b?\"

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

res = cpatron.findall(texte)

print (\"patron :\",patron,\"résultat : \",res)

patron = \"a{2,3}?b?\"

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

E.R. en Python 3

fiche 1 : le module Python RE

page 11

res = cpatron.findall(texte)

print (\"patron :\",patron,\"résultat : \",res)

patron = \"a{2,3}b??\"

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

res = cpatron.findall(texte)

print (\"patron :\",patron,\"résultat : \",res)

résultat :

Pour bien comprendre, il faut simuler la consommation !!!

","title":"gourmandise."},{"edit":"

Ecrire ici les résultats.

"}],[{"text":"

2.5. échappement.

Les jokers et les opérateurs sont des caractères courants. Comment, dans une expression régulière peut-on distinguer ce caractère en tant que caractère et le même en tant qu'opérateur ou composant d'un opérateur ? On utilise le même système que Python dans ce cas : pour considérer un caractère comme se représentant lui-même, il faut l'échapper par un antislash. On aura donc pour le point \\., pour l'astérisque \\*, pour le signe plus \\+ et ainsi de suite. Cela peut se compliquer ; un chapitre spécial sera consacré à cette question.

","title":"échappement"},{"edit":"

Ecrire ici les résultats.

"}],[{"text":"

Prenez l'habitude de nommer votre classe uniquement avec des caractères alphanumériques et commençant par une majuscule. Et à l'inverse l'instance peut être nommée sans majuscule.

voiture_sport = VoitureSport()

","title":"Conventions"},{"edit":" "}],[{"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 : https://python.doctor/page-apprendre-programmation-orientee-objet-poo-classes-python-cours-debutants ","title":"Envoyer votre travail"},{"edit":"

https://blog.lakinduakash.com/index.php/learn-object-oriented-programming-oop-in-python-3-within-10-minutes/91/

https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/doku.php/stu:python:pypoo

https://ericberthomier.fr/IMG/pdf/exos_corriges.pdf

https://python.sdv.univ-paris-diderot.fr/19_avoir_la_classe_avec_les_objets/

"}]]