python-docs-fr/howto/regex.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2016, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2016-10-30 10:44+0100\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: ../Doc/howto/regex.rst:5
msgid "Regular Expression HOWTO"
msgstr "Guide des expressions régulières"

#: ../Doc/howto/regex.rst:7
msgid "A.M. Kuchling <amk@amk.ca>"
msgstr "A.M. Kuchling <amk@amk.ca>"

#: ../Doc/howto/regex.rst:0
msgid "Abstract"
msgstr "Résumé"

#: ../Doc/howto/regex.rst:18
msgid ""
"This document is an introductory tutorial to using regular expressions in "
"Python with the :mod:`re` module.  It provides a gentler introduction than "
"the corresponding section in the Library Reference."
msgstr ""
"Ce document constitue un guide d'introduction à l'utilisation des "
"expressions régulières en Python avec le module :mod:`re`. Il fournit une "
"introduction plus abordable que la section correspondante dans le guide de "
"référence de la bibliothèque."

#: ../Doc/howto/regex.rst:24
msgid "Introduction"
msgstr "Introduction"

#: ../Doc/howto/regex.rst:26
msgid ""
"The :mod:`re` module was added in Python 1.5, and provides Perl-style "
"regular expression patterns.  Earlier versions of Python came with the :mod:"
"`regex` module, which provided Emacs-style patterns.  The :mod:`regex` "
"module was removed completely in Python 2.5."
msgstr ""

#: ../Doc/howto/regex.rst:31
msgid ""
"Regular expressions (called REs, or regexes, or regex patterns) are "
"essentially a tiny, highly specialized programming language embedded inside "
"Python and made available through the :mod:`re` module. Using this little "
"language, you specify the rules for the set of possible strings that you "
"want to match; this set might contain English sentences, or e-mail "
"addresses, or TeX commands, or anything you like.  You can then ask "
"questions such as \"Does this string match the pattern?\", or \"Is there a "
"match for the pattern anywhere in this string?\".  You can also use REs to "
"modify a string or to split it apart in various ways."
msgstr ""
"Les expressions régulières (notées RE ou motifs *regex* dans ce document) "
"sont essentiellement un petit langage de programmation hautement spécialisé "
"embarqué dans Python et dont la manipulation est rendue possible par "
"l'utilisation du module :mod:`re`. En utilisant ce petit langage, vous "
"définissez des règles pour spécifier une correspondance avec un ensemble "
"souhaité de chaînes de caractères ; ces chaînes peuvent être des phrases, "
"des adresses de courriel, des commandes TeX ou tout ce que vous voulez. Vous "
"pouvez ensuite poser des questions telles que \"Est-ce que cette chaîne de "
"caractères correspond au motif ?\" ou \"Y a-t-il une correspondance pour ce "
"motif à l'intérieur de la chaîne de caractères ?\". Vous pouvez aussi "
"utiliser les RE pour modifier une chaîne de caractères ou la découper de "
"différentes façons."

#: ../Doc/howto/regex.rst:40
msgid ""
"Regular expression patterns are compiled into a series of bytecodes which "
"are then executed by a matching engine written in C.  For advanced use, it "
"may be necessary to pay careful attention to how the engine will execute a "
"given RE, and write the RE in a certain way in order to produce bytecode "
"that runs faster. Optimization isn't covered in this document, because it "
"requires that you have a good understanding of the matching engine's "
"internals."
msgstr ""
"Un motif d'expression régulière est compilé en code intermédiaire "
"(*bytecode* en anglais) qui est ensuite exécuté par un moteur de "
"correspondance écrit en C. Pour une utilisation plus poussée, il peut "
"s'avérer nécessaire de s'intéresser à la manière dont le moteur exécute la "
"RE afin d'écrire une expression dont le code intermédiaire est plus rapide. "
"L'optimisation n'est pas traitée dans ce document, parce qu'elle nécessite "
"d'avoir une bonne compréhension des mécanismes internes du moteur de "
"correspondance."

#: ../Doc/howto/regex.rst:47
msgid ""
"The regular expression language is relatively small and restricted, so not "
"all possible string processing tasks can be done using regular expressions.  "
"There are also tasks that *can* be done with regular expressions, but the "
"expressions turn out to be very complicated.  In these cases, you may be "
"better off writing Python code to do the processing; while Python code will "
"be slower than an elaborate regular expression, it will also probably be "
"more understandable."
msgstr ""
"Le langage des expressions régulières est relativement petit et restreint, "
"donc toutes les tâches de manipulation de chaînes de caractères ne peuvent "
"pas être réalisées à l'aide d'expressions régulières. Il existe aussi des "
"tâches qui *peuvent* être réalisées à l'aide d'expressions régulières mais "
"qui ont tendance à produire des expressions régulières très compliquées. "
"Dans ces cas, il est plus utile d'écrire du code Python pour réaliser le "
"traitement ; même si le code Python est plus lent qu'une expression "
"régulière élaborée, il sera probablement plus compréhensible."

#: ../Doc/howto/regex.rst:56
msgid "Simple Patterns"
msgstr "Motifs simples"

#: ../Doc/howto/regex.rst:58
msgid ""
"We'll start by learning about the simplest possible regular expressions.  "
"Since regular expressions are used to operate on strings, we'll begin with "
"the most common task: matching characters."
msgstr ""
"Nous commençons par étudier les expressions régulières les plus simples. "
"Dans la mesure où les expressions régulières sont utilisées pour manipuler "
"des chaînes de caractères, nous commençons par l'action la plus courante : "
"la correspondance de caractères."

#: ../Doc/howto/regex.rst:62
msgid ""
"For a detailed explanation of the computer science underlying regular "
"expressions (deterministic and non-deterministic finite automata), you can "
"refer to almost any textbook on writing compilers."
msgstr ""
"Pour une explication détaillée sur le concept informatique sous-jacent aux "
"expressions régulières (automate à états déterministe ou non-déterministe), "
"vous pouvez vous référer à n'importe quel manuel sur l'écriture de "
"compilateurs."

#: ../Doc/howto/regex.rst:68
msgid "Matching Characters"
msgstr "Correspondance de caractères"

#: ../Doc/howto/regex.rst:70
msgid ""
"Most letters and characters will simply match themselves.  For example, the "
"regular expression ``test`` will match the string ``test`` exactly.  (You "
"can enable a case-insensitive mode that would let this RE match ``Test`` or "
"``TEST`` as well; more about this later.)"
msgstr ""
"La plupart des lettres ou caractères correspondent simplement à eux-mêmes. "
"Par exemple, l'expression régulière ``test`` correspond à la chaîne de "
"caractères ``test``, précisément. Vous pouvez activer le mode non-sensible à "
"la casse qui permet à cette RE de correspondre également à ``Test`` ou "
"``TEST`` (ce sujet est traité par la suite)."

#: ../Doc/howto/regex.rst:75
msgid ""
"There are exceptions to this rule; some characters are special :dfn:"
"`metacharacters`, and don't match themselves.  Instead, they signal that "
"some out-of-the-ordinary thing should be matched, or they affect other "
"portions of the RE by repeating them or changing their meaning.  Much of "
"this document is devoted to discussing various metacharacters and what they "
"do."
msgstr ""
"Il existe des exceptions à cette règle ; certains caractères sont des :dfn:"
"`métacaractères` spéciaux et ne correspondent pas à eux-mêmes. Au lieu de "
"cela, ils signalent que certaines choses non ordinaires doivent "
"correspondre, ou ils affectent d'autre portions de la RE en les répétant ou "
"en changeant leur sens. Une grande partie de ce document est consacrée au "
"fonctionnement de ces métacaractères."

#: ../Doc/howto/regex.rst:81
msgid ""
"Here's a complete list of the metacharacters; their meanings will be "
"discussed in the rest of this HOWTO."
msgstr ""
"Voici une liste complète des métacaractères ; leur sens est décrit dans la "
"suite de ce guide."

#: ../Doc/howto/regex.rst:88
msgid ""
"The first metacharacters we'll look at are ``[`` and ``]``. They're used for "
"specifying a character class, which is a set of characters that you wish to "
"match.  Characters can be listed individually, or a range of characters can "
"be indicated by giving two characters and separating them by a ``'-'``.  For "
"example, ``[abc]`` will match any of the characters ``a``, ``b``, or ``c``; "
"this is the same as ``[a-c]``, which uses a range to express the same set of "
"characters.  If you wanted to match only lowercase letters, your RE would be "
"``[a-z]``."
msgstr ""
"Les premiers métacaractères que nous étudions sont ``[`` et ``]``. Ils sont "
"utilisés pour spécifier une classe de caractères, qui forme un ensemble de "
"caractères dont vous souhaitez trouver la correspondance. Les caractères "
"peuvent être listés individuellement, ou une plage de caractères peut être "
"indiquée en fournissant deux caractères séparés par un `'-'``. Par exemple, "
"``[abc]`` correspond à n'importe quel caractère parmi ``a``, ``b``, ou "
"``c`` ; c'est équivalent à ``[a-c]``, qui utilise une plage pour exprimer le "
"même ensemble de caractères. Si vous voulez trouver une chaîne qui ne "
"contient que des lettres en minuscules, la RE est ``[a-z]``."

#: ../Doc/howto/regex.rst:97
msgid ""
"Metacharacters are not active inside classes.  For example, ``[akm$]`` will "
"match any of the characters ``'a'``, ``'k'``, ``'m'``, or ``'$'``; ``'$'`` "
"is usually a metacharacter, but inside a character class it's stripped of "
"its special nature."
msgstr ""
"Les métacaractères ne sont pas actifs dans les classes. Par exemple, ``[akm"
"$]`` correspond à n'importe quel caractère parmi ``'a'``, ``'k'``, ``'m'`` "
"ou ``'$'`` ; ``'$'`` est habituellement un métacaractère mais dans une "
"classe de caractères, il est dépourvu de sa signification spéciale."

#: ../Doc/howto/regex.rst:102
msgid ""
"You can match the characters not listed within the class by :dfn:"
"`complementing` the set.  This is indicated by including a ``'^'`` as the "
"first character of the class; ``'^'`` outside a character class will simply "
"match the ``'^'`` character.  For example, ``[^5]`` will match any character "
"except ``'5'``."
msgstr ""
"Vous pouvez trouver une correspondance avec les caractères non listés dans "
"une classe en spécifiant le :dfn:`complément` de l'ensemble. Ceci est "
"indiqué en plaçant un ``'^'`` en tant que premier caractère de la classe ; "
"``'^'`` en dehors d'une classe de caractères correspond au caractère "
"``'^'``. Par exemple, ``[^5]`` correspond à tous les caractères, sauf "
"``'5'``."

#: ../Doc/howto/regex.rst:107
msgid ""
"Perhaps the most important metacharacter is the backslash, ``\\``.   As in "
"Python string literals, the backslash can be followed by various characters "
"to signal various special sequences.  It's also used to escape all the "
"metacharacters so you can still match them in patterns; for example, if you "
"need to match a ``[`` or  ``\\``, you can precede them with a backslash to "
"remove their special meaning: ``\\[`` or ``\\\\``."
msgstr ""
"Le métacaractère le plus important est probablement la barre oblique inverse "
"( *backslash* en anglais), ``\\``. Comme dans les chaînes de caractères en "
"Python, la barre oblique inverse peut être suivie par différents caractères "
"pour signaler différentes séquences spéciales. Elle est aussi utilisée pour "
"échapper tous les métacaractères afin d'en trouver les correspondances dans "
"les motifs ; par exemple, si vous devez trouver une correspondance pour "
"``[`` ou ``\\``, vous pouvez les précéder avec une barre oblique inverse "
"pour annuler leur signification spéciale : ``\\[`` ou ``\\\\``."

#: ../Doc/howto/regex.rst:114
msgid ""
"Some of the special sequences beginning with ``'\\'`` represent predefined "
"sets of characters that are often useful, such as the set of digits, the set "
"of letters, or the set of anything that isn't whitespace.  The following "
"predefined special sequences are a subset of those available. The equivalent "
"classes are for byte string patterns. For a complete list of sequences and "
"expanded class definitions for Unicode string patterns, see the last part "
"of :ref:`Regular Expression Syntax <re-syntax>`."
msgstr ""

#: ../Doc/howto/regex.rst:123
msgid "``\\d``"
msgstr "``\\d``"

#: ../Doc/howto/regex.rst:123
msgid "Matches any decimal digit; this is equivalent to the class ``[0-9]``."
msgstr ""
"Correspond à n'importe quel caractère numérique ; équivalent à la classe "
"``[0-9]``."

#: ../Doc/howto/regex.rst:126
msgid "``\\D``"
msgstr "``\\D``"

#: ../Doc/howto/regex.rst:126
msgid ""
"Matches any non-digit character; this is equivalent to the class ``[^0-9]``."
msgstr ""
"Correspond à n'importe caractère non numérique ; équivalent à la classe "
"``[^0-9]``."

#: ../Doc/howto/regex.rst:130
msgid "``\\s``"
msgstr "``\\s``"

#: ../Doc/howto/regex.rst:129
msgid ""
"Matches any whitespace character; this is equivalent to the class ``[ \\t\\n"
"\\r\\f\\v]``."
msgstr ""
"Correspond à n'importe quel caractère \"blanc\" ; équivalent à la classe "
"``[ \\t\\n\\r\\f\\v]``."

