Différences

Ci-dessous, les différences entre deux révisions de la page.

--- divers_expr_reg [2008/12/11 13:17]
tyrtamos
+++ divers_expr_reg [2008/12/11 14:37]
tyrtamos
@@ Ligne 1: / Ligne 1: @@
 ====== Expressions régulières diverses ======
-//**En construction!**//
 Vous trouverez ici quelques expressions régulières avec leur "décodage" en langage humain (et ce n'est pas du luxe :-D).
@@ Ligne 25: / Ligne 22: @@
 A noter que le motif trouve aussi un nombre entier très long (comme "5555555555555555555555" par exemple) qui n'est pas un "int" en Python, mais un "long".
-===== test d'un nombre entier ou réel =====
+===== test d'un nombre réel (ou flottant, ou à "virgule flottante")=====
 <code python>
-motif = r"^[+-]?[0-9]+(\.[0-9]*)?([eE][+-]?[0-9]+)?$"
+motif = r"^[+-]?(([0-9]+[eE][+-]?[0-9]+)|([0-9]+\.[0-9]*([eE][+-]?[0-9]+)?)|(\.[0-9]+([eE][+-]?[0-9]+)?))$"
 </code>
@@ Ligne 34: / Ligne 31: @@
 <code>
-^      -> on commence au début de la chaine
+^
-[+-]?     -> éventuellement un"+" ou un "-"
+[+-]?     il peut y avoir ou pas un signe
-[0-9]+     -> un ou plusieurs chiffre(s)
+(
-(\.[0-9]*)?  -> éventuellement un point, suivi éventuellement d'un ou plusieurs chiffres
+([0-9]+[eE][+-]?[0-9]+)     si le 1er nb est entier (un ou plusieurs chiffres), alors, l'exposant est obligatoire
-([eE][+-]?[0-9]+)?  -> éventuellement un exposant ("e" ou "E"), éventuellement un signe (+ ou -), suivi d'un ou plusieurs chiffres (si il y a un exposant, il y a forcément au moins un chiffre)
+|
-$   -> on termine à la fin de la chaine
+([0-9]+\.[0-9]*([eE][+-]?[0-9]+)?)   si le 1er nombre (un ou plusieurs chiffre(s)) est suivi d'un point, alors les chiffres suivants et l'exposant sont optionnels
+|
+(\.[0-9]+([eE][+-]?[0-9]+)?) si on commence par un point, il y a un ou plusieurs chiffre(s) derrière, et l'exposant est optionnel
+)
+$
 </code>
-NB: ce motif refuse un nombre réel qui commence par un point.
 Bien sûr, si on veut chercher un tel nombre (entier ou réel) dans une chaine qui contient aussi autre chose, il faut retirer les "^" et "$".
-===== test d'un nombre réel (ou "flottant" ou à "virgule flottante") =====
+A noter qu'on peut faire plus court, (mais encore moins clair!) en remplaçant "[0-9]" par "\d", ce qui donne:
-Pour avoir une solution plus complète, il faut bien sûr être clair sur ce qu'on veut accepter et sur ce qu'on veut refuser.
+<code python>
+motif = r"^[+-]?((\d+[eE][+-]?\d+)|(\d+\.\d*([eE][+-]?\d+)?)|(\.\d+([eE][+-]?\d+)?))$"
+</code>
-Par exemple:
+On pourrait aussi mettre le motif de l'exposant en facteur dans les 2 derniers cas, mais cela conduirait à ajouter des parenthèses imbriquées.
-  * acceptable: "+11.111"  "1."  ".1"  "1e5"  "1.e5"  ".1e5"
+Vous pouvez essayer et éventuellement modifier l'expression régulière comme vous voulez avec la boucle suivante:
-  * refusé: "1" (=c'est un entier) "." ".e5" "e5"
+<code python>
+motif = r"^[+-]?(([0-9]+[eE][+-]?[0-9]+)|([0-9]+\.[0-9]*([eE][+-]?[0-9]+)?)|(\.[0-9]+([eE][+-]?[0-9]+)?))$"
+while True:
+    x = raw_input("x = ").strip()
+    if x == "":
+        break
+    if re.match(motif, x):
+        print u"x est un réel"
+    else:
+        print u"x n'est pas un réel"
+</code>
+===== test d'un nombre quelconque (entier ou réel) =====
-Ce qui donne l'expression régulière suivante:
+On peut simplement ajouter l'option supplémentaire "est entier" à la précédente, ce qui devient:
 <code python>
-r"^[+-]?(([0-9]+[eE][+-]?[0-9]+)|((([0-9]+\.[0-9]*)|(\.[0-9]+))([eE][+-]?[0-9]+)?))$"
+motif = r"^[+-]?(([0-9]+)|([0-9]+[eE][+-]?[0-9]+)|([0-9]+\.[0-9]*([eE][+-]?[0-9]+)?)|(\.[0-9]+([eE][+-]?[0-9]+)?))$"
 </code>
-Et voilà comment elle se lit:
+Et ce qui se lit:
 <code>
-^                                -> début de la chaine
+^
-[+-]?                            -> éventuellement un signe (+ ou -)
+[+-]?     il peut y avoir ou pas un signe
-(                                -> début de bloc qui décrit tout ce qui peut suivre l'éventuel signe
+(
-    ([0-9]+[eE][+-]?[0-9]+)      -> si le 1er nombre est entier, il est forcément suivi d'un exposant
+([0-9]+)  ça pourrait être un nombre entier
-    |                            -> ou:
+|
-    (
+([0-9]+[eE][+-]?[0-9]+)     il pourrait y avoir un nombre entier suivi d'un exposant
-        (
+|
-            ([0-9]+\.[0-9]*)     -> soit j'ai un ou plusieurs chiffre(s) suivi d'un point et éventuellement de chiffres (comme: 12. ou 12.35)
+([0-9]+\.[0-9]*([eE][+-]?[0-9]+)?)   si le 1er nombre (un ou plusieurs chiffre(s)) est suivi d'un point, alors les chiffres suivants et l'exposant sont optionnels
-            |
+|
-            (\.[0-9]+)           -> soit j'ai un point suivi d'un ou plusieurs chiffre(s) (comme .5)
+(\.[0-9]+([eE][+-]?[0-9]+)?) si on commence par un point, il y a un ou plusieurs chiffre(s) derrière, et l'exposant est optionnel
-        )
+)
-        ([eE][+-]?[0-9]+)?       -> les 2 solutions précédentes peuvent être suivies ou non d'un exposant
+$
-    )
-)                                 -> fin de bloc
-$                                 -> fin de la chaine
 </code>
-Vous pouvez essayer et éventuellement modifier l'expression régulière comme vous voulez avec la boucle suivant:
+Mais, en fait, l'expression se simplifie, ce qui donne:
 <code python>
-motiffloat = r"^[+-]?(([0-9]+[eE][+-]?[0-9]+)|((([0-9]+\.[0-9]*)|(\.[0-9]+))([eE][+-]?[0-9]+)?))$"
+motif = r"^[+-]?((([0-9]+(\.[0-9]*)?)|(\.[0-9]+))([eE][+-]?[0-9]+)?)$"
-print
-while True:
-    x = raw_input("x = ").strip()
-    if x == "":
-        break
-    if re.match(motiffloat, x):
-        print u"x est un réel"
-    else:
-        print u"x n'est pas un réel"
 </code>
+Sa lecture est plus complexe, et on peut mieux la comprendre avec l'indentation:
+<code>
+^
+[+-]?   éventuellement un signe
+(
+    (
+        ([0-9]+(\.[0-9]*)?)  on commence par un chiffre, éventuellement suivi d'un point, lui-même éventuellement suivi d'un ou plusieurs chiffres ("1." est accepté en tant que "1.0")
+        |
+        (\.[0-9]+)    on commence par un point, suivi d'un ou plusieurs chiffre(s) (".1" est accepté en tant que "0.1", mais, bien sûr, "." est refusé)
+    )
+    ([eE][+-]?[0-9]+)?   et dans l'un ou l'autre des 2 cas précédents, on peut avoir éventuellement un exposant
+)
+$
+</code>
+L'avantage d'utiliser les expressions régulières est ici évidente:
+  * si je veux limiter mes nombres à des nombres entiers ou réels mais sans exposant, il suffit de supprimer le motif de l'exposant
+  * si en plus je veux reconnaître des nombres écrits en français (avec la virgule), il suffit que je remplace le point par une virgule dans le motif.

Les recettes Python de Tyrtamos

Outils pour utilisateurs

Outils du site

Différences

Outils de la page