Expressions régulières

Le module qui fait des expressions régulières (regexp) s'appelle re (import re).

Recherche très simple et compacte d'un pattern (une expression régulière) dans une chaîne : re.search('[A-Z]\d+', myString) :

renvoie None si pattern non trouvé.
renvoie un match object si pattern trouvé.
on peut aussi utiliser des flags, comme la recherche case-insensitive : re.search('de', 'ACBDEFG', re.I) (renvoie un match ici).

Construction d'un pattern :

myPattern = re.compile('a\d{2}\tb\d+', re.I) (ici avec un flag qui dit que c'est case-insensitif).
myPattern.pattern : redonne la chaîne de départ qui a servit à construire le pattern.

Recherche d'un pattern :

match = myPattern.search('wwA34\tB678www') : recherche le pattern dans la string donnée et renvoie un objet match si il est trouvé
match = myPattern.match('A34\tB678www') : comme search, mais doit matcher en début de ligne.
match vaut alors None si le pattern n'est pas trouvé, sinon, c'est un objet.
si un match a été trouvé, match.start() et match.end() donnent les positions à utiliser pour récuperer tout le match (position de début et position de fin + 1)

Split selon un pattern :

myPattern.split('wwwwA34\tB678xxxxa12\tb987yyyy') : splitte selon le pattern donné et renvoie la liste des chaînes intermédiaires.
renvoie une liste avec un seul élément qui est la chaîne complète si le pattern n'est pas présent.
on peut aussi faire re.split('\d+', 'a23b1212cd9e')

Recherche multiple de patterns non overlappant, et retourne tous les patterns non overlappant sous forme de liste :

pat = re.compile('\d+[MID]'); pat.findall('2M3D5M1-I8MX') renvoie ['2M', '3D', '5M', '8M']
si un seul groupe entre parenthèse, renvoie la liste des groupes matchés (les group(1)) : re.compile('[-_](D\d+)').findall('abc_D23-D12_') renvoie ['D23', 'D12']
si plusieurs groupes entre parenthèses, renvoie la liste des tuples correspondant aux différents groupes : re.compile('([-_])(D\d+)').findall('abc_D23-D12_') renvoie [('_', 'D23'), ('-', 'D12')]
si aucun match, renvoie une liste vide.

si on veut avoir les matchs successifs, par exemple pour récupérer leurs positions :

pattern = re.compile(PATTERN)
for match in pattern.finditer(myString):
  print(match.group(), match.start(), match.end())

Récupération des groupes :

myPattern = re.compile('(a\d{2})\t(b\d+)', re.I) : définition de groupes avec les parenthèses
match = myPattern.search('wwwwA34\tB678xxxx') : recherche
match.group(1) : la première parenthèse matchante
match.groups() : un tuple avec toutes les parenthèses matchantes
match.start(1) et match.end(1) : les positions à utiliser pour récupérer le premier groupe (position de début et position de fin + 1)
match.group(0) : pour avoir tout le match

Substitutions :

re.sub(pattern, replacement, string) : effectue la substitution du pattern par la chaîne de remplacement qui peut utiliser \1, \2, ... pour les groupes, mais attention, il faut backslasher le \ ! Attention, le pattern doit matcher toute la chaîne.
re.sub fait des substitutions répétées si le pattern matche plusieurs fois (mais pas avec des matchs se chevauchant !)
exemple : re.sub('(\d+).*', 'number : \\1', s)
on peut aussi désactiver l'interprétation des \ avec 'r' : re.sub('(\d+).*', r'number : \1', s)

programmer en python, tutoriel python, graphes en python, Aymeric Duclert