#: ../Doc/howto/regex.rst:134
msgid "``\\S``"
msgstr "``\\S``"

#: ../Doc/howto/regex.rst:133
msgid ""
"Matches any non-whitespace character; this is equivalent to the class ``[^ "
"\\t\\n\\r\\f\\v]``."
msgstr ""
"Correspond à n'importe caractère autre que \"blanc\" ; équivalent à la "
"classe ``[^ \\t\\n\\r\\f\\v]``."

#: ../Doc/howto/regex.rst:138
msgid "``\\w``"
msgstr "``\\w``"

#: ../Doc/howto/regex.rst:137
msgid ""
"Matches any alphanumeric character; this is equivalent to the class ``[a-zA-"
"Z0-9_]``."
msgstr ""
"Correspond à n'importe caractère alphanumérique ; équivalent à la classe "
"``[a-zA-Z0-9_]``."

#: ../Doc/howto/regex.rst:142
msgid "``\\W``"
msgstr "``\\W``"

#: ../Doc/howto/regex.rst:141
msgid ""
"Matches any non-alphanumeric character; this is equivalent to the class "
"``[^a-zA-Z0-9_]``."
msgstr ""
"Correspond à n'importe caractère non-alphanumérique ; équivalent à la classe "
"``[^a-zA-Z0-9_]``."

#: ../Doc/howto/regex.rst:144
msgid ""
"These sequences can be included inside a character class.  For example, "
"``[\\s,.]`` is a character class that will match any whitespace character, "
"or ``','`` or ``'.'``."
msgstr ""
"Ces séquences peuvent être incluses dans une classe de caractères. Par "
"exemple, ``[\\s,.]`` est une classe de caractères qui correspond à tous les "
"caractères \"blancs\" ou ``','`` ou ``'.'``."

#: ../Doc/howto/regex.rst:148
msgid ""
"The final metacharacter in this section is ``.``.  It matches anything "
"except a newline character, and there's an alternate mode (``re.DOTALL``) "
"where it will match even a newline.  ``'.'`` is often used where you want to "
"match \"any character\"."
msgstr ""

#: ../Doc/howto/regex.rst:155
msgid "Repeating Things"
msgstr "Répétitions"

#: ../Doc/howto/regex.rst:157
msgid ""
"Being able to match varying sets of characters is the first thing regular "
"expressions can do that isn't already possible with the methods available on "
"strings.  However, if that was the only additional capability of regexes, "
"they wouldn't be much of an advance. Another capability is that you can "
"specify that portions of the RE must be repeated a certain number of times."
msgstr ""
"Trouver des correspondances de divers ensembles de caractères est la "
"première utilisation des expressions régulières, ce que l'on ne peut pas "
"faire avec les méthodes des chaînes. Cependant, si c'était la seule "
"possibilité des expressions régulières, le gain ne serait pas significatif. "
"Une autre utilisation consiste à spécifier des portions d'une RE qui peuvent "
"être répétées un certain nombre de fois."

#: ../Doc/howto/regex.rst:163
msgid ""
"The first metacharacter for repeating things that we'll look at is ``*``.  "
"``*`` doesn't match the literal character ``*``; instead, it specifies that "
"the previous character can be matched zero or more times, instead of exactly "
"once."
msgstr ""

#: ../Doc/howto/regex.rst:167
msgid ""
"For example, ``ca*t`` will match ``ct`` (0 ``a`` characters), ``cat`` (1 "
"``a``), ``caaat`` (3 ``a`` characters), and so forth.  The RE engine has "
"various internal limitations stemming from the size of C's ``int`` type that "
"will prevent it from matching over 2 billion ``a`` characters; you probably "
"don't have enough memory to construct a string that large, so you shouldn't "
"run into that limit."
msgstr ""

#: ../Doc/howto/regex.rst:174
msgid ""
"Repetitions such as ``*`` are :dfn:`greedy`; when repeating a RE, the "
"matching engine will try to repeat it as many times as possible. If later "
"portions of the pattern don't match, the matching engine will then back up "
"and try again with fewer repetitions."
msgstr ""
"Les répétitions telles que ``*`` sont :dfn:`gloutonnes` ; quand vous répétez "
"une RE, le moteur de correspondance essaie de trouver la correspondance la "
"plus longue en répétant le motif tant qu'il le peut. Si la suite du motif ne "
"correspond pas, le moteur de correspondance revient en arrière et essaie "
"avec moins de répétitions."

#: ../Doc/howto/regex.rst:179
msgid ""
"A step-by-step example will make this more obvious.  Let's consider the "
"expression ``a[bcd]*b``.  This matches the letter ``'a'``, zero or more "
"letters from the class ``[bcd]``, and finally ends with a ``'b'``.  Now "
"imagine matching this RE against the string ``abcbd``."
msgstr ""

#: ../Doc/howto/regex.rst:185
msgid "Step"
msgstr "Étape"

#: ../Doc/howto/regex.rst:185
msgid "Matched"
msgstr "Correspond"

#: ../Doc/howto/regex.rst:185
msgid "Explanation"
msgstr "Explication"

#: ../Doc/howto/regex.rst:187
msgid "1"
msgstr "1"

#: ../Doc/howto/regex.rst:187
msgid "``a``"
msgstr "``a``"

#: ../Doc/howto/regex.rst:187
msgid "The ``a`` in the RE matches."
msgstr "Le ``a`` correspond dans la RE."

#: ../Doc/howto/regex.rst:189
msgid "2"
msgstr "2"

#: ../Doc/howto/regex.rst:189
msgid "``abcbd``"
msgstr "``abcbd``"

#: ../Doc/howto/regex.rst:189
msgid ""
"The engine matches ``[bcd]*``, going as far as it can, which is to the end "
"of the string."
msgstr ""
"Le moteur de correspondance trouve ``[bcd]*``, va aussi loin qu'il le peut, "
"ce qui n'est pas la fin de la chaîne."

#: ../Doc/howto/regex.rst:193
msgid "3"
msgstr "3"

#: ../Doc/howto/regex.rst:193 ../Doc/howto/regex.rst:201
msgid "*Failure*"
msgstr "*échec*"

#: ../Doc/howto/regex.rst:193
msgid ""
"The engine tries to match ``b``, but the current position is at the end of "
"the string, so it fails."
msgstr ""
"Le moteur essaie de trouver une correspondance avec ``b`` mais la position "
"courante est à la fin de la chaîne de caractères, donc il échoue."

#: ../Doc/howto/regex.rst:198
msgid "4"
msgstr "4"

#: ../Doc/howto/regex.rst:198 ../Doc/howto/regex.rst:209
msgid "``abcb``"
msgstr "``abcb``"

#: ../Doc/howto/regex.rst:198
msgid "Back up, so that  ``[bcd]*`` matches one less character."
msgstr ""
"Retour en arrière, de manière à ce que ``[bcd]*`` corresponde avec un "
"caractère de moins."

#: ../Doc/howto/regex.rst:201
msgid "5"
msgstr "5"

#: ../Doc/howto/regex.rst:201
msgid ""
"Try ``b`` again, but the current position is at the last character, which is "
"a ``'d'``."
msgstr ""
"Essaie encore ``b``, mais la position courante est le dernier caractère, qui "
"est ``'d'``."

#: ../Doc/howto/regex.rst:205 ../Doc/howto/regex.rst:209
msgid "6"
msgstr "6"

#: ../Doc/howto/regex.rst:205
msgid "``abc``"
msgstr "``abc``"

#: ../Doc/howto/regex.rst:205
msgid "Back up again, so that ``[bcd]*`` is only matching ``bc``."
msgstr ""
"Encore un retour en arrière, de manière à ce que ``[bcd]*`` ne corresponde "
"qu'à ``bc``."

#: ../Doc/howto/regex.rst:209
msgid ""
"Try ``b`` again.  This time the character at the current position is "
"``'b'``, so it succeeds."
msgstr ""
"Essaie ``b`` encore une fois. Cette fois, le caractère à la position "
"courante est ``'b'``, donc cela fonctionne."

#: ../Doc/howto/regex.rst:215
msgid ""
"The end of the RE has now been reached, and it has matched ``abcb``.  This "
"demonstrates how the matching engine goes as far as it can at first, and if "
"no match is found it will then progressively back up and retry the rest of "
"the RE again and again.  It will back up until it has tried zero matches for "
"``[bcd]*``, and if that subsequently fails, the engine will conclude that "
"the string doesn't match the RE at all."
msgstr ""

#: ../Doc/howto/regex.rst:222
msgid ""
"Another repeating metacharacter is ``+``, which matches one or more times.  "
"Pay careful attention to the difference between ``*`` and ``+``; ``*`` "
"matches *zero* or more times, so whatever's being repeated may not be "
"present at all, while ``+`` requires at least *one* occurrence.  To use a "
"similar example, ``ca+t`` will match ``cat`` (1 ``a``), ``caaat`` (3 "
"``a``'s), but won't match ``ct``."
msgstr ""

#: ../Doc/howto/regex.rst:229
msgid ""
"There are two more repeating qualifiers.  The question mark character, ``?"
"``, matches either once or zero times; you can think of it as marking "
"something as being optional.  For example, ``home-?brew`` matches either "
"``homebrew`` or ``home-brew``."
msgstr ""

#: ../Doc/howto/regex.rst:234
msgid ""
"The most complicated repeated qualifier is ``{m,n}``, where *m* and *n* are "
"decimal integers.  This qualifier means there must be at least *m* "
"repetitions, and at most *n*.  For example, ``a/{1,3}b`` will match ``a/b``, "
"``a//b``, and ``a///b``.  It won't match ``ab``, which has no slashes, or "
"``a////b``, which has four."
msgstr ""

#: ../Doc/howto/regex.rst:240
msgid ""
"You can omit either *m* or *n*; in that case, a reasonable value is assumed "
"for the missing value.  Omitting *m* is interpreted as a lower limit of 0, "
"while omitting *n* results in an upper bound of infinity --- actually, the "
"upper bound is the 2-billion limit mentioned earlier, but that might as well "
"be infinity."
msgstr ""

#: ../Doc/howto/regex.rst:245
msgid ""
"Readers of a reductionist bent may notice that the three other qualifiers "
"can all be expressed using this notation.  ``{0,}`` is the same as ``*``, "
"``{1,}`` is equivalent to ``+``, and ``{0,1}`` is the same as ``?``.  It's "
"better to use ``*``, ``+``, or ``?`` when you can, simply because they're "
"shorter and easier to read."
msgstr ""
"Le lecteur attentif aura noté que les trois premiers quantificateurs peuvent "
"être exprimés en utilisant cette notation. ``{0,}`` est la même chose que "
"``*``, ``{1,}`` est équivalent à ``+`` et ``{0,1}`` se comporte comme ``?``. "
"Il est préférable d'utiliser ``*``, ``+`` ou ``?`` quand vous le pouvez, "
"simplement parce qu'ils sont plus courts et plus faciles à lire."

#: ../Doc/howto/regex.rst:253
msgid "Using Regular Expressions"
msgstr "Utilisation des expressions régulières"

#: ../Doc/howto/regex.rst:255
msgid ""
"Now that we've looked at some simple regular expressions, how do we actually "
"use them in Python?  The :mod:`re` module provides an interface to the "
"regular expression engine, allowing you to compile REs into objects and then "
"perform matches with them."
msgstr ""
"Maintenant que nous avons vu quelques expressions régulières simples, "
"utilisons-les concrètement. Le module :mod:`re` fournit une interface pour "
"le moteur de correspondance, ce qui permet de compiler les RE en objets et "
"d'effectuer des correspondances avec."

#: ../Doc/howto/regex.rst:262
msgid "Compiling Regular Expressions"
msgstr "Compilation des expressions régulières"

#: ../Doc/howto/regex.rst:264
msgid ""
"Regular expressions are compiled into pattern objects, which have methods "
"for various operations such as searching for pattern matches or performing "
"string substitutions. ::"
msgstr ""
"Les expressions régulières sont compilées en objets motifs, qui possèdent "
"des méthodes pour diverses opérations telles que la recherche de "
"correspondances ou les substitutions dans les chaînes. ::"

#: ../Doc/howto/regex.rst:273
msgid ""
":func:`re.compile` also accepts an optional *flags* argument, used to enable "
"various special features and syntax variations.  We'll go over the available "
"settings later, but for now a single example will do::"
msgstr ""
":func:`re.compile` accepte aussi une option *flags*, utilisée pour activer "
"des fonctionnalités particulières et des variations de syntaxe. Nous "
"étudierons la définition des variables plus tard et, pour l'instant, un seul "
"exemple suffit ::"

