Plongez au coeur de Python ,De débutant à expert

>>> s = '100 NORTH MAIN ROAD'
>>> s.replace('ROAD', 'RD.')               ***1***
'100 NORTH MAIN RD.'
>>> s = '100 NORTH BROAD ROAD'
>>> s.replace('ROAD', 'RD.')               ***2***
'100 NORTH BRD. RD.'
>>> s[:-4] + s[-4:].replace('ROAD', 'RD.') ***3***
'100 NORTH BROAD RD.'
>>> import re                              ***4***
>>> re.sub('ROAD$', 'RD.', s)              ***5*** ***6***
'100 NORTH BROAD RD.'

***1*** Mon but était de standardiser les adresses de manière à ce que 'ROAD' soit toujours abrégé en 'RD.'. Au premier abord, je pensais que ce serait assez simple pour utiliser uniquement la méthode de chaîne replace. Après tout, toutes les données étaient déjà en majuscules, donc les erreurs de casses ne seraient pas un problème. De plus, la chaîne de recherche, 'ROAD', était une constante. Pour cet exemple trompeusement simple, s.replace fonctionne effectivement.

***2*** Malheureusement, la vie est pleine de contre-exemples et je découvrais assez rapidemment celui-ci. Le problème ici est que 'ROAD' apparaît deux fois dans l'adresse, d'abord comme partie du nom de la rue 'BROAD' et ensuite comme mot isolé. La méthode replace trouve ces deux occurences et les remplace aveuglément, rendant l'adresse illisible.

***3*** Pour résoudre le problème des adresses comprenant plus d'une sous-chaîne 'ROAD', nous pourrions recourir à quelque chose de ce genre : ne rechercher et remplacer 'ROAD' que dans les 4 derniers caractères de l'adresse (s[-4:]) et ignorer le début de la chaîne (s[:-4]). Mais on voit bien que ça commence à être embrouillé. Par exemple, le motif dépend de la longueur de la chaîne que nous remplaçons (si nous remplaçons 'STREET' par 'ST.', nous devons écrire s[:-6] et s[-6:].replace(...)). Aimeriez-vous revenir à ce code dans six mois et devoir le débugger ? En ce qui me concerne, certainement pas.

***4*** Il est temps de recourir aux expressions régulières. En Python, toutes les fonctionalités en rapport aux expressions régulières sont contenues dans le module re.

***5*** Regardez le premier paramètre, 'ROAD$'. C'est une expression régulière très simple qui ne reconnaît 'ROAD' que s'il apparaît à la fin d'une chaîne. Le symbole $ signifie «fin de la chaîne» (il y a un caractère correspondant, l'accent circonflexe ^, qui signifie «début de la chaîne»).

***6*** A l'aide de la fonction re.sub, nous recherchons dans la chaîne s l'expression régulière 'ROAD$' et la remplaçons par 'RD.'. Cela correspond à ROAD à la fin de la chaîne s, mais ne correspond pas au ROAD faisant partie du mot BROAD, puisqu'il est au milieu de s.

En continuant mon travail de reformatage d'adresses, je decouvrais bientôt que le modèle précédent, reconnaître 'ROAD' à la fin de l'adresse, ne suffisait pas, car toutes les adresses n'incluaient pas d'identifiant pour la rue. Certaines finissaient simplement par le nom de la rue. La plupart du temps, je m'en sortais sans problème, mais si le nom de la rue était 'BROAD', alors l'expression régulière reconnaissait 'ROAD' à la fin de la chaîne dans le mot 'BROAD'. Ce n'était pas ce que je voulais.

>>> s = '100 BROAD'
>>> re.sub('ROAD$', 'RD.', s)
'100 BRD.'
>>> re.sub('\\bROAD$', 'RD.', s)  ***1***
'100 BROAD'
>>> re.sub(r'\bROAD$', 'RD.', s)  ***2***
'100 BROAD'
>>> s = '100 BROAD ROAD APT. 3'
>>> re.sub(r'\bROAD$', 'RD.', s)  ***3***
'100 BROAD ROAD APT. 3'
>>> re.sub(r'\bROAD\b', 'RD.', s) ***4***
'100 BROAD RD. APT 3'

