• PYTHON > les expressions régulières (regex)

      ATTENTION : ‘\n’ ou alors r’\\n’.

       

      if re.match(regex, content) is not None:
         print('RegEx trouvée')

      Syntaxe des expressions rationnelles

      import re
      m = re.search('(?<=abc)def', 'abcdef')
      m.group(0)
      def

       

      Cet exemple recherche un mot suivi d’un trait d’union :

      m = re.search(r'(?<=-)\w+', 'spam-egg')
      m.group(0)
      egg

      Contenu du module

      re.compile

      Toujours préférer re.compile si on utilise plusieurs fois match() et search()

      prog = re.compile(pattern)
      result = prog.match(string)

       

      est équivalent à :

      result = re.match(pattern, string)

      re.IGNORECASE

      Correspond au marqueur en ligne (?i).

      re.MULTILINE

      Quand spécifiée, le caractère ‘^’ correspond au début d’une chaîne et au début d’une ligne (caractère suivant directement le saut de ligne) ; et le caractère ‘$’ correspond à la fin d’une chaîne et à la fin d’une ligne (juste avant le saut de ligne). Par défaut, ‘^’ correspond uniquement au début de la chaîne, et ‘$’ uniquement à la fin de la chaîne, ou immédiatement avant le saut de ligne (s’il y a) à la fin de la chaîne. Correspond à l’option en ligne (?m).

      re.DOTALL

      Fait correspondre tous les caractères possibles à ‘.’, incluant le saut de ligne ; sans cette option, ‘.’ correspondrait à tout caractère à l’exception du saut de ligne. Correspond à l’option en ligne (?s).

      re.VERBOSE

      permet d’écrire des regex qui présentent mieux et sont plus lisibles en vous permettant de séparer visuellement les sections logiques du motif et d’ajouter des commentaires. Les caractères d’espacement à l’intérieur du motif sont ignorés, sauf à l’intérieur des classes de caractères ou quand précédés d’un backslash non échappé, ou dans des séquences comme *?, (?: or (?P<…>. Quand une ligne contient un # qui n’est pas dans une classe de caractères ou précédé d’un backslash non échappé, tous les caractères depuis le # le plus à gauche jusqu’à la fin de la ligne sont ignorés.

      Cela signifie que les deux expressions rationnelles suivantes qui valident un nombre décimal sont fonctionnellement égales :

       

      a = re.compile(r"""\d +  # the integral part
                         \.    # the decimal point
                         \d *  # some fractional digits""", re.X)
      b = re.compile(r"\d+\.\d*")

       

      Correspond à l’option de groupe (?x).

      re.search()

      re.search(pattern, string, flags=0)

      Analyse string à la recherche du premier emplacement où l’expression rationnelle pattern trouve une correspondance, et renvoie l”objet de correspondance trouvé. Renvoie None si aucune position dans la chaîne ne valide le motif.

      re.match()

      re.match(pattern, string, flags=0)

      Si zéro ou plus caractères au début de string correspondent à l’expression rationnelle pattern, renvoie l”objet de correspondance trouvé. Renvoie None si la chaîne ne correspond pas au motif ; notez que cela est différent d’une correspondance avec une chaîne vide.

      Si vous voulez trouver une correspondance n’importe où dans string, utilisez plutôt search() (voir aussi search() vs. match()).

      re.fullmatch()

      re.fullmatch(pattern, string, flags=0)

      Si l’entièreté de la chaîne string correspond à l’expression rationnelle pattern, renvoie l”objet de correspondance trouvé. Renvoie None si la chaîne ne correspond pas au motif ; notez que cela est différent d’une correspondance avec une chaîne vide.

      re.split()

      re.split(pattern, string, maxsplit=0, flags=0)

      Sépare string selon les occurrences de pattern. Si des parenthèses de capture sont utilisées dans pattern, alors les textes des groupes du motif sont aussi renvoyés comme éléments de la liste résultante. Si maxsplit est différent de zéro, il ne pourra y avoir plus de maxsplit séparations, et le reste de la chaîne sera renvoyé comme le dernier élément de la liste. :

       

      re.split(r'\W+', 'Words, words, words.')
      ['Words', 'words', 'words', '']
      re.split(r'(\W+)', 'Words, words, words.')
      ['Words', ', ', 'words', ', ', 'words', '.', '']
      re.split(r'\W+', 'Words, words, words.', 1)
      ['Words', 'words, words.']
      re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
      ['0', '3', '9']

       

      S’il y a des groupes de capture dans le séparateur et qu’ils trouvent une correspondance au début de la chaîne, le résultat commencera par une chaîne vide. La même chose se produit pour la fin de la chaîne :

       

      re.split(r'(\W+)', '...words, words...')
      ['', '...', 'words', ', ', 'words', '...', '']

       

      De cette manière, les séparateurs sont toujours trouvés aux mêmes indices relatifs dans la liste résultante.

      Note : split() ne sépare actuellement pas une chaîne sur une correspondance vide. Par exemple :

       

      re.split('x*', 'axbc')
      ['a', 'bc']

       

      Même si ‘x*’ correspond aussi à 0 “x” avant “a”, entre “b” et “c”, et après “c”, ces correspondances sont actuellement ignorées. Le comportement correct (i.e. découper aussi sur les correspondances vides et renvoyer ['', 'a', 'b', 'c', '']) sera implémenté dans les futures versions de Python, mais comme cela constitue un changement incompatible avec les précédentes, une FutureWarning sera levée pendant la transition.

      Les motifs qui ne peuvent correspondre qu’à des chaînes vides ne permettent actuellement pas de découper la chaîne. Puisque cela ne correspond pas au comportement voulu, une ValueError sera levée à partir de Python 3.5 :

       

      re.split("^$", "foo\n\nbar\n", flags=re.M)
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        ...
      ValueError: split() requires a non-empty pattern match.

       

      Modifié dans la version 3.5: Découper sur un motif qui peut correspondre à une chaîne vide lève maintenant un avertissement. Les motifs qui ne peuvent correspondre qu’à des chaînes vides sont maintenant rejetés.

      re.findall()

      re.findall(pattern, string, flags=0)

      Renvoie toutes les correspondances de pattern dans string qui ne se chevauchent pas, sous forme d’une liste de chaînes. Le chaîne string est analysée de la gauche vers la droite, et les correspondances sont renvoyées dans l’ordre où elles sont trouvées. Si un groupe ou plus sont présents dans le motif, renvoie une liste de groupes ; il s’agira d’une liste de tuples si le motif a plus d’un groupe. Les correspondances vides sont incluses dans le résultat.

      Note ; Due to the limitation of the current implementation the character following an empty match is not included in a next match, so findall(r’^|\w+’, ‘two words’) returns ['', 'wo', 'words'] (note missed « t »). This is changed in Python 3.7.

      re.finditer()

      re.finditer(pattern, string, flags=0)

      Renvoie un iterator produisant des objets de correspondance pour toutes les correspondances non chevauchantes de l’expression rationnelle pattern sur la chaîne string. string est analysée de la gauche vers la droite, et les correspondances sont renvoyées dans l’ordre où elles sont trouvées. Les correspondances vides sont inclues dans le résultat. Consultez la note à propos de findall().

      re.sub()

      re.sub(pattern, repl, string, count=0, flags=0)

      Renvoie la chaîne obtenue en remplaçant les occurrences (sans chevauchement) les plus à gauche de pattern dans string par le remplacement repl.

      repl peut être une chaîne de caractères ou une fonction. Les références arrières, telles que \6, sont remplacées par la sous-chaîne correspondant au groupe 6 dans le motif. Par exemple :

      re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):', r'static PyObject*\npy_\1(void)\n{', 'def myfunc():')
      'static PyObject*\npy_myfunc(void)\n{'

       

      Si repl est une fonction, elle est appelée pour chaque occurrence non chevauchante de pattern. La fonction prend comme argument un objet de correspondance, et renvoie la chaîne de remplacement. Par exemple :

       

      def dashrepl(matchobj):
          if matchobj.group(0) == '-': return ' '
          else: return '-'
      re.sub('-{1,2}', dashrepl, 'pro----gram-files')
      'pro--gram files'
      re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)
      'Baked Beans & Spam'

       

      Le motif peut être une chaîne de caractères ou un objet expression rationnelle.

      L’argument optionnel count est le nombre maximum d’occurrences du motif à remplacer : count ne doit pas être un nombre négatif. Si omis ou nul, toutes les occurrences seront remplacées. Les correspondances vides avec le motif sont remplacées uniquement quand elles ne sont pas adjacentes à une précédente correspondance, ainsi sub(‘x*’, ‘-’, ‘abc’) renvoie ‘-a-b-c-’.

      Dans les arguments repl de type string, en plus des séquences d’échappement et références arrières décrites au-dessus, \g<name> utilisera la sous-chaîne correspondant au groupe nommé name, comme défini par la syntaxe (?P<name>…). \g<number> utilise le groupe numéroté associé ; \g<2> est ainsi équivalent à \2, mais n’est pas ambigu dans un remplacement tel que \g<2>0, \20 serait interprété comme une référence au groupe 20, et non une référence au groupe 2 suivie par un caractère littéral ’0′. La référence arrière \g<0> est remplacée par la sous-chaîne entière validée par l’expression rationnelle.

      Modifié dans la version 3.1: Ajout de l’argument optionnel flags.

      Modifié dans la version 3.5: Les groupes sans correspondance sont remplacés par une chaîne vide.

      Modifié dans la version 3.6: Les séquences d’échappement inconnues dans pattern formées par ‘\’ et une lettre ASCII sont maintenant des erreurs.

      Deprecated since version 3.5, will be removed in version 3.7: Les séquences d’échappement dans repl formées d’un ‘\’ et d’une lettre ASCII lèvent maintenant un avertissement de dépréciation et seront interdites en Python 3.7.

      re.subn()

      re.subn(pattern, repl, string, count=0, flags=0)

      Réalise la même opération que sub(), mais renvoie un tuple (nouvelle_chaîne, nombre_de_substitutions_réalisées).

      Modifié dans la version 3.1: Ajout de l’argument optionnel flags.

      Modifié dans la version 3.5: Les groupes sans correspondance sont remplacés par une chaîne vide.

      re.escape()

      re.escape(pattern)

      Échappe tous les caractères de pattern à l’exception des lettres ASCII, des nombres et de ‘_’. Cela est utile si vous voulez valider une quelconque chaîne littérale qui pourrait contenir des métacaractères d’expressions rationnelles. Par exemple :

       

      print(re.escape('python.exe'))
      python\.exe
      
      legal_chars = string.ascii_lowercase + string.digits + "!#$%&'*+-.^_`|~:"
      print('[%s]+' % re.escape(legal_chars))
      [abcdefghijklmnopqrstuvwxyz0123456789\!\#\$\%\&\'\*\+\-\.\^_\`\|\~\:]+
      
      operators = ['+', '-', '*', '/', '**']
      print('|'.join(map(re.escape, sorted(operators, reverse=True))))
      \/|\-|\+|\*\*|\*

       

      Ces fonctions ne doivent pas être utilisées pour la chaîne de remplacement dans sub() et subn(), seuls les antislash devraient être échappés. Par exemple :

       

      digits_re = r'\d+'
      sample = '/usr/sbin/sendmail - 0 errors, 12 warnings'
      print(re.sub(digits_re, digits_re.replace('\\', r'\\'), sample))
      /usr/sbin/sendmail - \d+ errors, \d+ warnings

       

      Modifié dans la version 3.3: Le caractère ‘_’ n’est plus échappé.

      re.purge()

      Vide le cache d’expressions rationnelles.

      exception re.error(msg, pattern=None, pos=None)

      Exception levée quand une chaîne passée à l’une des fonctions ici présentes n’est pas une expression rationnelle valide (contenant par exemple une parenthèse non fermée) ou quand d’autres erreurs se produisent durant la compilation ou l’analyse. Il ne se produit jamais d’erreur si une chaîne ne contient aucune correspondance pour un motif. Les instances de l’erreur ont les attributs additionnels suivants :

      msg Le message d’erreur non formaté.

      pattern Le motif d’expression rationnelle.

      pos L’index dans pattern où la compilation a échoué (peut valoir None).

      lineno La ligne correspondant à pos (peut valoir None).

      colno La colonne correspondant à pos (peut valoir None).

      Objets d’expressions rationnelles

      Les expressions rationnelles compilées supportent les méthodes et attributs suivants :

       

      regex.search(string[, pos[, endpos]])

      Analyse string à la recherche du premier emplacement où l’expression rationnelle trouve une correspondance, et envoie l”objet de correspondance trouvé. Renvoie None si aucune position dans la chaîne ne satisfait le motif ; notez que cela est différent que de trouver une correspondance vide dans la chaîne.

      Le second paramètre pos (optionnel) donne l’index dans la chaîne où la recherche doit débuter ; il vaut 0 par défaut. Cela n’est pas complètement équivalent à un slicing sur la chaîne ; le caractère de motif ‘^’ correspond au début réel de la chaîne et aux positions juste après un saut de ligne, mais pas nécessairement à l’index où la recherche commence.

      Le paramètre optionnel endpos limite la longueur sur laquelle la chaîne sera analysée ; ce sera comme si la chaîne faisait endpos caractères de long, donc uniquement les caractères de pos à endpos - 1 seront analysés pour trouver une correspondance. Si endpos est inférieur à pos, aucune correspondance ne sera trouvée ; dit autrement, avec rx une expression rationnelle compilée, rx.search(string, 0, 50) est équivalent à rx.search(string[:50], 0).

       

      pattern = re.compile("d")
      pattern.search("dog")     # Match at index 0
      <_sre.SRE_Match object; span=(0, 1), match='d'>
      pattern.search("dog", 1)  # No match; search doesn't include the "d"

       

      regex.match(string[, pos[, endpos]])

      Si zéro caractère ou plus au début de string correspondent à cette expression rationnelle, renvoie l”objet de correspondance trouvé. Renvoie None si la chaîne ne correspond pas au motif ; notez que cela est différent d’une correspondance vide.

      Les paramètres optionnels pos et endpos ont le même sens que pour la méthode search().

       

      pattern = re.compile("o")
      pattern.match("dog")      # No match as "o" is not at the start of "dog".
      pattern.match("dog", 1)   # Match as "o" is the 2nd character of "dog".
      <_sre.SRE_Match object; span=(1, 2), match='o'>

      Si vous voulez une recherche n’importe où dans string, utilisez plutôt search() (voir aussi search() vs. match()).

       

      regex.fullmatch(string[, pos[, endpos]])

      Si la chaîne string entière valide l’expression rationnelle, renvoie l”object de correspondance associé. Renvoie None si la chaîne ne correspond pas au motif ; notez que cela est différent d’une correspondance vide.

      Les paramètres optionnels pos et endpos ont le même sens que pour la méthode search().

       

      pattern = re.compile("o[gh]")
      pattern.fullmatch("dog")      # No match as "o" is not at the start of "dog".
      pattern.fullmatch("ogre")     # No match as not the full string matches.
      pattern.fullmatch("doggie", 1, 3)   # Matches within given limits.
      <_sre.SRE_Match object; span=(1, 3), match='og'>

      Nouveau dans la version 3.4.

       

      regex.split(string, maxsplit=0)

      Identique à la fonction split(), en utilisant le motif compilé.

       

      regex.findall(string[, pos[, endpos]])

      Similaire à la fonction findall(), en utilisant le motif compilé, mais accepte aussi des paramètres pos et endpos optionnels qui limitent la région de recherche comme pour search().

       

      regex.finditer(string[, pos[, endpos]])

      Similaire à la fonction finditer(), en utilisant le motif compilé, mais accepte aussi des paramètres pos et endpos optionnels qui limitent la région de recherche comme pour search().

       

      regex.sub(repl, string, count=0)

      Identique à la fonction sub(), en utilisant le motif compilé.

       

      regex.subn(repl, string, count=0)

      Identique à la fonction subn(), en utilisant le motif compilé.

       

      regex.flags

      Les options de validation de l’expression rationnelle. Il s’agit d’une combinaison des options données à compile(), des potentielles options (?…) dans le motif, et des options implicites comme UNICODE si le motif est une chaîne Unicode.

       

      regex.groups

      Le nombre de groupes de capture dans le motif.

       

      regex.groupindex

      Un dictionnaire associant les noms de groupes symboliques définis par (?P<id>) aux groupes numérotés. Le dictionnaire est vide si aucun groupe symbolique n’est utilisé dans le motif.

       

      regex.pattern

      La chaîne de motif depuis laquelle l’objet expression rationnelle a été compilé.

      Objets de correspondance

      Les objets de correspondance ont toujours une valeur booléenne True. Puisque match() et search() renvoient None quand il n’y a pas de correspondance, vous pouvez tester s’il y a eu correspondance avec une simple instruction if :

       

      match = re.search(pattern, string)
      if match:
          process(match)

       

      Les objets de correspondance supportent les méthodes et attributs suivants :

       

      match.expand(template)

      Renvoie la chaîne obtenue en substituant les séquences d’échappement du gabarit template, comme réalisé par la méthode sub(). Les séquences comme \n sont converties vers les caractères appropriés, et les références arrières numériques (\1, \2) et nommées (\g<1>, \g<name>) sont remplacées par les contenus des groupes correspondant.

      Modifié dans la version 3.5: Les groupes sans correspondance sont remplacés par une chaîne vide.

       

      match.group([group1, ...])

      Renvoie un ou plus sous-groupes de la correspondance. Si un seul argument est donné, le résultat est une chaîne simple ; s’il y a plusieurs arguments, le résultat est un tuple comprenant un élément par argument. Sans arguments, group1 vaut par défaut zéro (la correspondance entière est renvoyée). Si un argument groupN vaut zéro, l’élément associé sera la chaîne de correspondance entière ; s’il est dans l’intervalle fermé [1..99], c’est la correspondance avec le groupe de parenthèses associé. Si un numéro de groupe est négatif ou supérieur au nombre de groupes définis dans le motif, une exception indexError est levée. Si un groupe est contenu dans une partie du motif qui n’a aucune correspondance, l’élément associé sera None. Si un groupe est contenu dans une partie du motif qui a plusieurs correspondances, seule la dernière correspondance est renvoyée.

       

      m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
      m.group(0)    # The entire match
      'Isaac Newton'
      m.group(1)    # The first parenthesized subgroup.
      'Isaac'
      m.group(2)    # The second parenthesized subgroup.
      'Newton'
      m.group(1, 2) # Multiple arguments give us a tuple.
      ('Isaac', 'Newton')

       

      Si l’expression rationnelle utilise la syntaxe (?P<name>…), les arguments groupN peuvent alors aussi être des chaînes identifiant les groupes par leurs noms. Si une chaîne donnée en argument n’est pas utilisée comme nom de groupe dans le motif, une exception IndexError est levée.

      Un exemple modérément compliqué :

       

      m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
      m.group('first_name')
      'Malcolm'
      m.group('last_name')
      'Reynolds'

       

      Les groupes nommés peuvent aussi être référencés par leur index :

       

      m.group(1)
      'Malcolm'
      m.group(2)
      'Reynolds'

       

      Si un groupe a plusieurs correspondances, seule la dernière est accessible :

       

      m = re.match(r"(..)+", "a1b2c3")  # Matches 3 times.
      m.group(1)                        # Returns only the last match.
      'c3'

       

      match.__getitem__(g)

      Cela est identique à m.group(g). Cela permet un accès plus facile à un groupe individuel depuis une correspondance :

       

      >>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
      >>> m[0]       # The entire match
      'Isaac Newton'
      >>> m[1]       # The first parenthesized subgroup.
      'Isaac'
      >>> m[2]       # The second parenthesized subgroup.
      'Newton'

       

      Nouveau dans la version 3.6.

       

      match.groups(default=None)

      Renvoie un tuple contenant tous les sous-groupes de la correspondance, de 1 jusqu’au nombre de groupes dans le motif. L’argument default est utilisé pour les groupes sans correspondance ; il vaut None par défaut.

      Par exemple :

       

      >>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
      >>> m.groups()
      ('24', '1632')

       

      Si on rend la partie décimale et tout ce qui la suit optionnels, tous les groupes ne figureront pas dans la correspondance. Ces groupes sans correspondance vaudront None sauf si une autre valeur est donnée à l’argument default :

       

      >>> m = re.match(r"(\d+)\.?(\d+)?", "24")
      >>> m.groups()      # Second group defaults to None.
      ('24', None)
      >>> m.groups('0')   # Now, the second group defaults to '0'.
      ('24', '0')

       

      match.groupdict(default=None)

      Renvoie un dictionnaire contenant tous les sous-groupes nommés de la correspondance, accessibles par leurs noms. L’argument default est utilisé pour les groupes qui ne figurent pas dans la correspondance ; il vaut None par défaut. Par exemple :

       

      >>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
      >>> m.groupdict()
      {'first_name': 'Malcolm', 'last_name': 'Reynolds'}

       

      match.start([group])

       

      match.end([group])

      Renvoie les indices de début et de fin de la sous-chaîne correspondant au groupe group ; group vaut par défaut zéro (pour récupérer les indices de la correspondance complète). Renvoie -1 si group existe mais ne figure pas dans la correspondance. Pour un objet de correspondance m, et un groupe g qui y figure, la sous-chaîne correspondant au groupe g (équivalente à m.group(g)) est :

       

      m.string[m.start(g):m.end(g)]

       

      Notez que m.start(group) sera égal à m.end(group) si group correspond à une chaîne vide. Par exemple, après m = re.search(‘b(c?)’, ‘cba’), m.start(0) vaut 1, m.end(0) vaut 2, m.start(1) et m.end(1) valent tous deux 2, et m.start(2) lève une exception IndexError.

      Un exemple qui supprimera remove_this d’une adresse mail :

       

      >>> email = "tony@tiremove_thisger.net"
      >>> m = re.search("remove_this", email)
      >>> email[:m.start()] + email[m.end():]
      'tony@tiger.net'

       

      match.span([group])

      Pour un objet de correspondance m, renvoie le tuple (m.start(group), m.end(group)). Notez que si group ne figure pas dans la correspondance, (-1, -1) est renvoyé. group vaut par défaut zéro, pour la correspondance entière.

       

      match.pos

      La valeur de pos qui a été passée à la méthode search() ou match() d’un objet expression rationnelle. C’est l’index dans la chaîne à partir duquel le moteur d’expressions rationnelles recherche une correspondance.

       

      match.endpos

      La valeur de endpos qui a été passée à la méthode search() ou match() d’un objet expression rationnelle. C’est l’index dans la chaîne que le moteur d’expressions rationnelles ne dépassera pas.

       

      match.lastindex

      L’index entier du dernier groupe de capture validé, ou None si aucun groupe ne correspondait. Par exemple, les expressions (a)b, ((a)(b)) et ((ab)) auront un lastindex == 1 si appliquées à la chaîne ‘ab’, alors que l’expression (a)(b) aura un lastindex == 2 si appliquée à la même chaîne.

       

      match.lastgroup

      Le nom du dernier groupe capturant validé, ou None si le groupe n’a pas de nom, ou si aucun groupe ne correspondait.

       

      match.re

      L’expression rationnelle dont la méthode match() ou search() a produit cet objet de correspondance.

       

      match.string

      La chaîne passée à match() ou search().

      EXEMPLES

      Rechercher une paire

      Dans cet exemple, nous utiliserons cette fonction de facilité pour afficher les objets de correspondance sous une meilleure forme :

      def displaymatch(match):
          if match is None:
              return None
          return '<Match: %r, groups=%r>' % (match.group(), match.groups())

      Supposez que vous écriviez un jeu de poker où la main d’un joueur est représentée par une chaîne de 5 caractères avec chaque caractère représentant une carte, « a » pour l’as, « k » pour le roi (king), « q » pour la reine (queen), « j » pour le valet (jack), « t » pour 10 (ten), et les caractères de « 2 » à « 9 » représentant les cartes avec ces valeurs.

      Pour vérifier qu’une chaîne donnée est une main valide, on pourrait faire comme suit :

       

      >>> valid = re.compile(r"^[a2-9tjqk]{5}$")
      >>> displaymatch(valid.match("akt5q"))  # Valid.
      "<Match: 'akt5q', groups=()>"
      >>> displaymatch(valid.match("akt5e"))  # Invalid.
      >>> displaymatch(valid.match("akt"))    # Invalid.
      >>> displaymatch(valid.match("727ak"))  # Valid.
      "<Match: '727ak', groups=()>"

      La dernière main, "727ak", contenait une paire, deux cartes de la même valeur. Pour valider cela avec une expression rationnelle, on pourrait utiliser des références arrière comme :

       

      >>> pair = re.compile(r".*(.).*\1")
      >>> displaymatch(pair.match("717ak"))     # Pair of 7s.
      "<Match: '717', groups=('7',)>"
      >>> displaymatch(pair.match("718ak"))     # No pairs.
      >>> displaymatch(pair.match("354aa"))     # Pair of aces.
      "<Match: '354aa', groups=('a',)>"

      Pour trouver de quelle carte est composée la paire, on pourrait utiliser la méthode group() de l’objet de correspondance de la manière suivante :

      >>> pair.match("717ak").group(1)
      '7'
      
      # Error because re.match() returns None, which doesn't have a group() method:
      >>> pair.match("718ak").group(1)
      Traceback (most recent call last):
        File "<pyshell#23>", line 1, in <module>
          re.match(r".*(.).*\1", "718ak").group(1)
      AttributeError: 'NoneType' object has no attribute 'group'
      
      >>> pair.match("354aa").group(1)
      'a'

      S

      Pour extraire le nom de fichier et les nombres depuis une chaîne comme :

      /usr/sbin/sendmail - 0 errors, 4 warnings
      (\S+) - (\d+) errors, (\d+) warnings

      search() vs. match()

      re.match() cherche une correspondance uniquement au début de la chaîne, tandis que re.search() en recherche une n’importe où dans la chaîne :

       

      re.match("c", "abcdef")    # No match
      re.search("c", "abcdef")   # Match
      <_sre.SRE_Match object; span=(2, 3), match='c'>

      Les expressions rationnelles commençant par ‘^’ peuvent être utilisées avec search() pour restreindre la recherche au début de la chaîne :

       

      >>> re.match("c", "abcdef")    # No match
      >>> re.search("^c", "abcdef")  # No match
      >>> re.search("^a", "abcdef")  # Match
      <_sre.SRE_Match object; span=(0, 1), match='a'>

      Notez cependant qu’en mode MULTILINE, match() ne recherche qu’au début de la chaîne, alors que search() avec une expression rationnelle commençant par ‘^’ recherchera au début de chaque ligne.

       

      >>> re.match('X', 'A\nB\nX', re.MULTILINE)  # No match
      >>> re.search('^X', 'A\nB\nX', re.MULTILINE)  # Match
      <_sre.SRE_Match object; span=(4, 5), match='X'>

      Construire un répertoire téléphonique

      split() découpe une chaîne en une liste délimitée par le motif donné. La méthode est inestimable pour convertir des données textuelles vers des structures de données qui peuvent être lues et modifiées par Python comme démontré dans l’exemple suivant qui crée un répertoire téléphonique.

      Premièrement, voici l’entrée. Elle provient normalement d’un fichier, nous utilisons ici une chaîne à guillemets triples :

       

      >>> text = """Ross McFluff: 834.345.1254 155 Elm Street
      ... Ronald Heathmore: 892.345.3428 436 Finley Avenue
      ... Frank Burger: 925.541.7625 662 South Dogwood Way
      ... Heather Albrecht: 548.326.4584 919 Park Place"""

      Les entrées sont séparées par un saut de ligne ou plus. Nous convertissons maintenant la chaîne en une liste où chaque ligne non vide aura sa propre entrée :

      >>> entries = re.split("\n+", text)
      >>> entries
      ['Ross McFluff: 834.345.1254 155 Elm Street',
      'Ronald Heathmore: 892.345.3428 436 Finley Avenue',
      'Frank Burger: 925.541.7625 662 South Dogwood Way',
      'Heather Albrecht: 548.326.4584 919 Park Place']

      Finalement, on sépare chaque entrée en une liste avec prénom, nom, numéro de téléphone et adresse. Nous utilisons le paramètre maxsplit de split() parce que l’adresse contient des espaces, qui sont notre motif de séparation :

      >>> [re.split(":? ", entry, 3) for entry in entries]
      [['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],
      ['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],
      ['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],
      ['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]

      Le motif :? trouve les deux points derrière le nom de famille, pour qu’ils n’apparaissent pas dans la liste résultante. Avec un maxsplit de 4, nous pourrions séparer le numéro du nom de la rue :

      >>> [re.split(":? ", entry, 4) for entry in entries]
      [['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],
      ['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],
      ['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],
      ['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]

      Mélanger les lettres des mots

      sub() remplace toutes les occurrences d’un motif par une chaîne ou le résultat d’une fonction. Cet exemple le montre, en utilisant sub() avec une fonction qui mélange aléatoirement les caractères de chaque mot dans une phrase (à l’exception des premiers et derniers caractères) :

      >>>

      >>> def repl(m):
      ...     inner_word = list(m.group(2))
      ...     random.shuffle(inner_word)
      ...     return m.group(1) + "".join(inner_word) + m.group(3)
      >>> text = "Professor Abdolmalek, please report your absences promptly."
      >>> re.sub(r"(\w)(\w+)(\w)", repl, text)
      'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'
      >>> re.sub(r"(\w)(\w+)(\w)", repl, text)
      'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'

      Trouver tous les adverbes

      findall() matches all occurrences of a pattern, not just the first one as search() does. For example, if a writer wanted to find all of the adverbs in some text, they might use findall() in the following manner:

       

      >>> text = "He was carefully disguised but captured quickly by police."
      >>> re.findall(r"\w+ly", text)
      ['carefully', 'quickly']

      Trouver tous les adverbes et leurs positions

      If one wants more information about all matches of a pattern than the matched text, finditer() is useful as it provides match objects instead of strings. Continuing with the previous example, if a writer wanted to find all of the adverbs and their positions in some text, they would use finditer() in the following manner:

       

      text = "He was carefully disguised but captured quickly by police."
      for m in re.finditer(r"\w+ly", text):
          print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))
      07-16: carefully
      40-47: quickly

      Notation brutes de chaînes

      La notation brute de chaînes (r"text") garde saines les expressions rationnelles. Sans elle, chaque backslash (‘\’) dans une expression rationnelle devrait être préfixé d’un autre backslash pour l’échapper. Par exemple, les deux lignes de code suivantes sont fonctionnellement identiques :

       

      re.match(r"\W(.)\1\W", " ff ")
      <_sre.SRE_Match object; span=(0, 4), match=' ff '>
      re.match("\\W(.)\\1\\W", " ff ")
      <_sre.SRE_Match object; span=(0, 4), match=' ff '>

       

      Pour rechercher un backslash littéral, il faut l’échapper dans l’expression rationnelle. Avec la notation brute, cela signifie r"\\". Sans elle, il faudrait utiliser

      >>> re.match(r"\\", r"\\")
      <_sre.SRE_Match object; span=(0, 1), match='\\'>
      >>> re.match("\\\\", r"\\")
      <_sre.SRE_Match object; span=(0, 1), match='\\'>

       

 

Aucun commentaire

 

Laissez un commentaire