#: ../Doc/howto/regex.rst:279
msgid ""
"The RE is passed to :func:`re.compile` as a string.  REs are handled as "
"strings because regular expressions aren't part of the core Python language, "
"and no special syntax was created for expressing them.  (There are "
"applications that don't need REs at all, so there's no need to bloat the "
"language specification by including them.) Instead, the :mod:`re` module is "
"simply a C extension module included with Python, just like the :mod:"
"`socket` or :mod:`zlib` modules."
msgstr ""
"La RE passée à :func:`re.compile` est une chaîne. Les RE sont des chaînes "
"car les expressions régulières ne font pas partie intrinsèque du langage "
"Python et aucune syntaxe particulière n'a été créée pour les exprimer (il "
"existe des applications qui ne nécessitent aucune RE et il n'a donc aucune "
"raison de grossir les spécifications du langage en incluant les RE). Ainsi, "
"le module :mod:`re` est simplement un module d'extension en C inclus dans "
"Python, tout comme les modules :mod:`socket` ou :mod:`zlib`."

#: ../Doc/howto/regex.rst:286
msgid ""
"Putting REs in strings keeps the Python language simpler, but has one "
"disadvantage which is the topic of the next section."
msgstr ""
"Exprimer les RE comme des chaînes de caractères garde le langage Python plus "
"simple mais introduit un inconvénient qui fait l'objet de la section "
"suivante."

#: ../Doc/howto/regex.rst:291
msgid "The Backslash Plague"
msgstr "La maudite barre oblique inverse"

#: ../Doc/howto/regex.rst:293
msgid ""
"As stated earlier, regular expressions use the backslash character "
"(``'\\'``) to indicate special forms or to allow special characters to be "
"used without invoking their special meaning. This conflicts with Python's "
"usage of the same character for the same purpose in string literals."
msgstr ""
"Comme indiqué précédemment, les expressions régulières utilisent la barre "
"oblique inverse (*backslash* en anglais) pour indiquer des constructions "
"particulières ou pour autoriser des caractères spéciaux sans que leur "
"signification spéciale ne soit invoquée. C'est en contradiction avec l'usage "
"de Python qui est qu'un caractère doit avoir la même signification dans les "
"littéraux de chaînes de caractères."

#: ../Doc/howto/regex.rst:298
msgid ""
"Let's say you want to write a RE that matches the string ``\\section``, "
"which might be found in a LaTeX file.  To figure out what to write in the "
"program code, start with the desired string to be matched.  Next, you must "
"escape any backslashes and other metacharacters by preceding them with a "
"backslash, resulting in the string ``\\\\section``.  The resulting string "
"that must be passed to :func:`re.compile` must be ``\\\\section``.  However, "
"to express this as a Python string literal, both backslashes must be escaped "
"*again*."
msgstr ""
"Considérons que vous voulez écrire une RE qui fait correspondre la chaîne de "
"caractères ``\\section`` (on en trouve dans un fichier LaTeX). Pour savoir "
"ce qu'il faut coder dans votre programme, commençons par la chaîne de "
"caractères cherchée. Ensuite, nous devons échapper chaque barre oblique "
"inverse et tout autre métacaractère en les précédant d'une barre oblique "
"inverse, ce qui donne la chaîne de caractères ``\\\\section``. La chaîne "
"résultante qui doit être passée à :func:`re.compile` est donc ``\\"
"\\section``. Comme nous devons l'exprimer sous la forme d'une chaîne "
"littérale Python, nous devons échapper les deux barres obliques inverses "
"*encore une fois*."

#: ../Doc/howto/regex.rst:307
msgid "Characters"
msgstr "Caractères"

#: ../Doc/howto/regex.rst:307
msgid "Stage"
msgstr "Niveau"

#: ../Doc/howto/regex.rst:309
msgid "``\\section``"
msgstr "``\\section``"

#: ../Doc/howto/regex.rst:309
msgid "Text string to be matched"
msgstr "Chaîne de caractère à chercher"

#: ../Doc/howto/regex.rst:311
msgid "``\\\\section``"
msgstr "``\\\\section``"

#: ../Doc/howto/regex.rst:311
msgid "Escaped backslash for :func:`re.compile`"
msgstr "Barre oblique inverse échappée pour :func:`re.compile`"

#: ../Doc/howto/regex.rst:313 ../Doc/howto/regex.rst:333
msgid "``\"\\\\\\\\section\"``"
msgstr "``\"\\\\\\\\section\"``"

#: ../Doc/howto/regex.rst:313
msgid "Escaped backslashes for a string literal"
msgstr ""
"Barres obliques inverses échappées pour un littéral de chaîne de caractères"

#: ../Doc/howto/regex.rst:316
msgid ""
"In short, to match a literal backslash, one has to write ``'\\\\\\\\'`` as "
"the RE string, because the regular expression must be ``\\\\``, and each "
"backslash must be expressed as ``\\\\`` inside a regular Python string "
"literal.  In REs that feature backslashes repeatedly, this leads to lots of "
"repeated backslashes and makes the resulting strings difficult to understand."
msgstr ""
"Pour faire court, si vous cherchez une correspondance pour une barre oblique "
"inverse littérale, écrivez ``'\\\\\\\\'`` dans votre chaîne RE, car "
"l'expression régulière doit être ``\\\\`` et que chaque barre oblique "
"inverse doit être exprimée comme ``\\\\`` dans un littéral chaîne de "
"caractères Python. Dans les RE qui comportent plusieurs barres obliques "
"inverses, cela conduit à beaucoup de barres obliques inverses et rend la "
"chaîne résultante difficile à comprendre."

#: ../Doc/howto/regex.rst:322
msgid ""
"The solution is to use Python's raw string notation for regular expressions; "
"backslashes are not handled in any special way in a string literal prefixed "
"with ``'r'``, so ``r\"\\n\"`` is a two-character string containing ``'\\'`` "
"and ``'n'``, while ``\"\\n\"`` is a one-character string containing a "
"newline. Regular expressions will often be written in Python code using this "
"raw string notation."
msgstr ""
"La solution consiste à utiliser les chaînes brutes Python pour les "
"expressions régulières ; les barres obliques inverses ne sont pas gérées "
"d'une manière particulière dans les chaînes littérales préfixées avec "
"``'r'``. Ainsi, ``r\"\\n\"`` est la chaîne de deux caractères contenant "
"``'\\'`` et ``'n'`` alors que ``\"\\n\"`` est la chaîne contenant uniquement "
"le caractère retour à la ligne. Les expressions régulières sont souvent "
"écrites dans le code Python en utilisant la notation \"chaînes brutes\"."

#: ../Doc/howto/regex.rst:329
msgid "Regular String"
msgstr "Chaîne normale"

#: ../Doc/howto/regex.rst:329
msgid "Raw string"
msgstr "Chaîne de caractères brute"

#: ../Doc/howto/regex.rst:331
msgid "``\"ab*\"``"
msgstr "``\"ab*\"``"

#: ../Doc/howto/regex.rst:331
msgid "``r\"ab*\"``"
msgstr "``r\"ab*\"``"

#: ../Doc/howto/regex.rst:333
msgid "``r\"\\\\section\"``"
msgstr "``r\"\\\\section\"``"

#: ../Doc/howto/regex.rst:335
msgid "``\"\\\\w+\\\\s+\\\\1\"``"
msgstr "``\"\\\\w+\\\\s+\\\\1\"``"

#: ../Doc/howto/regex.rst:335
msgid "``r\"\\w+\\s+\\1\"``"
msgstr "``r\"\\w+\\s+\\1\"``"

#: ../Doc/howto/regex.rst:340
msgid "Performing Matches"
msgstr "Recherche de correspondances"

#: ../Doc/howto/regex.rst:342
msgid ""
"Once you have an object representing a compiled regular expression, what do "
"you do with it?  Pattern objects have several methods and attributes. Only "
"the most significant ones will be covered here; consult the :mod:`re` docs "
"for a complete listing."
msgstr ""
"Une fois que nous avons un objet représentant une expression régulière "
"compilée, qu'en faisons-nous ? Les objets motifs ont plusieurs méthodes et "
"attributs. Seuls les plus significatifs seront couverts ici ; consultez la "
"documentation :mod:`re` pour la liste complète."

#: ../Doc/howto/regex.rst:348 ../Doc/howto/regex.rst:409
#: ../Doc/howto/regex.rst:1042
msgid "Method/Attribute"
msgstr "Méthode/Attribut"

#: ../Doc/howto/regex.rst:348 ../Doc/howto/regex.rst:409
#: ../Doc/howto/regex.rst:1042
msgid "Purpose"
msgstr "Objectif"

#: ../Doc/howto/regex.rst:350
msgid "``match()``"
msgstr "``match()``"

#: ../Doc/howto/regex.rst:350
msgid "Determine if the RE matches at the beginning of the string."
msgstr "Détermine si la RE fait correspond dès le début de la chaîne."

#: ../Doc/howto/regex.rst:353
msgid "``search()``"
msgstr "``search()``"

#: ../Doc/howto/regex.rst:353
msgid "Scan through a string, looking for any location where this RE matches."
msgstr "Analyse la chaîne à la recherche d'une position où la RE correspond."

#: ../Doc/howto/regex.rst:356
msgid "``findall()``"
msgstr "``findall()``"

#: ../Doc/howto/regex.rst:356
msgid "Find all substrings where the RE matches, and returns them as a list."
msgstr ""
"Trouve toutes les sous-chaînes qui correspondent à la RE et les renvoie sous "
"la forme d'une liste."

#: ../Doc/howto/regex.rst:359
msgid "``finditer()``"
msgstr "``finditer()``"

#: ../Doc/howto/regex.rst:359
msgid ""
"Find all substrings where the RE matches, and returns them as an :term:"
"`iterator`."
msgstr ""
"Trouve toutes les sous-chaînes qui correspondent à la RE et les renvoie sous "
"la forme d'un :term:`itérateur <iterator>`."

#: ../Doc/howto/regex.rst:363
msgid ""
":meth:`match` and :meth:`search` return ``None`` if no match can be found.  "
"If they're successful, a :ref:`match object <match-objects>` instance is "
"returned, containing information about the match: where it starts and ends, "
"the substring it matched, and more."
msgstr ""

#: ../Doc/howto/regex.rst:368
msgid ""
"You can learn about this by interactively experimenting with the :mod:`re` "
"module.  If you have Tkinter available, you may also want to look at :source:"
"`Tools/scripts/redemo.py`, a demonstration program included with the Python "
"distribution.  It allows you to enter REs and strings, and displays whether "
"the RE matches or fails. :file:`redemo.py` can be quite useful when trying "
"to debug a complicated RE.  Phil Schwartz's `Kodos <http://kodos.sourceforge."
"net/>`_ is also an interactive tool for developing and testing RE patterns."
msgstr ""

#: ../Doc/howto/regex.rst:377
msgid ""
"This HOWTO uses the standard Python interpreter for its examples. First, run "
"the Python interpreter, import the :mod:`re` module, and compile a RE::"
msgstr ""
"Ce guide utilise l'interpréteur standard de Python pour ses exemples. "
"Commencez par lancer l'interpréteur Python, importez le module :mod:`re` et "
"compilez une RE ::"

#: ../Doc/howto/regex.rst:386
msgid ""
"Now, you can try matching various strings against the RE ``[a-z]+``.  An "
"empty string shouldn't match at all, since ``+`` means 'one or more "
"repetitions'. :meth:`match` should return ``None`` in this case, which will "
"cause the interpreter to print no output.  You can explicitly print the "
"result of :meth:`match` to make this clear. ::"
msgstr ""

#: ../Doc/howto/regex.rst:396
msgid ""
"Now, let's try it on a string that it should match, such as ``tempo``.  In "
"this case, :meth:`match` will return a :ref:`match object <match-objects>`, "
"so you should store the result in a variable for later use. ::"
msgstr ""

#: ../Doc/howto/regex.rst:404
msgid ""
"Now you can query the :ref:`match object <match-objects>` for information "
"about the matching string.  :ref:`match object <match-objects>` instances "
"also have several methods and attributes; the most important ones are:"
msgstr ""

#: ../Doc/howto/regex.rst:411
msgid "``group()``"
msgstr "``group()``"

#: ../Doc/howto/regex.rst:411
msgid "Return the string matched by the RE"
msgstr "Renvoie la chaîne de caractères correspondant à la RE"

#: ../Doc/howto/regex.rst:413
msgid "``start()``"
msgstr "``start()``"

#: ../Doc/howto/regex.rst:413
msgid "Return the starting position of the match"
msgstr "Renvoie la position de début de la correspondance"

#: ../Doc/howto/regex.rst:415
msgid "``end()``"
msgstr "``end()``"

#: ../Doc/howto/regex.rst:415
msgid "Return the ending position of the match"
msgstr "Renvoie la position de fin de la correspondance"

#: ../Doc/howto/regex.rst:417
msgid "``span()``"
msgstr "``span()``"

#: ../Doc/howto/regex.rst:417
msgid "Return a tuple containing the (start, end) positions  of the match"
msgstr ""
"Renvoie un *tuple* contenant les positions (début, fin) de la correspondance"

#: ../Doc/howto/regex.rst:421
msgid "Trying these methods will soon clarify their meaning::"
msgstr "Essayons ces méthodes pour clarifier leur signification ::"

#: ../Doc/howto/regex.rst:430
msgid ""
":meth:`group` returns the substring that was matched by the RE.  :meth:"
"`start` and :meth:`end` return the starting and ending index of the match. :"
"meth:`span` returns both start and end indexes in a single tuple.  Since "
"the :meth:`match` method only checks if the RE matches at the start of a "
"string, :meth:`start` will always be zero.  However, the :meth:`search` "
"method of patterns scans through the string, so  the match may not start at "
"zero in that case. ::"
msgstr ""