***1*** Ce que je voulais vraiment était de reconnaître 'ROAD' quand il était à la fin de la chaîne et qu'il était un mot isolé, pas une partie de mot. Pour exprimer cela dans une expressions régulière, on utilise \b, qui signifie «une limite de mot doit apparaître ici». En Python, c'est rendu plus compliqué par le fait que le caractère '\', qui est le caractère d'échappement, doit lui-même être précédé du caractère d'échappement (c'est ce qui est parfois appelé la backslash plague et c'est une des raison pour lesquelles les expressions régulières sont plus faciles à utliser en Perl qu'en Python. Par contre, Perl mélange les expressions régulières et la syntaxe du langage, donc si vous avez un bogue, il peut être difficile de savoir si c'est une erreur dans la syntaxe ou dans l'expression régulière).

***2*** Pour éviter la backslash plague, vous pouvez utiliser ce qu'on appelle une chaîne brute, en préfixant la chaîne par la lettre r. Cela signale à Python que cette chaîne doit être traitée sans échappement, '\t' est un caractère de tabulation, mais r'\t' est réellement un caractère backslash \ suivi de la lettre t. Je vous conseille de toujours utiliser des chaînes brutes lorsque vous employez des expressions régulières, sinon cela devient confus très vite (et les expressions régulières peuvent devenir suffisament confuses par elles-mêmes).

***3*** *soupir* Malheureusement, je découvrais rapidement d'autres cas qui contredisaient mon raisonnement. Dans le cas présent, l'adresse contenait le mot isolé 'ROAD' mais il n'était pas à la fin de la chaîne, car l'adresse avait un numéro d'appartement après l'identifiant de la rue. Comme 'ROAD' n'était pas tout à la fin de la chaîne, il n'était pas identifié, donc l'appel de re.sub s'achèvait sans rien remplacer, j'obtenais en retour la chaîne d'origine, ce qui n'était pas le but recherché.

***4*** Pour résoudre ce problème, j'enlevais le caractère $et ajoutais un deuxième \b. L'expression régulière signifiait alors «reconnaître 'ROAD' lorsqu'il est un mot isolé, n'importe où dans la chaîne», que ce soit à la fin, au début ou quelque part au milieu.

Qu'est-ce qui serait nécessaire pour vérifier qu'une chaîne de caractères quelconque constitue des chiffres romains valides ? Nous allons opérer caractère par caractère. Puisque les chiffres romains sont toujours écrits du plus grand vers le plus petit, nous allons commencer par les plus grands : les milliers. Pour les nombres supérieurs à 1000, les milliers sont représentés par une série de caractères M.

Exemple 7.3. Rechercher les milliers▲

>>> import re
>>> pattern = '^M?M?M?$'       ***1***
>>> re.search(pattern, 'M')    ***2***
<SRE_Match object at 0106FB58>
>>> re.search(pattern, 'MM')   ***3***
<SRE_Match object at 0106C290>
>>> re.search(pattern, 'MMM')  ***4***
<SRE_Match object at 0106AA38>
>>> re.search(pattern, 'MMMM') ***5***
>>> re.search(pattern, '')     ***6***
<SRE_Match object at 0106F4A8>

Les centaines présentent plus de difficultés que les milliers car elles peuvent être exprimées de plusieurs manières mutuellement exclusives, en fonction de leur valeur.

• 100 = C
• 200 = CC
• 300 = CCC
• 400 = CD
• 500 = D
• 600 = DC
• 700 = DCC
• 800 = DCCC
• 900 = CM

Il y a donc quatre motifs possibles :

• CM
• CD
• 0 à 3 C (0 si les centaines valent 0)
• D, suivi de 0 à 3 C

Les deux derniers motifs peuvent être combinés en :

• un D optionnel, suivi de 0 à 3 C

L'exemple suivant montre comment valider les centaines en chiffres romains.

Exemple 7.4. Rechercher les centaines▲

>>> import re
>>> pattern = '^M?M?M?(CM|CD|D?C?C?C?)$' ***1***
>>> re.search(pattern, 'MCM')            ***2***
<SRE_Match object at 01070390>
>>> re.search(pattern, 'MD')             ***3***
<SRE_Match object at 01073A50>
>>> re.search(pattern, 'MMMCCC')         ***4***
<SRE_Match object at 010748A8>
>>> re.search(pattern, 'MCMC')           ***5***
>>> re.search(pattern, '')               ***6***
<SRE_Match object at 01071D98>

