Plongez au coeur de Python

Exemple 17.1. plural1.py

import re

def plural(noun):                            
    if re.search('[sxz]$', noun):             
        return re.sub('$', 'es', noun)        
    elif re.search('[^aeioudgkprt]h$', noun):
        return re.sub('$', 'es', noun)       
    elif re.search('[^aeiou]y$', noun):      
        return re.sub('y$', 'ies', noun)     
    else:                                    
        return noun + 's'                    

	C'est une expression régulière, mais elle utilise une syntaxe que vous n'avez pas vue au Chapitre 7, Expressions régulières. Les crochets signifient «reconnaître exactement un de ces caractères». Donc [sxz] signifie «s ou x ou z», mais seulement l'une de ces trois lettres. Le $ doit vous être familier, il reconnaît la fin de la chaîne. Il s'agit donc de vérifier si noun se termine par s, x ou z.
	La fonction re.sub effectue des remplacements à partir d'une expression régulière. Examinons-la en détail.

Exemple 17.2. Présentation de re.sub

>>> import re
>>> re.search('[abc]', 'Mark')   
<_sre.SRE_Match object at 0x001C1FA8>
>>> re.sub('[abc]', 'o', 'Mark') 
'Mork'
>>> re.sub('[abc]', 'o', 'rock') 
'rook'
>>> re.sub('[abc]', 'o', 'caps') 
'oops'

	La chaîne Mark contient-elle a, b ou c ? Oui, elle contient a.
	Maintenant, recherchons a, b ou c, et remplaçons-le par o. Mark devient Mork.
	La même fonction transforme rock en rook.
	Vous auriez pu croire qu'elle transformerait caps en oaps, mais ce n'est pas le cas. re.sub remplace tout ce qui a été reconnu, pas seulement la première occurrence. Cette expression régulière transforme donc caps en oops, aussi bien le c que le a sont remplacés par o.

Exemple 17.3. Retour à plural1.py

import re

def plural(noun):                            
    if re.search('[sxz]$', noun):            
        return re.sub('$', 'es', noun)        
    elif re.search('[^aeioudgkprt]h$', noun): 
        return re.sub('$', 'es', noun)        
    elif re.search('[^aeiou]y$', noun):      
        return re.sub('y$', 'ies', noun)     
    else:                                    
        return noun + 's'                    

	Retour à la fonction plural. Que faisons nous ? Nous remplaçons la fin de chaîne par es. En d'autre termes, nous ajoutons es à la chaîne. Nous pourrions accomplir la même chose avec une concaténation, par exemple noun + 'es', mais j'utilise les expressions régulières pour tous les cas pour des raisons de cohérence, raisons qui deviendront plus claires plus loin dans le chapitre.
	Regardez attentivement, c'est encore une nouvelle variation. Le ^ comme premier caractère entre les crochets signifie quelque chose de spécial : la négation. [^abc] signifie «n'importe quel caractère unique sauf a, b ou c». Donc [^aeioudgkprt] signifie n'importe quel caractère sauf a, e, i, o, u, d, g, k, p, r ou t. Ensuite, ce caractère doit être suivi de h, suivi par la fin de chaîne. Nous cherchons les mots qui finissent par H dans lesquels le H est prononcé.
	Même motif ici : reconnaître les mots qui finissent par Y, dans lesquels le caractère qui précède Y n'est pas a, e, i, o ou u. Nous recherchons des mots qui se finissent par un Y prononcé comme I.

Exemple 17.4. Expressions régulières avec négation

>>> import re
>>> re.search('[^aeiou]y$', 'vacancy') 
<_sre.SRE_Match object at 0x001C1FA8>
>>> re.search('[^aeiou]y$', 'boy')     
>>> 
>>> re.search('[^aeiou]y$', 'day')
>>> 
>>> re.search('[^aeiou]y$', 'pita')    
>>> 

	vacancy est reconnu par cette expression régulière parce qu'il se termine par cy, c n'est pas a, e, i, o ou u.
	boy n'est pas reconnu, il se termine par oy et nous avons spécifié que le caractère précédent le y ne pouvait pas être o. day n'est pas reconnu car il se termine par ay.
	pita n'est pas reconnu parce qu'il ne se termine pas par y.

Exemple 17.5. Fonctionnement de re.sub

>>> re.sub('y$', 'ies', 'vacancy')              
'vacancies'
>>> re.sub('y$', 'ies', 'agency')
'agencies'
>>> re.sub('([^aeiou])y$', r'\1ies', 'vacancy') 
'vacancies'

Cette expression régulière transforme vacancy en vacancies et agency en agencies, ce qui est le but recherché. Notez qu'elle transformerait également boy en boies, mais cela n'arrivera jamais puisque nous faison d'abord le re.search pour savoir si nous devons effectuer le re.sub.

Juste au passage, je veux souligner qu'il est possible de combiner ces deux expressions régulières (une pour savoir si la règle s'applique, l'autre pour l'appliquer effectivement) en une seule expression régulière. Voilà à quoi ça ressemblerait. Elle devrait être familière : elle utilise un groupe mémorisé, ce que vous avez appris à la Section 7.6, «Etude de cas : reconnaissance de numéros de téléphone», pour se rappeler du caractère avant le y. Ensuite, dans la chaîne de substitution, elle utilise une nouvelle syntaxe, \1, qui signifie «hep, ce premier groupe que tu as mémorisé, met le ici». Dans ce cas, elle a mémorisé le c devant le y et donc elle substitue un c au c et ies à y (si on a plus d'un groupe mémorisé, on utilise \2 et \3 etc.).

Les remplacements par expressions régulières sont extrêmement puissants et la syntaxe \1 les rend encore plus puissants. Mais combiner l'opération entière en une seule expression régulière est également beaucoup plus difficile à lire et ne correspond pas à la manière dont les règles de pluriel des noms ont été définies au début. Les règles se présente de la manière suivante : «si le mot se termine par S, X ou Z, alors ajouter ES». Si vous regardez cette fonction, vous verrez deux lignes de codes qui disent «si le mot se termine par S, X ou Z, alors ajouter ES». Difficile de trouver une correspondance plus directe.