#: ../Doc/howto/regex.rst:447
msgid ""
"In actual programs, the most common style is to store the :ref:`match object "
"<match-objects>` in a variable, and then check if it was ``None``.  This "
"usually looks like::"
msgstr ""
"Dans les programmes réels, la façon de faire la plus courante consiste à "
"stocker :ref:`l'objet correspondance <match-objects>` dans une variable, "
"puis à vérifier s'il vaut ``None``. Généralement, cela ressemble à ceci ::"

#: ../Doc/howto/regex.rst:458
msgid ""
"Two pattern methods return all of the matches for a pattern. :meth:`findall` "
"returns a list of matching strings::"
msgstr ""

#: ../Doc/howto/regex.rst:465
msgid ""
":meth:`findall` has to create the entire list before it can be returned as "
"the result.  The :meth:`finditer` method returns a sequence of :ref:`match "
"object <match-objects>` instances as an :term:`iterator`. [#]_ ::"
msgstr ""

#: ../Doc/howto/regex.rst:481
msgid "Module-Level Functions"
msgstr "Fonctions de niveau module"

#: ../Doc/howto/regex.rst:483
msgid ""
"You don't have to create a pattern object and call its methods; the :mod:"
"`re` module also provides top-level functions called :func:`match`, :func:"
"`search`, :func:`findall`, :func:`sub`, and so forth.  These functions take "
"the same arguments as the corresponding pattern method, with the RE string "
"added as the first argument, and still return either ``None`` or a :ref:"
"`match object <match-objects>` instance. ::"
msgstr ""

#: ../Doc/howto/regex.rst:495
msgid ""
"Under the hood, these functions simply create a pattern object for you and "
"call the appropriate method on it.  They also store the compiled object in a "
"cache, so future calls using the same RE are faster."
msgstr ""

#: ../Doc/howto/regex.rst:499
msgid ""
"Should you use these module-level functions, or should you get the pattern "
"and call its methods yourself?  That choice depends on how frequently the RE "
"will be used, and on your personal coding style.  If the RE is being used at "
"only one point in the code, then the module functions are probably more "
"convenient.  If a program contains a lot of regular expressions, or re-uses "
"the same ones in several locations, then it might be worthwhile to collect "
"all the definitions in one place, in a section of code that compiles all the "
"REs ahead of time.  To take an example from the standard library, here's an "
"extract from the deprecated :mod:`xmllib` module::"
msgstr ""

#: ../Doc/howto/regex.rst:514
msgid ""
"I generally prefer to work with the compiled object, even for one-time uses, "
"but few people will be as much of a purist about this as I am."
msgstr ""

#: ../Doc/howto/regex.rst:519
msgid "Compilation Flags"
msgstr "Options de compilation"

#: ../Doc/howto/regex.rst:521
msgid ""
"Compilation flags let you modify some aspects of how regular expressions "
"work. Flags are available in the :mod:`re` module under two names, a long "
"name such as :const:`IGNORECASE` and a short, one-letter form such as :const:"
"`I`.  (If you're familiar with Perl's pattern modifiers, the one-letter "
"forms use the same letters; the short form of :const:`re.VERBOSE` is :const:"
"`re.X`, for example.) Multiple flags can be specified by bitwise OR-ing "
"them; ``re.I | re.M`` sets both the :const:`I` and :const:`M` flags, for "
"example."
msgstr ""
"Les options de compilation vous permettent de modifier le comportement des "
"expressions régulières. Ces options sont accessibles dans le module :mod:"
"`re` par deux noms, un long du type :const:`IGNORECASE` et un court (une "
"seule lettre) tel que :const:`I` (si vous êtes habitués aux modificateurs de "
"motifs Perl, la version courte utilise les mêmes lettres que Perl, par "
"exemple la version courte de :const:`re.VERBOSE` est :const:`re.X`). "
"Plusieurs options peuvent être spécifiées en appliquant l'opérateur bit-à-"
"bit *OR* ; par exemple, ``re.I | re.M`` active à la fois les options :const:"
"`I` et :const:`M`."

#: ../Doc/howto/regex.rst:529
msgid ""
"Here's a table of the available flags, followed by a more detailed "
"explanation of each one."
msgstr ""
"Vous trouvez ci-dessous le tableau des options disponibles, suivies "
"d'explications détaillées."

#: ../Doc/howto/regex.rst:533
msgid "Flag"
msgstr "Option"

#: ../Doc/howto/regex.rst:533
msgid "Meaning"
msgstr "Signification"

#: ../Doc/howto/regex.rst:535
msgid ":const:`DOTALL`, :const:`S`"
msgstr ":const:`DOTALL`, :const:`S`"

#: ../Doc/howto/regex.rst:535
msgid "Make ``.`` match any character, including newlines"
msgstr ""

#: ../Doc/howto/regex.rst:538
msgid ":const:`IGNORECASE`, :const:`I`"
msgstr ":const:`IGNORECASE`, :const:`I`"

#: ../Doc/howto/regex.rst:538
msgid "Do case-insensitive matches"
msgstr ""

#: ../Doc/howto/regex.rst:540
msgid ":const:`LOCALE`, :const:`L`"
msgstr ":const:`LOCALE`, :const:`L`"

#: ../Doc/howto/regex.rst:540
msgid "Do a locale-aware match"
msgstr ""

#: ../Doc/howto/regex.rst:542
msgid ":const:`MULTILINE`, :const:`M`"
msgstr ":const:`MULTILINE`, :const:`M`"

#: ../Doc/howto/regex.rst:542
msgid "Multi-line matching, affecting ``^`` and ``$``"
msgstr ""

#: ../Doc/howto/regex.rst:545
msgid ":const:`VERBOSE`, :const:`X`"
msgstr ""

#: ../Doc/howto/regex.rst:545
msgid ""
"Enable verbose REs, which can be organized more cleanly and understandably."
msgstr ""
"Active les RE verbeuses, qui peuvent être organisées de manière plus propre "
"et compréhensible."

#: ../Doc/howto/regex.rst:548
msgid ":const:`UNICODE`, :const:`U`"
msgstr ""

#: ../Doc/howto/regex.rst:548
msgid ""
"Makes several escapes like ``\\w``, ``\\b``, ``\\s`` and ``\\d`` dependent "
"on the Unicode character database."
msgstr ""

#: ../Doc/howto/regex.rst:558
msgid ""
"Perform case-insensitive matching; character class and literal strings will "
"match letters by ignoring case.  For example, ``[A-Z]`` will match lowercase "
"letters, too, and ``Spam`` will match ``Spam``, ``spam``, or ``spAM``. This "
"lowercasing doesn't take the current locale into account; it will if you "
"also set the :const:`LOCALE` flag."
msgstr ""

#: ../Doc/howto/regex.rst:569
msgid ""
"Make ``\\w``, ``\\W``, ``\\b``, and ``\\B``, dependent on the current locale."
msgstr ""

#: ../Doc/howto/regex.rst:571
msgid ""
"Locales are a feature of the C library intended to help in writing programs "
"that take account of language differences.  For example, if you're "
"processing French text, you'd want to be able to write ``\\w+`` to match "
"words, but ``\\w`` only matches the character class ``[A-Za-z]``; it won't "
"match ``'é'`` or ``'ç'``.  If your system is configured properly and a "
"French locale is selected, certain C functions will tell the program that "
"``'é'`` should also be considered a letter. Setting the :const:`LOCALE` flag "
"when compiling a regular expression will cause the resulting compiled object "
"to use these C functions for ``\\w``; this is slower, but also enables ``\\w"
"+`` to match French words as you'd expect."
msgstr ""

#: ../Doc/howto/regex.rst:586
msgid ""
"(``^`` and ``$`` haven't been explained yet;  they'll be introduced in "
"section :ref:`more-metacharacters`.)"
msgstr ""
"Nota : ``^`` et ``$`` n'ont pas encore été expliqués ; ils sont introduits "
"dans la section :ref:`more-metacharacters`."

#: ../Doc/howto/regex.rst:589
msgid ""
"Usually ``^`` matches only at the beginning of the string, and ``$`` matches "
"only at the end of the string and immediately before the newline (if any) at "
"the end of the string. When this flag is specified, ``^`` matches at the "
"beginning of the string and at the beginning of each line within the string, "
"immediately following each newline.  Similarly, the ``$`` metacharacter "
"matches either at the end of the string and at the end of each line "
"(immediately preceding each newline)."
msgstr ""
"Normalement, ``^`` correspond uniquement au début de la chaîne, et ``$`` "
"correspond uniquement à la fin de la chaîne et immédiatement avant la "
"nouvelle ligne (s'il y en a une) à la fin de la chaîne. Lorsque cette option "
"est spécifiée, ``^`` correspond au début de la chaîne de caractères et au "
"début de chaque ligne de la chaîne de caractères, immédiatement après le "
"début de la nouvelle ligne. De même, le métacaractère ``$`` correspond à la "
"fin de la chaîne de caractères ou à la fin de chaque ligne (précédant "
"immédiatement chaque nouvelle ligne)."

#: ../Doc/howto/regex.rst:602
msgid ""
"Makes the ``'.'`` special character match any character at all, including a "
"newline; without this flag, ``'.'`` will match anything *except* a newline."
msgstr ""
"Fait que le caractère spécial ``'.'`` corresponde avec n'importe quel "
"caractère, y compris le retour à la ligne ; sans cette option, ``'.'`` "
"correspond avec tout, *sauf* le retour à la ligne."

#: ../Doc/howto/regex.rst:610
msgid ""
"Make ``\\w``, ``\\W``, ``\\b``, ``\\B``, ``\\d``, ``\\D``, ``\\s`` and ``"
"\\S`` dependent on the Unicode character properties database."
msgstr ""

#: ../Doc/howto/regex.rst:618
msgid ""
"This flag allows you to write regular expressions that are more readable by "
"granting you more flexibility in how you can format them.  When this flag "
"has been specified, whitespace within the RE string is ignored, except when "
"the whitespace is in a character class or preceded by an unescaped "
"backslash; this lets you organize and indent the RE more clearly.  This flag "
"also lets you put comments within a RE that will be ignored by the engine; "
"comments are marked by a ``'#'`` that's neither in a character class or "
"preceded by an unescaped backslash."
msgstr ""
"Cette option vous permet d'écrire des expressions régulières plus lisibles "
"en vous permettant plus de flexibilité pour le formatage. Lorsque cette "
"option est activée, les \"blancs\" dans la chaîne RE sont ignorés, sauf "
"lorsque le \"blanc\" se trouve dans une classe de caractères ou est précédé "
"d'une barre oblique inverse ; ceci vous permet d'organiser et d'indenter vos "
"RE plus clairement. Cette option vous permet également de placer des "
"commentaires dans une RE, ils seront ignorés par le moteur ; les "
"commentaires commencent par un ``'#'`` qui n'est ni dans une classe de "
"caractères, ni précédé d'une barre oblique inverse."

#: ../Doc/howto/regex.rst:627
msgid ""
"For example, here's a RE that uses :const:`re.VERBOSE`; see how much easier "
"it is to read? ::"
msgstr ""
"Par exemple, voici une RE qui utilise :const:`re.VERBOSE` ; vous pouvez "
"constater qu'elle est beaucoup plus facile à lire ::"

#: ../Doc/howto/regex.rst:640
msgid "Without the verbose setting, the RE would look like this::"
msgstr "Sans l'option verbeuse, cette RE ressemble à ceci ::"

#: ../Doc/howto/regex.rst:646
msgid ""
"In the above example, Python's automatic concatenation of string literals "
"has been used to break up the RE into smaller pieces, but it's still more "
"difficult to understand than the version using :const:`re.VERBOSE`."
msgstr ""
"Dans l'exemple ci-dessus, Python concatène automatiquement les littéraux "
"chaînes de caractères qui ont été utilisés pour séparer la RE en petits "
"morceaux, mais la RE reste plus difficile à comprendre que sa version "
"utilisant :const:`re.VERBOSE`."

#: ../Doc/howto/regex.rst:652
msgid "More Pattern Power"
msgstr "Des motifs plus puissants"

#: ../Doc/howto/regex.rst:654
msgid ""
"So far we've only covered a part of the features of regular expressions.  In "
"this section, we'll cover some new metacharacters, and how to use groups to "
"retrieve portions of the text that was matched."
msgstr ""
"Jusqu'à présent nous avons seulement couvert une partie des fonctionnalités "
"des expressions régulières. Dans cette section, nous couvrirons quelques "
"nouveaux métacaractères et l'utilisation des groupes pour récupérer des "
"portions de textes correspondantes."

#: ../Doc/howto/regex.rst:662
msgid "More Metacharacters"
msgstr "Plus de métacaractères"

#: ../Doc/howto/regex.rst:664
msgid ""
"There are some metacharacters that we haven't covered yet.  Most of them "
"will be covered in this section."
msgstr ""
"Nous n'avons pas encore couvert tous les métacaractères. Cette section "
"traite de la plupart de ceux que nous n'avons pas abordés."