>>> import re
>>> pattern = '^M?M?M?$'
>>> re.search(pattern, 'M')    ***1***
<_sre.SRE_Match object at 0x008EE090>
>>> pattern = '^M?M?M?$'
>>> re.search(pattern, 'MM')   ***2***
<_sre.SRE_Match object at 0x008EEB48>
>>> pattern = '^M?M?M?$'
>>> re.search(pattern, 'MMM')  ***3***
<_sre.SRE_Match object at 0x008EE090>
>>> re.search(pattern, 'MMMM') ***4***
>>>

***1*** Cette chaîne est reconnue : le motif reconnaît le début de la chaîne, puis le premier M optionnel, mais pas de second ni de troisième M (ce qui est correct puisqu'ils sont optionnels), puis la fin de la chaîne.

***2*** Le motif reconnaît le début de la chaîne, puis le premier et le second M optionnels, mais pas de troisième M (ce qui est correct puisqu'il est optionnel), puis la fin de la chaîne.

***3*** Le motif reconnaît le début de la chaîne, puis les trois M optionnels, puis la fin de la chaîne.

***4*** Le motif reconnaît le début de la chaîne, puis les trois M optionnels, mais pas la fin de la chaîne (puisqu'il reste un M), la chaîne n'est donc pas reconnue et None est retourné.

>>> pattern = '^M{0,3}$'       ***1***
>>> re.search(pattern, 'M')    ***2***
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, 'MM')   ***3***
<_sre.SRE_Match object at 0x008EE090>
>>> re.search(pattern, 'MMM')  ***4***
<_sre.SRE_Match object at 0x008EEDA8>
>>> re.search(pattern, 'MMMM') ***5***
>>>

***1*** Ce motifie signifie : «reconnaître le début de la chaîne, puis de zéro à trois caractères M, puis la fin de la chaîne.» Le 0 et le 3 peuvent être n'importe quel nombre, si nous voulons reconnaître au moins un, mais pas plus de trois caractères M, nous pouvons écrire M{1,3}.

***2*** Le motif reconnaît le début de la chaîne, puis un M sur trois possibles, puis la fin de la chaîne.

***3*** Le motif reconnaît le début de la chaîne, puis deux M sur trois possibles, puis la fin de la chaîne.

***4*** Le motif reconnaît le début de la chaîne, puis trois M sur trois possibles, puis la fin de la chaîne.

***5*** Le motif reconnaît le début de la chaîne, puis trois M sur trois possibles, puis ne reconnaît pas la fin de la chaîne. L'expression régulière permet jusqu'à trois caractères M avant la fin de la chaîne, mais il y en a quatre, donc la chaîne n'est pas reconnue et None est retourné.

Il n'y a aucun moyen de déterminer par un programme que deux expressions régulières sont équivalentes. Le mieux que vous puissiez faire est d'écrire de nombreux cas de test pour vérifier que leur comportements sont identiques pour les entrées pertinentes. Nous discuterons plus en détail l'écriture de cas de tests plus loin dans le livre.

Maintenant, nous allons étendre l'expression régulière pour prendre en compte les dizaines et les unités. L'exemple suivant montre la recherche des dizaines.

Exemple 7.7. Rechercher les dizaines▲

>>> pattern = '^M?M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)$'
>>> re.search(pattern, 'MCMXL')    ***1***
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, 'MCML')     ***2***
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, 'MCMLX')    ***3***
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, 'MCMLXXX')  ***4***
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, 'MCMLXXXX') ***5***
>>>

>>> pattern = '^M?M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)(IX|IV|V?I?I?I?)$'

Exemple 7.8. Validation des chiffres romains avec {n,m}▲

>>> pattern = '^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$'
>>> re.search(pattern, 'MDLV')             ***1***
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, 'MMDCLXVI')         ***2***
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, 'MMMMDCCCLXXXVIII') ***3***
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, 'I')                ***4***
<_sre.SRE_Match object at 0x008EEB48>

>>> pattern = """
    ^                   # beginning of string
    M{0,4}              # thousands - 0 to 4 M's
    (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
                        #            or 500-800 (D, followed by 0 to 3 C's)
    (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
                        #        or 50-80 (L, followed by 0 to 3 X's)
    (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
                        #        or 5-8 (V, followed by 0 to 3 I's)
    $                   # end of string
    """
>>> re.search(pattern, 'M', re.VERBOSE)                ***1***
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, 'MCMLXXXIX', re.VERBOSE)        ***2***
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, 'MMMMDCCCLXXXVIII', re.VERBOSE) ***3***
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, 'M')                            ***4***