#: ../Doc/howto/regex.rst:667
msgid ""
"Some of the remaining metacharacters to be discussed are :dfn:`zero-width "
"assertions`.  They don't cause the engine to advance through the string; "
"instead, they consume no characters at all, and simply succeed or fail.  For "
"example, ``\\b`` is an assertion that the current position is located at a "
"word boundary; the position isn't changed by the ``\\b`` at all.  This means "
"that zero-width assertions should never be repeated, because if they match "
"once at a given location, they can obviously be matched an infinite number "
"of times."
msgstr ""
"Certains métacaractères restants sont des :dfn:`assertions de largeur zéro` "
"(*zero-width assertions* en anglais). Ils ne font pas avancer le moteur dans "
"la chaîne de caractères ; ils ne consomment aucun caractère et ils "
"réussissent ou échouent tout simplement. Par exemple, ``\\b`` est une "
"assertion selon laquelle la position actuelle est située à la limite d'un "
"mot ; la position n'est pas modifiée par le \" \\b \". Cela signifie que les "
"assertions de largeur zéro ne doivent pas être répétées car, si elles "
"correspondent à un endroit donné, elles correspondent automatiquement un "
"nombre infini de fois."

#: ../Doc/howto/regex.rst:683
msgid "``|``"
msgstr "``|``"

#: ../Doc/howto/regex.rst:676
msgid ""
"Alternation, or the \"or\" operator.   If A and B are regular expressions, "
"``A|B`` will match any string that matches either ``A`` or ``B``. ``|`` has "
"very low precedence in order to make it work reasonably when you're "
"alternating multi-character strings. ``Crow|Servo`` will match either "
"``Crow`` or ``Servo``, not ``Cro``, a ``'w'`` or an ``'S'``, and ``ervo``."
msgstr ""

#: ../Doc/howto/regex.rst:682
msgid ""
"To match a literal ``'|'``, use ``\\|``, or enclose it inside a character "
"class, as in ``[|]``."
msgstr ""
"Pour correspondre avec un ``'|'`` littéral, utilisez ``\\|`` ou placez-le "
"dans une classe de caractères, comme ceci ``[|]``."

#: ../Doc/howto/regex.rst:699
msgid "``^``"
msgstr "``^``"

#: ../Doc/howto/regex.rst:686
msgid ""
"Matches at the beginning of lines.  Unless the :const:`MULTILINE` flag has "
"been set, this will only match at the beginning of the string.  In :const:"
"`MULTILINE` mode, this also matches immediately after each newline within "
"the string."
msgstr ""
"Correspond à un début de ligne. À moins que l'option :const:`MULTILINE` ne "
"soit activée, cela ne fait correspondre que le début de la chaîne. Dans le "
"mode :const:`MULTILINE`, cela fait aussi correspondre immédiatement après "
"chaque nouvelle ligne à l'intérieur de la chaîne."

#: ../Doc/howto/regex.rst:690
msgid ""
"For example, if you wish to match the word ``From`` only at the beginning of "
"a line, the RE to use is ``^From``. ::"
msgstr ""
"Par exemple, si vous voulez trouver le mot ``From`` uniquement quand il est "
"en début de ligne, la RE à utiliser est ``^From``. ::"

#: ../Doc/howto/regex.rst:713
msgid "``$``"
msgstr "``$``"

#: ../Doc/howto/regex.rst:702
msgid ""
"Matches at the end of a line, which is defined as either the end of the "
"string, or any location followed by a newline character.     ::"
msgstr ""
"Correspond à une fin de ligne, ce qui veut dire soit la fin de la chaîne, "
"soit tout emplacement qui est suivi du caractère de nouvelle ligne. ::"

#: ../Doc/howto/regex.rst:712
msgid ""
"To match a literal ``'$'``, use ``\\$`` or enclose it inside a character "
"class, as in  ``[$]``."
msgstr ""
"Pour trouver un ``'$'`` littéral, utilisez ``\\$`` ou placez-le à "
"l'intérieur d'une classe de caractères, comme ceci ``[$]``."

#: ../Doc/howto/regex.rst:719
msgid "``\\A``"
msgstr "``\\A``"

#: ../Doc/howto/regex.rst:716
msgid ""
"Matches only at the start of the string.  When not in :const:`MULTILINE` "
"mode, ``\\A`` and ``^`` are effectively the same.  In :const:`MULTILINE` "
"mode, they're different: ``\\A`` still matches only at the beginning of the "
"string, but ``^`` may match at any location inside the string that follows a "
"newline character."
msgstr ""
"Correspond au début de la chaîne de caractère, uniquement. Si l'option :"
"const:`MULTILINE` n'est pas activée, ``\\A`` et ``^`` sont équivalents. Dans "
"le mode :const:`MULTILINE`, ils sont différents : ``\\A`` ne correspond "
"toujours qu'au début de la chaîne alors que ``^`` correspond aussi aux "
"emplacements situés immédiatement après une nouvelle ligne à l'intérieur de "
"la chaîne."

#: ../Doc/howto/regex.rst:722
msgid "``\\Z``"
msgstr "``\\Z``"

#: ../Doc/howto/regex.rst:722
msgid "Matches only at the end of the string."
msgstr "Correspond uniquement à la fin d'une chaîne de caractères."

#: ../Doc/howto/regex.rst:757
msgid "``\\b``"
msgstr "``\\b``"

#: ../Doc/howto/regex.rst:725
msgid ""
"Word boundary.  This is a zero-width assertion that matches only at the "
"beginning or end of a word.  A word is defined as a sequence of alphanumeric "
"characters, so the end of a word is indicated by whitespace or a non-"
"alphanumeric character."
msgstr ""
"Limite de mot. C'est une assertion de largeur zéro qui correspond uniquement "
"aux positions de début et de fin de mot. Un mot est défini comme une "
"séquence de caractères alphanumériques ; ainsi, la fin d'un mot est indiquée "
"par un \"blanc\" ou un caractère non-alphanumérique."

#: ../Doc/howto/regex.rst:730
msgid ""
"The following example matches ``class`` only when it's a complete word; it "
"won't match when it's contained inside another word. ::"
msgstr ""
"L'exemple suivant fait correspondre ``class`` seulement si c'est un mot "
"complet ; il n'y a pas de correspondance quand il est à l'intérieur d'un "
"autre mot. ::"

#: ../Doc/howto/regex.rst:741
msgid ""
"There are two subtleties you should remember when using this special "
"sequence. First, this is the worst collision between Python's string "
"literals and regular expression sequences.  In Python's string literals, ``"
"\\b`` is the backspace character, ASCII value 8.  If you're not using raw "
"strings, then Python will convert the ``\\b`` to a backspace, and your RE "
"won't match as you expect it to. The following example looks the same as our "
"previous RE, but omits the ``'r'`` in front of the RE string. ::"
msgstr ""
"Quand vous utilisez cette séquence spéciale, gardez deux choses à l'esprit. "
"Tout d'abord, c'est la pire collision entre les littéraux des chaînes Python "
"et les séquences d'expressions régulières.  Dans les littéraux de chaîne de "
"caractères Python, ``\\b``` est le caractère de retour-arrière (*backspace* "
"en anglais), dont la valeur ASCII est 8.  Si vous n'utilisez pas les chaînes "
"de caractères brutes, alors Python convertit le ``\\b`` en retour-arrière, "
"et votre RE ne correspond pas à ce que vous attendez. L'exemple suivant "
"ressemble à notre RE précédente, mais nous avons omis le ```'r'`` devant la "
"chaîne RE. ::"

#: ../Doc/howto/regex.rst:755
msgid ""
"Second, inside a character class, where there's no use for this assertion, ``"
"\\b`` represents the backspace character, for compatibility with Python's "
"string literals."
msgstr ""
"Ensuite, dans une classe de caractères, où cette assertion n'a pas lieu "
"d'être, ``\\b`` représente le caractère retour-arrière, afin d'être "
"compatible avec les littéraux de chaînes de caractères."

#: ../Doc/howto/regex.rst:762
msgid "``\\B``"
msgstr "``\\B``"

#: ../Doc/howto/regex.rst:760
msgid ""
"Another zero-width assertion, this is the opposite of ``\\b``, only matching "
"when the current position is not at a word boundary."
msgstr ""
"Encore une assertion de largeur zéro, qui est l'opposée de ``\\b``, c'est-à-"
"dire qu'elle fait correspondre uniquement les emplacements qui ne sont pas à "
"la limite d'un mot."

#: ../Doc/howto/regex.rst:765
msgid "Grouping"
msgstr "Regroupement"

#: ../Doc/howto/regex.rst:767
msgid ""
"Frequently you need to obtain more information than just whether the RE "
"matched or not.  Regular expressions are often used to dissect strings by "
"writing a RE divided into several subgroups which match different components "
"of interest. For example, an RFC-822 header line is divided into a header "
"name and a value, separated by a ``':'``, like this::"
msgstr ""

#: ../Doc/howto/regex.rst:778
msgid ""
"This can be handled by writing a regular expression which matches an entire "
"header line, and has one group which matches the header name, and another "
"group which matches the header's value."
msgstr ""
"Vous pouvez alors écrire une expression régulière qui fait correspondre une "
"ligne d'en-tête entière et qui comporte un groupe correspondant au nom de "
"l'en-tête, et un autre groupe correspondant à la valeur de l'en-tête."

#: ../Doc/howto/regex.rst:782
msgid ""
"Groups are marked by the ``'('``, ``')'`` metacharacters. ``'('`` and "
"``')'`` have much the same meaning as they do in mathematical expressions; "
"they group together the expressions contained inside them, and you can "
"repeat the contents of a group with a repeating qualifier, such as ``*``, ``"
"+``, ``?``, or ``{m,n}``.  For example, ``(ab)*`` will match zero or more "
"repetitions of ``ab``. ::"
msgstr ""
"Les groupes sont délimités par les métacaractères marqueurs ``'('``et "
"``')'``. ``'('`` et ``')'`` ont à peu près le même sens que dans les "
"expressions mathématiques ; ils forment un groupe à partir des expressions "
"qu'ils encadrent ; vous pouvez répéter le contenu d'un groupe à l'aide d'un "
"quantificateur, comme ``*``, ``+``, ``?`` ou ``{m,n}``. Par exemple, "
"``(ab)*`` correspond à zéro, une ou plusieurs fois ``ab``. ::"

#: ../Doc/howto/regex.rst:793
msgid ""
"Groups indicated with ``'('``, ``')'`` also capture the starting and ending "
"index of the text that they match; this can be retrieved by passing an "
"argument to :meth:`group`, :meth:`start`, :meth:`end`, and :meth:`span`.  "
"Groups are numbered starting with 0.  Group 0 is always present; it's the "
"whole RE, so :ref:`match object <match-objects>` methods all have group 0 as "
"their default argument.  Later we'll see how to express groups that don't "
"capture the span of text that they match. ::"
msgstr ""

#: ../Doc/howto/regex.rst:808
msgid ""
"Subgroups are numbered from left to right, from 1 upward.  Groups can be "
"nested; to determine the number, just count the opening parenthesis "
"characters, going from left to right. ::"
msgstr ""
"Les sous-groupes sont numérotés de la gauche vers la droite, à partir de 1. "
"Les groupes peuvent être imbriqués ; pour déterminer le numéro, il vous "
"suffit de compter le nombre de parenthèses ouvrantes de la gauche vers la "
"droite. ::"

#: ../Doc/howto/regex.rst:821
msgid ""
":meth:`group` can be passed multiple group numbers at a time, in which case "
"it will return a tuple containing the corresponding values for those "
"groups. ::"
msgstr ""

#: ../Doc/howto/regex.rst:827
msgid ""
"The :meth:`groups` method returns a tuple containing the strings for all the "
"subgroups, from 1 up to however many there are. ::"
msgstr ""

#: ../Doc/howto/regex.rst:833
msgid ""
"Backreferences in a pattern allow you to specify that the contents of an "
"earlier capturing group must also be found at the current location in the "
"string.  For example, ``\\1`` will succeed if the exact contents of group 1 "
"can be found at the current position, and fails otherwise.  Remember that "
"Python's string literals also use a backslash followed by numbers to allow "
"including arbitrary characters in a string, so be sure to use a raw string "
"when incorporating backreferences in a RE."
msgstr ""
"Les renvois dans un motif vous permettent de spécifier que le contenu d'un "
"groupe précédent doit aussi être trouvé à l'emplacement actuel dans la "
"chaîne. Par exemple, ``\\1`` réussit si le contenu du premier groupe se "
"trouve aussi à la position courante, sinon il échoue. Rappelez-vous que les "
"littéraux de chaînes Python utilisent aussi la barre oblique inverse suivie "
"d'un nombre pour insérer des caractères arbitraires dans une chaîne ; soyez "
"sûr d'utiliser une chaîne brute quand vous faites des renvois dans une RE."

#: ../Doc/howto/regex.rst:841
msgid "For example, the following RE detects doubled words in a string. ::"
msgstr ""
"Par exemple, la RE suivante détecte les mots doublés dans une chaîne. ::"

#: ../Doc/howto/regex.rst:847
msgid ""
"Backreferences like this aren't often useful for just searching through a "
"string --- there are few text formats which repeat data in this way --- but "
"you'll soon find out that they're *very* useful when performing string "
"substitutions."
msgstr ""
"Les renvois tels que celui-ci ne sont pas très utiles pour effectuer une "
"simple recherche dans une chaîne --- il n'y a que peu de formats de textes "
"qui répètent des données ainsi --- mais vous verrez bientôt qu'ils sont "
"*très* utiles pour effectuer des substitutions dans les chaînes."

#: ../Doc/howto/regex.rst:853
msgid "Non-capturing and Named Groups"
msgstr "Groupes non de capture et groupes nommés"

#: ../Doc/howto/regex.rst:855
msgid ""
"Elaborate REs may use many groups, both to capture substrings of interest, "
"and to group and structure the RE itself.  In complex REs, it becomes "
"difficult to keep track of the group numbers.  There are two features which "
"help with this problem.  Both of them use a common syntax for regular "
"expression extensions, so we'll look at that first."
msgstr ""
"Les RE élaborées peuvent utiliser de nombreux groupes, à la fois pour "
"capturer des sous-chaînes intéressantes ainsi que pour regrouper et "
"structurer la RE elle-même. Dans les RE complexes, il devient difficile de "
"garder la trace des numéros de groupes. Deux caractéristiques aident à "
"résoudre ce problème, toutes deux utilisant la même syntaxe d'extension des "
"expressions régulières. Nous allons donc commencer en examinant cette "
"syntaxe."

#: ../Doc/howto/regex.rst:861
msgid ""
"Perl 5 added several additional features to standard regular expressions, "
"and the Python :mod:`re` module supports most of them.   It would have been "
"difficult to choose new single-keystroke metacharacters or new special "
"sequences beginning with ``\\`` to represent the new features without making "
"Perl's regular expressions confusingly different from standard REs.  If you "
"chose ``&`` as a new metacharacter, for example, old expressions would be "
"assuming that ``&`` was a regular character and wouldn't have escaped it by "
"writing ``\\&`` or ``[&]``."
msgstr ""

#: ../Doc/howto/regex.rst:869
msgid ""
"The solution chosen by the Perl developers was to use ``(?...)`` as the "
"extension syntax.  ``?`` immediately after a parenthesis was a syntax error "
"because the ``?`` would have nothing to repeat, so this didn't introduce any "
"compatibility problems.  The characters immediately after the ``?``  "
"indicate what extension is being used, so ``(?=foo)`` is one thing (a "
"positive lookahead assertion) and ``(?:foo)`` is something else (a non-"
"capturing group containing the subexpression ``foo``)."
msgstr ""
"La solution adoptée par les développeurs Perl a été d'utiliser ``(?...)`` "
"comme syntaxe d'extension. Placer ``?`` immédiatement après une parenthèse "
"était une erreur de syntaxe, parce que le ``?`` n'a alors rien à répéter. "
"Ainsi, cela n'a pas introduit de problème de compatibilité. Les caractères "
"qui suivent immédiatement le ``?`` indiquent quelle extension est utilisée, "
"donc ``(?=truc)`` est une chose (une assertion positive anticipée) et ``(?:"
"truc)`` est une autre chose (la sous-expression ``truc`` que l'on groupe)."

#: ../Doc/howto/regex.rst:877
msgid ""
"Python adds an extension syntax to Perl's extension syntax.  If the first "
"character after the question mark is a ``P``, you know that it's an "
"extension that's specific to Python.  Currently there are two such "
"extensions: ``(?P<name>...)`` defines a named group, and ``(?P=name)`` is a "
"backreference to a named group.  If future versions of Perl 5 add similar "
"features using a different syntax, the :mod:`re` module will be changed to "
"support the new syntax, while preserving the Python-specific syntax for "
"compatibility's sake."
msgstr ""

#: ../Doc/howto/regex.rst:885
msgid ""
"Now that we've looked at the general extension syntax, we can return to the "
"features that simplify working with groups in complex REs. Since groups are "
"numbered from left to right and a complex expression may use many groups, it "
"can become difficult to keep track of the correct numbering.  Modifying such "
"a complex RE is annoying, too: insert a new group near the beginning and you "
"change the numbers of everything that follows it."
msgstr ""

#: ../Doc/howto/regex.rst:892
msgid ""
"Sometimes you'll want to use a group to collect a part of a regular "
"expression, but aren't interested in retrieving the group's contents. You "
"can make this fact explicit by using a non-capturing group: ``(?:...)``, "
"where you can replace the ``...`` with any other regular expression. ::"
msgstr ""

#: ../Doc/howto/regex.rst:904
msgid ""
"Except for the fact that you can't retrieve the contents of what the group "
"matched, a non-capturing group behaves exactly the same as a capturing "
"group; you can put anything inside it, repeat it with a repetition "
"metacharacter such as ``*``, and nest it within other groups (capturing or "
"non-capturing). ``(?:...)`` is particularly useful when modifying an "
"existing pattern, since you can add new groups without changing how all the "
"other groups are numbered.  It should be mentioned that there's no "
"performance difference in searching between capturing and non-capturing "
"groups; neither form is any faster than the other."
msgstr ""
"À part le fait que vous n'avez pas accès au contenu du groupe, un groupe se "
"comporte exactement de la même manière qu'un groupe de capture ; vous pouvez "
"placer n'importe quoi dedans, spécifier une répétition avec un métacaractère "
"tel que ``*`` et l'imbriquer dans un autre groupe (de capture ou pas). "
"``(?:...)`` est particulièrement utile quand vous modifiez des motifs "
"existants, puisque vous pouvez ajouter de nouveaux groupes sans changer la "
"façon dont les autres groupes sont numérotés. Nous devons mentionner ici "
"qu'il n'y a aucune différence de performance dans la recherche de groupes, "
"de capture ou non ; les deux formes travaillent à la même vitesse."

#: ../Doc/howto/regex.rst:913
msgid ""
"A more significant feature is named groups: instead of referring to them by "
"numbers, groups can be referenced by a name."
msgstr ""
"Une fonctionnalité plus importante est le nommage des groupes : au lieu d'y "
"faire référence par des nombres, vous pouvez référencer des groupes par leur "
"nom."

#: ../Doc/howto/regex.rst:916
msgid ""
"The syntax for a named group is one of the Python-specific extensions: ``(?"
"P<name>...)``.  *name* is, obviously, the name of the group.  Named groups "
"also behave exactly like capturing groups, and additionally associate a name "
"with a group.  The :ref:`match object <match-objects>` methods that deal "
"with capturing groups all accept either integers that refer to the group by "
"number or strings that contain the desired group's name.  Named groups are "
"still given numbers, so you can retrieve information about a group in two "
"ways::"
msgstr ""

#: ../Doc/howto/regex.rst:931
msgid ""
"Named groups are handy because they let you use easily-remembered names, "
"instead of having to remember numbers.  Here's an example RE from the :mod:"
"`imaplib` module::"
msgstr ""
"Les groupes nommés sont pratiques car il est plus facile de se rappeler un "
"nom qu'un numéro. Voici un exemple de RE tirée du module :mod:`imaplib` ::"

#: ../Doc/howto/regex.rst:942
msgid ""
"It's obviously much easier to retrieve ``m.group('zonem')``, instead of "
"having to remember to retrieve group 9."
msgstr ""
"Il est évidemment plus facile de récupérer ``m.group('zonem')`` que de se "
"rappeler de récupérer le groupe 9."

#: ../Doc/howto/regex.rst:945
msgid ""
"The syntax for backreferences in an expression such as ``(...)\\1`` refers "
"to the number of the group.  There's naturally a variant that uses the group "
"name instead of the number. This is another Python extension: ``(?P=name)`` "
"indicates that the contents of the group called *name* should again be "
"matched at the current point.  The regular expression for finding doubled "
"words, ``(\\b\\w+)\\s+\\1`` can also be written as ``(?P<word>\\b\\w+)\\s+(?"
"P=word)``::"
msgstr ""

#: ../Doc/howto/regex.rst:958
msgid "Lookahead Assertions"
msgstr "Assertions prédictives"

#: ../Doc/howto/regex.rst:960
msgid ""
"Another zero-width assertion is the lookahead assertion.  Lookahead "
"assertions are available in both positive and negative form, and  look like "
"this:"
msgstr ""
"Une autre assertion de largeur zéro est l'assertion prédictive. Une "
"assertion prédictive peut s'exprimer sous deux formes, la positive et la "
"négative, comme ceci :"

#: ../Doc/howto/regex.rst:968
msgid "``(?=...)``"
msgstr "``(?=...)``"

#: ../Doc/howto/regex.rst:964
msgid ""
"Positive lookahead assertion.  This succeeds if the contained regular "
"expression, represented here by ``...``, successfully matches at the current "
"location, and fails otherwise. But, once the contained expression has been "
"tried, the matching engine doesn't advance at all; the rest of the pattern "
"is tried right where the assertion started."
msgstr ""
"Assertion prédictive positive. Elle réussit si l'expression régulière "
"contenue, représentée ici par  ``...``, correspond effectivement à "
"l'emplacement courant ; dans le cas contraire, elle échoue. Mais, une fois "
"que l'expression contenue a été essayée, le moteur de correspondance "
"n'avance pas ; le reste du motif est testé à l'endroit même où l'assertion a "
"commencé."

#: ../Doc/howto/regex.rst:973
msgid "``(?!...)``"
msgstr "``(?!...)``"

#: ../Doc/howto/regex.rst:971
msgid ""
"Negative lookahead assertion.  This is the opposite of the positive "
"assertion; it succeeds if the contained expression *doesn't* match at the "
"current position in the string."
msgstr ""
"Assertion prédictive négative. C'est l'opposée de l'assertion positive ; "
"elle réussit si l'expression régulière contenue *ne* correspond *pas* à "
"l'emplacement courant dans la chaine."

#: ../Doc/howto/regex.rst:975
msgid ""
"To make this concrete, let's look at a case where a lookahead is useful. "
"Consider a simple pattern to match a filename and split it apart into a base "
"name and an extension, separated by a ``.``.  For example, in ``news.rc``, "
"``news`` is the base name, and ``rc`` is the filename's extension."
msgstr ""
"Pour rendre ceci plus concret, regardons le cas où une prédiction est utile. "
"Considérons un motif simple qui doit faire correspondre un nom de fichier et "
"le diviser en un nom de base et une extension, séparés par un ``.``. Par "
"exemple, dans ``news.rc``, ``news`` est le nom de base et ``rc`` est "
"l'extension du nom de fichier."

#: ../Doc/howto/regex.rst:980
msgid "The pattern to match this is quite simple:"
msgstr "Le motif de correspondance est plutôt simple :"

#: ../Doc/howto/regex.rst:982
msgid "``.*[.].*$``"
msgstr "``.*[.].*$``"

#: ../Doc/howto/regex.rst:984
msgid ""
"Notice that the ``.`` needs to be treated specially because it's a "
"metacharacter; I've put it inside a character class.  Also notice the "
"trailing ``$``; this is added to ensure that all the rest of the string must "
"be included in the extension.  This regular expression matches ``foo.bar`` "
"and ``autoexec.bat`` and ``sendmail.cf`` and ``printers.conf``."
msgstr ""

#: ../Doc/howto/regex.rst:990
msgid ""
"Now, consider complicating the problem a bit; what if you want to match "
"filenames where the extension is not ``bat``? Some incorrect attempts:"
msgstr ""
"Maintenant, compliquons un peu le problème ; si nous voulons faire "
"correspondre les noms de fichiers dont l'extension n'est pas ``bat`` ? voici "
"quelques tentatives incorrectes :"

#: ../Doc/howto/regex.rst:993
msgid ""
"``.*[.][^b].*$``  The first attempt above tries to exclude ``bat`` by "
"requiring that the first character of the extension is not a ``b``.  This is "
"wrong, because the pattern also doesn't match ``foo.bar``."
msgstr ""
"``.*[.][^b].*$`` Le premier essai ci-dessus tente d'exclure ``bat`` en "
"spécifiant que le premier caractère de l'extension ne doit pas être ``b``. "
"Cela ne fonctionne pas, car le motif n'accepte pas ``truc.bar``."

#: ../Doc/howto/regex.rst:997
msgid "``.*[.]([^b]..|.[^a].|..[^t])$``"
msgstr "``.*[.]([^b]..|.[^a].|..[^t])$``"

#: ../Doc/howto/regex.rst:999
msgid ""
"The expression gets messier when you try to patch up the first solution by "
"requiring one of the following cases to match: the first character of the "
"extension isn't ``b``; the second character isn't ``a``; or the third "
"character isn't ``t``.  This accepts ``foo.bar`` and rejects ``autoexec."
"bat``, but it requires a three-letter extension and won't accept a filename "
"with a two-letter extension such as ``sendmail.cf``.  We'll complicate the "
"pattern again in an effort to fix it."
msgstr ""
"L'expression devient plus confuse si nous essayons de réparer la première "
"solution en spécifiant l'un des cas suivants : le premier caractère de "
"l'extension n'est pas ``b`` ; le deuxième caractère n'est pas ``a`` ; ou le "
"troisième caractère n'est pas ``t```. Ce motif accepte ``truc.bar`` et "
"rejette ``autoexec.bat``, mais elle nécessite une extension de trois lettres "
"et n'accepte pas un nom de fichier avec une extension de deux lettres comme "
"``sendmail.cf``. Compliquons encore une fois le motif pour essayer de le "
"réparer."