***1*** La chose la plus importante à se rappeler lorsqu'on utilise des expressions régulières détaillées est qu'il faut passer un argument supplémentaire : re.VERBOSE est une constante définie dans le module re qui signale que le motif doit être traité comme une expresion régulière détaillée. Comme vous le voyez, ce motif comprend beaucoup d'espaces (qui sont tous ignorés) et plusieurs commentaires (qui sont tous ignorés). Une fois enlevés les espaces et les commentaires, on obtient exactement la même expression régulière que nous avons vu à la section précédente, mais elle est beaucoup plus lisible.

***2*** Le motif reconnaît le début de la chaîne, puis un sur un maximum de quatre M, puis CM, puis L et trois sur un maximum de trois X. Ensuite IX et la fin de la chaîne.

***3*** Le motif reconnaît le début de la chaîne, puis quatre sur un maximum de quatre M, puis D et trois sur un maximum de trois C. Ensuite L et trois sur un maximum de trois X, puis V et trois sur un maximum de trois I et la fin de la chaîne.

***4*** Rien n'est reconnu. Pourquoi ? Parce que le drapeau re.VERBOSE n'est pas mis et donc la fonction re.search traite le motif comme une expression régulière compacte, dans laquelle les espaces et les commentaires sont pris en compte. Python ne peut pas savoir si une expression régulière est détailée ou non. Python considère que chaque expression régulière est compacte, à moins que vous ne spécifiez qu'elle est détaillée.

>>> phonePattern = re.compile(r'^(\d{3})-(\d{3})-(\d{4})$') ***1***
>>> phonePattern.search('800-555-1212').groups()            ***2***
('800', '555', '1212')
>>> phonePattern.search('800-555-1212-1234')                ***3***
>>>

***1*** Lisez toujours les expressions régulières de la gauche vers la droite. Celle-ci reconnaît le début de la chaîne, puis (\d{3}). Que veut dire ce \d{3}? Le {3} signifie «reconnaître exactement trois chiffres», c'est une variante de la syntaxe {n,m} que nous avons vu plus haut. \d signifie «n'importe quel chiffre» (de 0 à 9). En le mettant entre parenthèses, nous disons «reconnais exactement trois chiffres, puis identifie-les comme un groupe que je peux rappeler plus tard». Ensuite, le motif reconnaît un tiret, puis un autre groupe de trois chiffres, un autre tiret, un groupe de quatre chiffres et la fin de la chaîne.

***2*** Pour accéder aux groupes que l'expression régulière à identifiés, utilisez la méthode groups() de l'objet que la fonction search retourne. Elle retournera un tuple du nombre de groupes définis dans l'expression régulières. Dans ce cas, nous avons défini trois groupes, deux de trois chiffres et un de quatre.

***3*** Cette expression régulière n'est pas la réponse finale car elle ne prend pas en compte les numéros de téléphone avec une extension à la fin. Pour cela, nous allons devoir la modifier.

					>>> phonePattern = re.compile(r'^(\d{3})-(\d{3})-(\d{4})-(\d+)$') ***1***
					>>> phonePattern.search('800-555-1212-1234').groups()             ***2***
					('800', '555', '1212', '1234')
					>>> phonePattern.search('800 555 1212 1234')                      ***3***
					>>> 
					>>> phonePattern.search('800-555-1212')                           ***4***
					>>>

***1*** Cette expression régulière est pratiquement identique à la précédente. Elle reconnaît le début de la chaîne, puis un groupe identifié de trois chiffres, puis un tiret, puis un groupe identifié de trois chiffres, puis un tiret, puis un groupe identifié de quatre chiffres. Ce qui est nouveau, c'est qu'elle reconnaît ensuite un autre tiret puis un groupe identifié de un chiffre ou plus, puis la fin de la chaîne.
***2*** La méthode groups() retourne maintenant un tuple de quatre éléments, puisque l'expression régulière définit quatre groupe à identifier.
***3*** Malheureusement cette expression régulière n'est pas la réponse finale non plus, puisqu'elle considère que les différentes parties du numéro de téléphone sont séparées par des tirets. Et si elles étaient séparées par des espaces, des virgules ou des points ? Il nous faut une solution plus générale pour identifier différents types de séparateurs.
***4*** Non seulement cette expression régulière ne fait pas tout ce que nous voulions, elle est en fait un pas en arrière puisqu'elle ne peut pas reconnaître de numéros de téléphone sans extension. Ce n'est pas du tout ce que nous voulions, si l'extension est présente, nous voulons la connaître, mais si elle ne l'est pas, nous voulons tout de même connaître les différentes parties du numéro.