#: ../Doc/howto/regex.rst:1007
msgid "``.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$``"
msgstr "``.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$``"

#: ../Doc/howto/regex.rst:1009
msgid ""
"In the third attempt, the second and third letters are all made optional in "
"order to allow matching extensions shorter than three characters, such as "
"``sendmail.cf``."
msgstr ""
"Pour cette troisième tentative, les deuxième et troisième lettres sont "
"devenues facultatives afin de permettre la correspondance avec des "
"extensions plus courtes que trois caractères, comme ``sendmail.cf``."

#: ../Doc/howto/regex.rst:1013
msgid ""
"The pattern's getting really complicated now, which makes it hard to read "
"and understand.  Worse, if the problem changes and you want to exclude both "
"``bat`` and ``exe`` as extensions, the pattern would get even more "
"complicated and confusing."
msgstr ""
"Le motif devient vraiment compliqué maintenant, ce qui le rend difficile à "
"lire et à comprendre. Pire, si le problème change et que vous voulez exclure "
"à la fois ``bat`` et ``exe`` en tant qu'extensions, le modèle deviendra "
"encore plus compliqué et confus."

#: ../Doc/howto/regex.rst:1018
msgid "A negative lookahead cuts through all this confusion:"
msgstr "Une assertion prédictive négative supprime toute cette confusion :"

#: ../Doc/howto/regex.rst:1020
msgid ""
"``.*[.](?!bat$)[^.]*$``  The negative lookahead means: if the expression "
"``bat`` doesn't match at this point, try the rest of the pattern; if ``bat"
"$`` does match, the whole pattern will fail.  The trailing ``$`` is required "
"to ensure that something like ``sample.batch``, where the extension only "
"starts with ``bat``, will be allowed.  The ``[^.]*`` makes sure that the "
"pattern works when there are multiple dots in the filename."
msgstr ""
"``.*[.](?!bat$)[^.]*$`` Cette assertion prédictive négative signifie : si "
"l'expression ``bat`` ne correspond pas à cet emplacement, essaie le reste du "
"motif ; si ``bat$`` correspond, tout le motif échoue. Le ``$`` est "
"nécessaire pour s'assurer que quelque chose comme ``sample.batch``, où c'est "
"seulement le début de l'extension qui vaut ``bat``, est autorisé. Le "
"``[^...]*`` s'assure que le motif fonctionne lorsqu'il y a plusieurs points "
"dans le nom de fichier."

#: ../Doc/howto/regex.rst:1027
msgid ""
"Excluding another filename extension is now easy; simply add it as an "
"alternative inside the assertion.  The following pattern excludes filenames "
"that end in either ``bat`` or ``exe``:"
msgstr ""
"Exclure une autre extension de nom de fichier est maintenant facile ; il "
"suffit de l'ajouter comme alternative à l'intérieur de l'assertion. Le motif "
"suivant exclut les noms de fichiers qui se terminent par ``bat`` ou ``exe`` :"

#: ../Doc/howto/regex.rst:1031
msgid "``.*[.](?!bat$|exe$)[^.]*$``"
msgstr "``.*[.](?!bat$|exe$)[^.]*$``"

#: ../Doc/howto/regex.rst:1035
msgid "Modifying Strings"
msgstr "Modification de chaînes"

#: ../Doc/howto/regex.rst:1037
msgid ""
"Up to this point, we've simply performed searches against a static string. "
"Regular expressions are also commonly used to modify strings in various "
"ways, using the following pattern methods:"
msgstr ""
"Jusqu'à présent, nous avons simplement effectué des recherches dans une "
"chaîne statique. Les expressions régulières sont aussi couramment utilisées "
"pour modifier les chaînes de caractères de diverses manières, en utilisant "
"les méthodes suivantes des motifs :"

#: ../Doc/howto/regex.rst:1044
msgid "``split()``"
msgstr "``split()``"

#: ../Doc/howto/regex.rst:1044
msgid "Split the string into a list, splitting it wherever the RE matches"
msgstr ""
"Découpe la chaîne de caractère en liste, la découpant partout où la RE "
"correspond"

#: ../Doc/howto/regex.rst:1047
msgid "``sub()``"
msgstr "``sub()``"

#: ../Doc/howto/regex.rst:1047
msgid ""
"Find all substrings where the RE matches, and replace them with a different "
"string"
msgstr ""
"Recherche toutes les sous-chaînes de caractères où la RE correspond et les "
"substitue par une chaîne de caractères différente"

#: ../Doc/howto/regex.rst:1050
msgid "``subn()``"
msgstr "``subn()``"

#: ../Doc/howto/regex.rst:1050
msgid ""
"Does the same thing as :meth:`sub`,  but returns the new string and the "
"number of replacements"
msgstr ""

#: ../Doc/howto/regex.rst:1057
msgid "Splitting Strings"
msgstr "Découpage de chaînes"

#: ../Doc/howto/regex.rst:1059
msgid ""
"The :meth:`split` method of a pattern splits a string apart wherever the RE "
"matches, returning a list of the pieces. It's similar to the :meth:`split` "
"method of strings but provides much more generality in the delimiters that "
"you can split by; :meth:`split` only supports splitting by whitespace or by "
"a fixed string.  As you'd expect, there's a module-level :func:`re.split` "
"function, too."
msgstr ""

#: ../Doc/howto/regex.rst:1070
msgid ""
"Split *string* by the matches of the regular expression.  If capturing "
"parentheses are used in the RE, then their contents will also be returned as "
"part of the resulting list.  If *maxsplit* is nonzero, at most *maxsplit* "
"splits are performed."
msgstr ""
"Découpe *string* en suivant les correspondances de l'expression régulière. "
"Si des parenthèses de capture sont utilisées dans la RE, leur contenu est "
"également renvoyé dans la liste résultante. Si *maxsplit* n'est pas nul, au "
"plus *maxsplit* découpages sont effectués."

#: ../Doc/howto/regex.rst:1075
msgid ""
"You can limit the number of splits made, by passing a value for *maxsplit*. "
"When *maxsplit* is nonzero, at most *maxsplit* splits will be made, and the "
"remainder of the string is returned as the final element of the list.  In "
"the following example, the delimiter is any sequence of non-alphanumeric "
"characters. ::"
msgstr ""
"Vous pouvez limiter le nombre de découpages effectués en passant une valeur "
"pour *maxsplit*. Quand *maxsplit* n'est pas nul, au plus *maxsplit* "
"découpages sont effectués et le reste de la chaîne est renvoyé comme dernier "
"élément de la liste. Dans l'exemple suivant, le délimiteur est toute "
"séquence de caractères non alphanumériques. ::"

#: ../Doc/howto/regex.rst:1087
msgid ""
"Sometimes you're not only interested in what the text between delimiters is, "
"but also need to know what the delimiter was.  If capturing parentheses are "
"used in the RE, then their values are also returned as part of the list.  "
"Compare the following calls::"
msgstr ""
"Parfois, vous voulez récupérer le texte entre les délimiteurs mais aussi "
"quel était le délimiteur. Si des parenthèses de capture sont utilisées dans "
"la RE, leurs valeurs sont également renvoyées dans la liste. Comparons les "
"appels suivants ::"

#: ../Doc/howto/regex.rst:1099
msgid ""
"The module-level function :func:`re.split` adds the RE to be used as the "
"first argument, but is otherwise the same.   ::"
msgstr ""
"La fonction de niveau module :func:`re.split` ajoute la RE à utiliser comme "
"premier argument, mais est par ailleurs identique. ::"

#: ../Doc/howto/regex.rst:1111
msgid "Search and Replace"
msgstr "Recherche et substitution"

#: ../Doc/howto/regex.rst:1113
msgid ""
"Another common task is to find all the matches for a pattern, and replace "
"them with a different string.  The :meth:`sub` method takes a replacement "
"value, which can be either a string or a function, and the string to be "
"processed."
msgstr ""

#: ../Doc/howto/regex.rst:1121
msgid ""
"Returns the string obtained by replacing the leftmost non-overlapping "
"occurrences of the RE in *string* by the replacement *replacement*.  If the "
"pattern isn't found, *string* is returned unchanged."
msgstr ""
"Renvoie la chaîne obtenue en remplaçant les occurrences sans chevauchement "
"les plus à gauche de la RE dans *string* par la substitution *replacement*. "
"Si le motif n'est pas trouvé, *string* est renvoyée inchangée."

#: ../Doc/howto/regex.rst:1125
msgid ""
"The optional argument *count* is the maximum number of pattern occurrences "
"to be replaced; *count* must be a non-negative integer.  The default value "
"of 0 means to replace all occurrences."
msgstr ""
"L'argument optionnel *count* est le nombre maximum d'occurrences du motif à "
"remplacer ; *count* doit être un entier positif ou nul. La valeur par défaut "
"de 0 signifie qu'il faut remplacer toutes les occurrences."

#: ../Doc/howto/regex.rst:1129
msgid ""
"Here's a simple example of using the :meth:`sub` method.  It replaces colour "
"names with the word ``colour``::"
msgstr ""

#: ../Doc/howto/regex.rst:1138
msgid ""
"The :meth:`subn` method does the same work, but returns a 2-tuple containing "
"the new string value and the number of replacements  that were performed::"
msgstr ""

#: ../Doc/howto/regex.rst:1147
msgid ""
"Empty matches are replaced only when they're not adjacent to a previous "
"match. ::"
msgstr ""

#: ../Doc/howto/regex.rst:1154
msgid ""
"If *replacement* is a string, any backslash escapes in it are processed.  "
"That is, ``\\n`` is converted to a single newline character, ``\\r`` is "
"converted to a carriage return, and so forth. Unknown escapes such as ``"
"\\j`` are left alone. Backreferences, such as ``\\6``, are replaced with the "
"substring matched by the corresponding group in the RE.  This lets you "
"incorporate portions of the original text in the resulting replacement "
"string."
msgstr ""

#: ../Doc/howto/regex.rst:1161
msgid ""
"This example matches the word ``section`` followed by a string enclosed in "
"``{``, ``}``, and changes ``section`` to ``subsection``::"
msgstr ""
"Cet exemple fait correspondre le mot ``section`` suivi par une chaîne "
"encadrée par  ``{`` et ``}``, et modifie ``section`` en ``subsection`` ::"

#: ../Doc/howto/regex.rst:1168
msgid ""
"There's also a syntax for referring to named groups as defined by the ``(?"
"P<name>...)`` syntax.  ``\\g<name>`` will use the substring matched by the "
"group named ``name``, and  ``\\g<number>``  uses the corresponding group "
"number. ``\\g<2>`` is therefore equivalent to ``\\2``,  but isn't ambiguous "
"in a replacement string such as ``\\g<2>0``.  (``\\20`` would be interpreted "
"as a reference to group 20, not a reference to group 2 followed by the "
"literal character ``'0'``.)  The following substitutions are all equivalent, "
"but use all three variations of the replacement string. ::"
msgstr ""
"Il existe aussi une syntaxe pour faire référence aux groupes nommés définis "
"par la syntaxe ``(?P<nom>....)``. ``\\g<nom>`` utilise la sous-chaîne "
"correspondante au groupe nommé ``nom`` et ``\\g<numéro>`` utilise le numéro "
"de groupe correspondant. ``\\g<2>`` est donc l'équivalent de ``\\2``, mais "
"n'est pas ambigu dans une chaîne de substitution telle que ``\\g<2>0`` (``"
"\\20`` serait interprété comme une référence au groupe 20 et non comme une "
"référence au groupe 2 suivie du caractère littéral ``'0'``). Les "
"substitutions suivantes sont toutes équivalentes mais utilisent les trois "
"variantes de la chaîne de remplacement. ::"

#: ../Doc/howto/regex.rst:1185
msgid ""
"*replacement* can also be a function, which gives you even more control.  If "
"*replacement* is a function, the function is called for every non-"
"overlapping occurrence of *pattern*.  On each call, the function is passed "
"a :ref:`match object <match-objects>` argument for the match and can use "
"this information to compute the desired replacement string and return it."
msgstr ""
"*replacement* peut aussi être une fonction, ce qui vous donne encore plus de "
"contrôle. Si *replacement* est une fonction, la fonction est appelée pour "
"chaque occurrence non chevauchante de *pattern*. À chaque appel, un "
"argument :ref:`objet correspondance <match-objects>` est passé à la "
"fonction, qui peut utiliser cette information pour calculer la chaîne de "
"remplacement désirée et la renvoyer."

#: ../Doc/howto/regex.rst:1191
msgid ""
"In the following example, the replacement function translates decimals into "
"hexadecimal::"
msgstr ""
"Dans l'exemple suivant, la fonction de substitution convertit un nombre "
"décimal en hexadécimal ::"

#: ../Doc/howto/regex.rst:1203
msgid ""
"When using the module-level :func:`re.sub` function, the pattern is passed "
"as the first argument.  The pattern may be provided as an object or as a "
"string; if you need to specify regular expression flags, you must either use "
"a pattern object as the first parameter, or use embedded modifiers in the "
"pattern string, e.g. ``sub(\"(?i)b+\", \"x\", \"bbbb BBBB\")`` returns ``'x "
"x'``."
msgstr ""
"Quand vous utilisez la fonction de niveau module :func:`re.sub`, le motif "
"est passé comme premier argument. Vous pouvez fournir le motif sous forme "
"d'objet ou de chaîne de caractères ; si vous avez besoin de spécifier des "
"options pour l'expression régulière, vous devez soit utiliser un objet motif "
"comme premier paramètre, soit utiliser des modificateurs intégrés dans la "
"chaîne de caractères, par exemple ``sub(\"(?i)b+\", \"x\", \"bbbb BBBBB"
"\")```renvoie ``'x x'``."

#: ../Doc/howto/regex.rst:1211
msgid "Common Problems"
msgstr "Problèmes classiques"

#: ../Doc/howto/regex.rst:1213
msgid ""
"Regular expressions are a powerful tool for some applications, but in some "
"ways their behaviour isn't intuitive and at times they don't behave the way "
"you may expect them to.  This section will point out some of the most common "
"pitfalls."
msgstr ""
"Les expressions régulières constituent un outil puissant pour certaines "
"applications mais, à certains égards, leur comportement n'est pas intuitif "
"et, parfois, elles ne se comportent pas comme vous pouvez vous y attendre.  "
"Cette section met en évidence certains des pièges les plus courants."

#: ../Doc/howto/regex.rst:1219
msgid "Use String Methods"
msgstr "Utilisez les méthodes du type *string*"

#: ../Doc/howto/regex.rst:1221
msgid ""
"Sometimes using the :mod:`re` module is a mistake.  If you're matching a "
"fixed string, or a single character class, and you're not using any :mod:"
"`re` features such as the :const:`IGNORECASE` flag, then the full power of "
"regular expressions may not be required. Strings have several methods for "
"performing operations with fixed strings and they're usually much faster, "
"because the implementation is a single small C loop that's been optimized "
"for the purpose, instead of the large, more generalized regular expression "
"engine."
msgstr ""

#: ../Doc/howto/regex.rst:1229
msgid ""
"One example might be replacing a single fixed string with another one; for "
"example, you might replace ``word`` with ``deed``.  ``re.sub()`` seems like "
"the function to use for this, but consider the :meth:`replace` method.  Note "
"that :func:`replace` will also replace ``word`` inside words, turning "
"``swordfish`` into ``sdeedfish``, but the  naive RE ``word`` would have done "
"that, too.  (To avoid performing the substitution on parts of words, the "
"pattern would have to be ``\\bword\\b``, in order to require that ``word`` "
"have a word boundary on either side.  This takes the job beyond  :meth:"
"`replace`'s abilities.)"
msgstr ""

#: ../Doc/howto/regex.rst:1238
msgid ""
"Another common task is deleting every occurrence of a single character from "
"a string or replacing it with another single character.  You might do this "
"with something like ``re.sub('\\n', ' ', S)``, but :meth:`translate` is "
"capable of doing both tasks and will be faster than any regular expression "
"operation can be."
msgstr ""

#: ../Doc/howto/regex.rst:1244
msgid ""
"In short, before turning to the :mod:`re` module, consider whether your "
"problem can be solved with a faster and simpler string method."
msgstr ""
"Bref, avant de passer au module :mod:`re`, évaluez d'abord si votre problème "
"peut être résolu avec une méthode de chaîne plus rapide et plus simple."

#: ../Doc/howto/regex.rst:1249
msgid "match() versus search()"
msgstr "*match()* contre *search()*"

#: ../Doc/howto/regex.rst:1251
msgid ""
"The :func:`match` function only checks if the RE matches at the beginning of "
"the string while :func:`search` will scan forward through the string for a "
"match. It's important to keep this distinction in mind.  Remember,  :func:"
"`match` will only report a successful match which will start at 0; if the "
"match wouldn't start at zero,  :func:`match` will *not* report it. ::"
msgstr ""

#: ../Doc/howto/regex.rst:1262
msgid ""
"On the other hand, :func:`search` will scan forward through the string, "
"reporting the first match it finds. ::"
msgstr ""

#: ../Doc/howto/regex.rst:1270
msgid ""
"Sometimes you'll be tempted to keep using :func:`re.match`, and just add ``."
"*`` to the front of your RE.  Resist this temptation and use :func:`re."
"search` instead.  The regular expression compiler does some analysis of REs "
"in order to speed up the process of looking for a match.  One such analysis "
"figures out what the first character of a match must be; for example, a "
"pattern starting with ``Crow`` must match starting with a ``'C'``.  The "
"analysis lets the engine quickly scan through the string looking for the "
"starting character, only trying the full match if a ``'C'`` is found."
msgstr ""
"Vous pouvez être tenté d'utiliser :func:`re.match` en ajoutant simplement ``."
"*`` au début de votre RE. Ce n'est pas une bonne idée, utilisez plutôt :func:"
"`re.search`. Le compilateur d'expressions régulières analyse les REs pour "
"optimiser le processus de recherche d'une correspondance. Cette analyse "
"permet de déterminer ce que doit être le premier caractère d'une "
"correspondance ; par exemple, un motif commençant par ``Corbeau`` doit faire "
"correspondre un ``'C'`` en tête. L'analyse permet au moteur de parcourir "
"rapidement la chaîne de caractères à la recherche du caractère de départ, "
"n'essayant la correspondance complète que si un \"C\" a déjà été trouvé."

#: ../Doc/howto/regex.rst:1279
msgid ""
"Adding ``.*`` defeats this optimization, requiring scanning to the end of "
"the string and then backtracking to find a match for the rest of the RE.  "
"Use :func:`re.search` instead."
msgstr ""
"Ajouter ``.*`` annihile cette optimisation, nécessitant un balayage jusqu'à "
"la fin de la chaîne de caractères, puis un retour en arrière pour trouver "
"une correspondance pour le reste de la RE. Préférez l'utilisation :func:`re."
"search`."

#: ../Doc/howto/regex.rst:1285
msgid "Greedy versus Non-Greedy"
msgstr "Glouton contre non-glouton"

#: ../Doc/howto/regex.rst:1287
msgid ""
"When repeating a regular expression, as in ``a*``, the resulting action is "
"to consume as much of the pattern as possible.  This fact often bites you "
"when you're trying to match a pair of balanced delimiters, such as the angle "
"brackets surrounding an HTML tag.  The naive pattern for matching a single "
"HTML tag doesn't work because of the greedy nature of ``.*``. ::"
msgstr ""
"Si vous répétez un motif dans une expression régulière, comme ``a*``, "
"l'action résultante est de consommer autant de motifs que possible. C'est un "
"problème lorsque vous essayez de faire correspondre une paire de "
"délimiteurs, comme des chevrons encadrant une balise HTML. Le motif naïf "
"pour faire correspondre une seule balise HTML ne fonctionne pas en raison de "
"la nature gloutonne de ``.*``. ::"

#: ../Doc/howto/regex.rst:1301
msgid ""
"The RE matches the ``'<'`` in ``<html>``, and the ``.*`` consumes the rest "
"of the string.  There's still more left in the RE, though, and the ``>`` "
"can't match at the end of the string, so the regular expression engine has "
"to backtrack character by character until it finds a match for the ``>``.   "
"The final match extends from the ``'<'`` in ``<html>`` to the ``'>'`` in ``</"
"title>``, which isn't what you want."
msgstr ""

#: ../Doc/howto/regex.rst:1308
msgid ""
"In this case, the solution is to use the non-greedy qualifiers ``*?``, ``+?"
"``, ``??``, or ``{m,n}?``, which match as *little* text as possible.  In the "
"above example, the ``'>'`` is tried immediately after the first ``'<'`` "
"matches, and when it fails, the engine advances a character at a time, "
"retrying the ``'>'`` at every step.  This produces just the right result::"
msgstr ""
"Dans ce cas, la solution consiste à utiliser des quantificateurs non "
"gloutons tels que ``*?``, ``+?``, ``??`` ou ``{m,n}?``, qui effectuent une "
"correspondance aussi *petite* que possible. Dans l'exemple ci-dessus, le "
"``'>'`` est essayé immédiatement après que le ``'<'`` corresponde et, s'il "
"échoue, le moteur avance caractère par caractère, ré-essayant ``'>'`` à "
"chaque pas. Nous obtenons alors le bon résultat ::"

#: ../Doc/howto/regex.rst:1317
msgid ""
"(Note that parsing HTML or XML with regular expressions is painful. Quick-"
"and-dirty patterns will handle common cases, but HTML and XML have special "
"cases that will break the obvious regular expression; by the time you've "
"written a regular expression that handles all of the possible cases, the "
"patterns will be *very* complicated.  Use an HTML or XML parser module for "
"such tasks.)"
msgstr ""
"Note : l'analyse du HTML ou du XML avec des expressions régulières est tout "
"sauf une sinécure. Les motifs écrits à la va-vite traiteront les cas "
"communs, mais HTML et XML ont des cas spéciaux qui font planter l'expression "
"régulière évidente ; quand vous aurez écrit une expression régulière qui "
"traite tous les cas possibles, les motifs seront *très* compliqués.  "
"Utilisez un module d'analyse HTML ou XML pour de telles tâches."

#: ../Doc/howto/regex.rst:1325
msgid "Using re.VERBOSE"
msgstr "Utilisez *re.VERBOSE*"

#: ../Doc/howto/regex.rst:1327
msgid ""
"By now you've probably noticed that regular expressions are a very compact "
"notation, but they're not terribly readable.  REs of moderate complexity can "
"become lengthy collections of backslashes, parentheses, and metacharacters, "
"making them difficult to read and understand."
msgstr ""
"À présent, vous vous êtes rendu compte que les expressions régulières sont "
"une notation très compacte, mais qu'elles ne sont pas très lisibles. Une RE "
"modérément complexe  peut rapidement devenir une longue collection de barres "
"obliques inverses, de parenthèses et de métacaractères, ce qui la rend "
"difficile à lire et à comprendre."

#: ../Doc/howto/regex.rst:1332
msgid ""
"For such REs, specifying the ``re.VERBOSE`` flag when compiling the regular "
"expression can be helpful, because it allows you to format the regular "
"expression more clearly."
msgstr ""

#: ../Doc/howto/regex.rst:1336
msgid ""
"The ``re.VERBOSE`` flag has several effects.  Whitespace in the regular "
"expression that *isn't* inside a character class is ignored.  This means "
"that an expression such as ``dog | cat`` is equivalent to the less readable "
"``dog|cat``, but ``[a b]`` will still match the characters ``'a'``, ``'b'``, "
"or a space.  In addition, you can also put comments inside a RE; comments "
"extend from a ``#`` character to the next newline.  When used with triple-"
"quoted strings, this enables REs to be formatted more neatly::"
msgstr ""
"L'option ``re.VERBOSE`` a plusieurs effets. Les espaces dans l'expression "
"régulière qui *ne sont pas* à l'intérieur d'une classe de caractères sont "
"ignorées. Cela signifie qu'une expression comme ``chien | chat`` est "
"équivalente à ``chien|chat`` qui est moins lisible, mais ``[a b]`` "
"correspond toujours aux caractères ``'a'``, ``'b'`` ou à une espace. En "
"outre, vous avez la possibilité de mettre des commentaires à l'intérieur "
"d'une RE ; les commentaires s'étendent du caractère ``#`` à la nouvelle "
"ligne suivante. Lorsque vous l'utilisez avec des chaînes à triple "
"guillemets, cela permet aux RE d'être formatées plus proprement ::"

#: ../Doc/howto/regex.rst:1353
msgid "This is far more readable than::"
msgstr "Ceci est beaucoup plus lisible que::"

#: ../Doc/howto/regex.rst:1359
msgid "Feedback"
msgstr "Vos commentaires"

#: ../Doc/howto/regex.rst:1361
msgid ""
"Regular expressions are a complicated topic.  Did this document help you "
"understand them?  Were there parts that were unclear, or Problems you "
"encountered that weren't covered here?  If so, please send suggestions for "
"improvements to the author."
msgstr ""
"Les expressions régulières sont un sujet compliqué. Est-ce que ce document "
"vous a aidé à les comprendre ? Des parties ne sont pas claires, ou des "
"problèmes que vous avez rencontrés ne sont pas traités ici ? Si tel est le "
"cas, merci d'envoyer vos suggestions d'améliorations à l'auteur."

#: ../Doc/howto/regex.rst:1366
msgid ""
"The most complete book on regular expressions is almost certainly Jeffrey "
"Friedl's Mastering Regular Expressions, published by O'Reilly.  "
"Unfortunately, it exclusively concentrates on Perl and Java's flavours of "
"regular expressions, and doesn't contain any Python material at all, so it "
"won't be useful as a reference for programming in Python.  (The first "
"edition covered Python's now-removed :mod:`regex` module, which won't help "
"you much.)  Consider checking it out from your library."
msgstr ""

#: ../Doc/howto/regex.rst:1376
msgid "Footnotes"
msgstr "Notes"

#: ../Doc/howto/regex.rst:1377
msgid "Introduced in Python 2.2.2."
msgstr ""