L'exemple suivant montre l'expression régulière qui reconnaît les séparateurs entre les différentes parties d'un numéro de téléphone.

>>> phonePattern = re.compile(r'^(\d{3})\D+(\d{3})\D+(\d{4})\D+(\d+)$') ***1***
>>> phonePattern.search('800 555 1212 1234').groups()                   ***2***
('800', '555', '1212', '1234')
>>> phonePattern.search('800-555-1212-1234').groups()                   ***3***
('800', '555', '1212', '1234')
>>> phonePattern.search('80055512121234')                               ***4***
>>> 
>>> phonePattern.search('800-555-1212')                                 ***5***
>>>

***1*** Faites bien attention. Nous reconnaissons le début de la chaîne, puis un groupe de trois chiffres, puis \D+. Qu'est-ce que c'est que ça ? Et bien, \D reconnaît n'importe quel caractère sauf un chiffre et + signifie «un ou plus». Donc \D+ reconnaît un ou plusieurs caractères n'étant pas des chiffres. C'est ce que nous utilisons pour essayer de reconnaitre les séparateurs.

***2*** Utiliser \D+ au lieu de - nous permet de reconnaître des numéros de téléphone dont les différentes parties sont séparées par des espaces au lieu de tirets.

***3*** Bien sûr, les numéro de téléphone séparés par des tirets sont toujours reconnus.

***4*** Malheureusement ce n'est pas encore la réponse définitive car elle suppose qu'il y a bien un séparateur. Et si le numéro est saisi sans espaces ni tirets ?

***4*** Le problème de l'extension optionnelle n'a toujours pas été réglé. Maintenant nous avons deux problèmes, mais nous pouvons les régler tous les deux grâce à la même technique.

L'exemple suivant montre l'expression régulière qui reconnaît les numéros de téléphone sans séparateurs.

>>> phonePattern = re.compile(r'^(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$') ***1***
>>> phonePattern.search('80055512121234').groups()                      ***2***
('800', '555', '1212', '1234')
>>> phonePattern.search('800.555.1212 x1234').groups()                  ***3***
('800', '555', '1212', '1234')
>>> phonePattern.search('800-555-1212').groups()                        ***4***
('800', '555', '1212', '')
>>> phonePattern.search('(800)5551212 x1234')                           ***5***
>>>

***1*** La seule modification depuis la dernière étape est de remplacer le + par un *. Au lieu de \D+ entre les différentes parties du numéro de téléphone, nous avons maintenant \D*. Vous vous rappelez que + signifie «un ou plus» et bien * signifie «zéro ou plus». Nous devrions donc pouvoir reconnaître des numéros de téléphone qui n'ont pas de séparateur du tout.

***2*** Et ça marche. Nous avons reconnu le début de la chaîne, puis un groupe identifié de trois chiffres (800), puis zéro caractères non numériques, puis un groupe identifié de trois caractères (555), puis zéro caractères non numériques, puis un groupe identifié de quatre caractères (1212), puis zéro caractères non numériques, puis un groupe identifié d'un nombre quelconque de caractères (1234), puis la fin de la chaîne.

***3*** D'autre variantes marchent également maintenant : des points à la place des tirets et un espace et un x avant l'extension.

***4*** Finalement, nous avons trouvé une solution à notre problème, les extension sont vraiment optionnelles. Si aucune extension n'est trouvée la méthode groups() retourne un tuple de quatre éléments, mais le quatrième élément est simplement une chaîne vide.

***5*** La mauvaise nouvelle, c'est que nous n'avons pas terminé. Il y a un caractère supplémentaire avant le code régional, mais l'expression régulière suppose que le code régional est la première chose au début de la chaîne. Bien sûr, nous pouvons utiliser la même technique «zéro ou plus caractères non-numériques» pour sauter les caractères situés avant le code régional.

L'exemple suivant montre comment prendre en compte les caractères au début des numéros de téléphone.

>>> phonePattern = re.compile(r'^\D*(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$') ***1***
>>> phonePattern.search('(800)5551212 ext. 1234').groups()                 ***2***
('800', '555', '1212', '1234')
>>> phonePattern.search('800-555-1212').groups()                           ***3***
('800', '555', '1212', '')
>>> phonePattern.search('work 1-(800) 555.1212 #1234')                     ***4***
>>>

***1*** C'est la même chose que dans l'exemple précédent, sauf que nous reconnaissons \D*, c'est à dire zéro ou plus caractères non numériques, avant le premier groupe identifié (le code régional). Notez que nous n'identifions pas ces caractères non numériques (ils ne sont pas entre parenthèses). Si ils sont présents, nous les passons simplement et commençont à identifier le code régional quand nous y arrivons.

***2*** Le numéro de téléphone est correctement reconnu, même avec la parenthèse ouvrante devant le code régional (la parenthèse fermante était déjà prise en compte, elle est considérée comme un séparateur non-numérique et reconnue par le \D* suivant le premier groupe identifié).

***3*** Une simple vérification de cohérence pour nous assurer que nous n'avons rien endommagé de ce qui fonctionnait déjà. Puisque les caractères de début sont entièrement optionnels, le début de la chaîne est reconnu, puis zéro caractères non-numériques, puis un groupe identifié de trois caractères (800), puis un caractère non-numérique (le tiret), puis un groupe identifié de trois caractères (555), puis un caractère non-numérique (le tiret), puis un groupe identifié de quatre caractères (1212), puis zéro caractères non-numériques, puis un groupe identifié de zéro caractères numériques, puis la fin de la chaîne.

***4*** Mais il y a encore un problème. Pourquoi ce numéro ne fonctionne-t-il pas ? Parce qu'il y a un 1 avant le code régional et que nous avons considéré que tous les caractères de début sont non-numériques (\D*).

Faisons le point. Jusqu'à présent, nos expressions régulières commençaient toujours la reconnaissance en début de chaîne, mais maintenant nous voyons qu'il peut y avoir un nombre indeterminé de caractères à ignorer en début de chaîne. Au lieu d'essayer de les identifier pour les sauter, essayons une approche différente : ne pas reconnaître explicitemment le début de la chaîne. C'est ce que nous verrons dans l'exemple suivant.

>>> phonePattern = re.compile(r'(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$') ***1***
>>> phonePattern.search('work 1-(800) 555.1212 #1234').groups()        ***2***
('800', '555', '1212', '1234')
>>> phonePattern.search('800-555-1212')                                ***3***
('800', '555', '1212', '')
>>> phonePattern.search('80055512121234')                              ***4***
('800', '555', '1212', '1234')

***1*** Notez l'absence de ^ dans cette expression régulière. Nous ne reconnaissons plus le début de la chaîne. Rien ne nous oblige à reconnaître la chaîne entière, le moteur d'expressions régulières se débrouillera pour trouver où commence la reconnaissance.

***2*** Maintenant, nous pouvons reconnaître un numéro de téléphone précédé de caractères et de chiffres et segmenté par des séparateurs de tout type et de toute taille.

***3*** Contrôle de cohérence, ça fonctionne toujours.

***4*** Cela aussi fonctionne toujours.

Vous avez pu voir comment les expressions régulières peuvent rapidemment échapper à tout contrôle. Parcourez les différentes versions de notre expression régulière, pouvez-vous dire quelles différences les séparent ?

Tant que nous comprenons encore la version finale (et c'est bien la version finale, si vous découvrez un cas qu'elle n'est pas capable de traiter, je ne veux pas en entendre parler), écrivons-la sous la forme d'une expression régulière détaillée avant d'oublier les choix que nous avons fait.

>>> phonePattern = re.compile(r'''
                # don't match beginning of string, number can start anywhere
    (\d{3})     # area code is 3 digits (e.g. '800')
    \D*         # optional separator is any number of non-digits
    (\d{3})     # trunk is 3 digits (e.g. '555')
    \D*         # optional separator
    (\d{4})     # rest of number is 4 digits (e.g. '1212')
    \D*         # optional separator
    (\d*)       # extension is optional and can be any number of digits
    $           # end of string
    ''', re.VERBOSE)
>>> phonePattern.search('work 1-(800) 555.1212 #1234').groups()        ***1***
('800', '555', '1212', '1234')
>>> phonePattern.search('800-555-1212')                                ***2***
('800', '555', '1212', '')

***1*** Mis à part le fait qu'elle est distribuée sur plusieurs lignes, c'est exactement la même expression régulière qu'à la dernière étape, il n'est donc pas étonnant qu'elle reconnaisse les mêmes entrées de manière identique.

***2*** Vérification de cohérence finale. Oui, ça marche toujours, nous avons terminé.

Pour en savoir plus sur les expressions régulières

• La Regular Expression HOWTO explique les expressions régulières et leur usage en Python.
• La Python Library Reference résume le module re.