"Let's create an extension module called ``spam`` (the favorite food of Monty "
"Python fans...) and let's say we want to create a Python interface to the C "
"library function :c:func:`system` [#]_. This function takes a null-"
"terminated character string as argument and returns an integer. We want "
"this function to be callable from Python as follows::"
msgstr ""
"Créons un module d'extension appelé ``spam`` (la nourriture préférée de fans "
"des Monty Python ...) et disons que nous voulons créer une interface Python "
"à la fonction de la bibliothèque C :c:func:`system`. [#]_ Cette fonction "
"prend une chaîne de caractères terminée par NULL comme argument et renvoie "
"un entier. Nous voulons que cette fonction soit appelable à partir de Python "
"comme suit : ::"
msgstr "Créons un module d'extension appelé ``spam`` (la nourriture préférée de fans des Monty Python ...) et disons que nous voulons créer une interface Python à la fonction de la bibliothèque C :c:func:`system` [#]_. Cette fonction prend une chaîne de caractères terminée par NULL comme argument et renvoie un entier. Nous voulons que cette fonction soit appelable à partir de Python comme suit : ::"
"Developer Studio will throw in a lot of import libraries that you do not "
"really need, adding about 100K to your executable. To get rid of them, use "
"the Project Settings dialog, Link tab, to specify *ignore default "
"libraries*. Add the correct :file:`msvcrtxx.lib` to the list of libraries."
msgstr ""
"Developer Studio apportera beaucoup de bibliothèques d'import dont vous "
"n'avez pas vraiment besoin, augmentant d'environ 100K votre exécutable. Pour "
"s'en débarasser, allez dans les Paramètres du Projet, onglet Lien, pour "
"préciser *ignorer les bibliothèques par défaut*. Et la :file:`msvcrtxx.lib` "
"correcte à la liste des bibliothèques."
msgstr "Developer Studio apportera beaucoup de bibliothèques d'import dont vous n'avez pas vraiment besoin, augmentant d'environ 100K votre exécutable. Pour s'en débarasser, allez dans les Paramètres du Projet, onglet Lien, pour préciser *ignorer les bibliothèques par défaut*. Et la :file:`msvcrtxx.lib` correcte à la liste des bibliothèques."
"`file objects <file object>`, and objects of any classes you define with an :"
"meth:`__iter__` method or with a :meth:`__getitem__` method that implements :"
"term:`Sequence` semantics."
msgstr ""
msgstr "Un objet capable de renvoyer ses éléments un à un. Pour lister quelques exemples d'itérables, on pourrait lister tout les types séquence (comme :class:`list`, :class:`str`, et :class:`tuple`), et quelques autres comme :class:`dict`, :term:`objets fichiers <objet fichier>`, ou tout objet de toute classe ayant une méthode :meth:`__iter__` ou :meth:`__getitem__` implémentant la sémantique des :term:`Sequence`."
#: ../Doc/glossary.rst:541
#, fuzzy
msgid ""
"Iterables can be used in a :keyword:`for` loop and in many other places "
"where a sequence is needed (:func:`zip`, :func:`map`, ...). When an "
@ -1291,22 +1290,7 @@ msgid ""
"``for`` statement does that automatically for you, creating a temporary "
"unnamed variable to hold the iterator for the duration of the loop. See "
"also :term:`iterator`, :term:`sequence`, and :term:`generator`."
msgstr ""
"Un objet capable de donner ses éléments un à un. Pour lister quelques "
"exemples d'itérables, on pourrait lister tout les types séquence (comme :"
"class:`list`, :class:`str`, et :class:`tuple`), et quelques autres comme :"
"class:`dict`, :term:`objets fichiers <objet fichier>`, ou tout objet de "
"toute classe ayant une méthode :meth:`__iter__` ou :meth:`__getitem__`. Les "
"itérables peuvent être utilisés dans des boucles :keyword:`for` ou tout "
"autre endroit où une séquence est requise (:func:`zip`, :func:`map`, ...). "
"Lorsqu'un itérable est passé comme argument à la fonction native :func:"
"`iter`, elle donnera un itérateur de cet itérable. Cet itérateur n'est "
"valable que pour une passe sur le jeu de valeurs. Lors de l'utilisation "
"d'itérables, il n'est habituellement pas nécessaire d'appeler :func:`iter` "
"ou de s'occuper d'objet itérateurs. L'instruction ``for`` fait ça "
"automatiquement pour vous, créant une variable temporaire anonyme pour "
"garder l'itérateur durant la boucle. Voir aussi :term:`itérateur`, :term:"
"`séquence`, et :term:`générateur`."
msgstr "Les itérables peuvent être utilisés dans des boucles :keyword:`for` ou tout autre endroit où une séquence est requise (:func:`zip`, :func:`map`, ...). Lorsqu'un itérable est passé comme argument à la fonction native :func:`iter`, elle donnera un itérateur de cet itérable. Cet itérateur n'est valable que pour une passe sur le jeu de valeurs. Lors de l'utilisation d'itérables, il n'est habituellement pas nécessaire d'appeler :func:`iter` ou de s'occuper d'objet itérateurs. L'instruction ``for`` fait ça automatiquement pour vous, créant une variable temporaire anonyme pour garder l'itérateur durant la boucle. Voir aussi :term:`itérateur`, :term:`séquence`, et :term:`générateur`."
"être utilisée à travers la fonction :func:`math.ceil`."
#: ../Doc/library/fractions.rst:161
#, fuzzy
msgid ""
"The first version returns the nearest :class:`int` to ``self``, rounding "
"half to even. The second version rounds ``self`` to the nearest multiple of "
"``Fraction(1, 10**ndigits)`` (logically, if ``ndigits`` is negative), again "
"rounding half toward even. This method can also be accessed through the :"
"func:`round` function."
msgstr ""
"La première version renvoie l':class:`int` le plus proche de ``self``, "
"arrondissant les demis au nombre pair le plus proche. La seconde version "
"arrondit ``self`` au plus proche multiple de ``Fraction(1, 10**ndigits)`` "
"(logiquement, si ``ndigits`` est négatif), arrondissant toujours les demis "
"au nombre pair le plus proche. Cette méthode peut aussi être utilisée à "
"travers la fonction :func:`round`."
msgstr "La première version renvoie l':class:`int` le plus proche de ``self``, arrondissant les demis au nombre pair le plus proche. La seconde version arrondit ``self`` au plus proche multiple de ``Fraction(1, 10**ndigits)`` (logiquement, si ``ndigits`` est négatif), arrondissant toujours les demis au nombre pair le plus proche. Cette méthode peut aussi être utilisée à via la fonction :func:`round`."
"Last-Translator: François Magimel <francois.magimel@alumni.enseeiht.fr>\n"
"Language-Team: \n"
"Language: fr\n"
@ -224,7 +224,6 @@ msgid "Class-based API"
msgstr "API basée sur les classes"
#: ../Doc/library/gettext.rst:135
#, fuzzy
msgid ""
"The class-based API of the :mod:`gettext` module gives you more flexibility "
"and greater convenience than the GNU :program:`gettext` API. It is the "
@ -233,15 +232,7 @@ msgid ""
"GNU :file:`.mo` format files, and has methods for returning strings. "
"Instances of this \"translations\" class can also install themselves in the "
"built-in namespace as the function :func:`_`."
msgstr ""
"L'API du module :mod:`gettext` basée sur les classes vous donne plus de "
"flexibilité et est plus pratique que l'API de GNU :program:`gettext`. Son "
"utilisation est recommandée pour localiser vos applications et modules "
"Python. :mod:`gettext` définit une classe \"translations\" qui analyse "
"syntaxiquement les fichiers au format GNU :file:`.mo`, et qui possède des "
"méthodes pour renvoyer des chaînes de caractères. Les instances de cette "
"classe \"translations\" peuvent également s'installer dans l'espace de noms "
"natif en tant que fonction :func:`_`."
msgstr "L'API du module :mod:`gettext` basée sur les classes vous donne plus de flexibilité et est plus pratique que l'API de GNU :program:`gettext`. Son utilisation est recommandée pour localiser vos applications et modules Python. :mod:`!gettext` définit une classe \"translations\" qui analyse syntaxiquement les fichiers au format GNU :file:`.mo`, et qui possède des méthodes pour renvoyer des chaînes de caractères. Les instances de cette classe \"translations\" peuvent également s'installer dans l'espace de noms natif en tant que fonction :func:`_`."
#: ../Doc/library/gettext.rst:146
msgid ""
@ -393,20 +384,13 @@ msgid "The :class:`NullTranslations` class"
msgstr "La classe :class:`NullTranslations`"
#: ../Doc/library/gettext.rst:218
#, fuzzy
msgid ""
"Translation classes are what actually implement the translation of original "
"source file message strings to translated message strings. The base class "
"used by all translation classes is :class:`NullTranslations`; this provides "
"the basic interface you can use to write your own specialized translation "
"classes. Here are the methods of :class:`!NullTranslations`:"
msgstr ""
"Les classes de traduction implémentent le fait de passer d'une chaîne de "
"caractères du fichier original à traduire à la traduction de celle-ci. La "
"classe de base utilisée est :class:`NullTranslations`. C'est l'interface de "
"base à utiliser lorsque vous souhaitez écrire vos propres classes "
"spécifiques à la traduction. Voici les méthodes de :class:"
"`NullTranslations`:"
msgstr "Les classes de traduction implémentent le fait de passer d'une chaîne de caractères du fichier original à traduire à la traduction de celle-ci. La classe de base utilisée est :class:`NullTranslations`. C'est l'interface de base à utiliser lorsque vous souhaitez écrire vos propres classes spécifiques à la traduction. Voici les méthodes de :class:`!NullTranslations`:"
#: ../Doc/library/gettext.rst:227
msgid ""
@ -445,37 +429,25 @@ msgstr ""
"substitution s'il ne peut fournir une traduction pour un message donné."
#: ../Doc/library/gettext.rst:250
#, fuzzy
msgid ""
"If a fallback has been set, forward :meth:`!gettext` to the fallback. "
"Otherwise, return *message*. Overridden in derived classes."
msgstr ""
"Si un objet de substitution a été défini, transmet :meth:`.gettext` à celui-"
"ci. Sinon, renvoie *message*. Surchargé dans les classes dérivées."
msgstr "Si un objet de substitution a été défini, transmet :meth:`!gettext` à celui-ci. Sinon, renvoie *message*. Surchargé dans les classes dérivées."
#: ../Doc/library/gettext.rst:256
#, fuzzy
msgid ""
"If a fallback has been set, forward :meth:`!ngettext` to the fallback. "
"Otherwise, return *singular* if *n* is 1; return *plural* otherwise. "
"Overridden in derived classes."
msgstr ""
"Si un objet de substitution a été défini, transmet :meth:`ngettext` à celui-"
msgstr "Si un objet de substitution a été défini, transmet :meth:`!ngettext` à celui-ci. Sinon, renvoie *singular* si *n* vaut 1, *plural* sinon. Surchargé dans les classes dérivées."
#: ../Doc/library/gettext.rst:264
#, fuzzy
msgid ""
"Equivalent to :meth:`.gettext` and :meth:`.ngettext`, but the translation is "
"returned as a byte string encoded in the preferred system encoding if no "
"encoding was explicitly set with :meth:`set_output_charset`. Overridden in "
"derived classes."
msgstr ""
"Équivalent de :meth:`.gettext` et :meth:`ngettext`, mais la traduction est "
"renvoyée sous la forme d'une chaîne d'octets, encodée avec l'encodage du "
"système si aucun autre n'a été défini avec :meth:`set_output_charset`. "
"Surchargé dans les classes dérivées."
msgstr "Équivalent de :meth:`.gettext` et :meth:`.ngettext`, mais la traduction est renvoyée sous la forme d'une chaîne d'octets, encodée avec l'encodage du système si aucun autre n'a été défini avec :meth:`set_output_charset`. Surchargé dans les classes dérivées."
"Both patterns and strings to be searched can be Unicode strings (:class:"
"`str`) as well as 8-bit strings (:class:`bytes`). However, Unicode strings "
@ -42,13 +41,7 @@ msgid ""
"string with a byte pattern or vice-versa; similarly, when asking for a "
"substitution, the replacement string must be of the same type as both the "
"pattern and the search string."
msgstr ""
"Motifs comme chaînes à analyser peuvent aussi bien être des chaînes Unicode "
"que des chaînes 8-bit. Cependant, chaînes Unicode et 8-bit ne peuvent pas "
"être mélangées: vous ne pouvez ainsi pas analyser une chaîne Unicode avec "
"un motif 8-bit, et inversement; similairement, lors d'une substitution, la "
"chaîne de remplacement doit être du même type que le motif et la chaîne "
"analysée."
msgstr "Motifs comme chaînes à analyser peuvent aussi bien être des chaînes Unicode (:class:`str`) que des chaînes d'octets (:class:`bytes`). Cependant, chaînes Unicode et 8-bit ne peuvent pas être mélangées: vous ne pouvez ainsi pas analyser une chaîne Unicode avec un motif 8-bit, et inversement; similairement, lors d'une substitution, la chaîne de remplacement doit être du même type que le motif et la chaîne analysée."
#: ../Doc/library/re.rst:24
msgid ""
@ -183,18 +176,11 @@ msgstr ""
"tester ``'entourées de simples guillemets'``.)"
#: ../Doc/library/re.rst:83
#, fuzzy
msgid ""
"Some characters, like ``'|'`` or ``'('``, are special. Special characters "
"either stand for classes of ordinary characters, or affect how the regular "
"expressions around them are interpreted."
msgstr ""
"Certains caractères, comme ``'|'`` ou ``'('``, sont spéciaux. Des caractères "
"spéciaux peuvent aussi exister pour les classes de caractères ordinaires, ou "
"affecter comment les expressions rationnelles autour d'eux seront "
"interprétées. Les motifs d'expressions rationnelles ne devraient pas "
"contenir de caractères nuls, mais peuvent spécifier le caractère nul en "
"utilisant une notation ``\\number`` comme ``\\x00``."
msgstr "Certains caractères, comme ``'|'`` ou ``'('``, sont spéciaux. Des caractères spéciaux peuvent aussi exister pour les classes de caractères ordinaires, ou affecter comment les expressions rationnelles autour d'eux seront interprétées."
#: ../Doc/library/re.rst:87
msgid ""
@ -311,7 +297,6 @@ msgid "``*?``, ``+?``, ``??``"
msgstr "``*?``, ``+?``, ``??``"
#: ../Doc/library/re.rst:129
#, fuzzy
msgid ""
"The ``'*'``, ``'+'``, and ``'?'`` qualifiers are all :dfn:`greedy`; they "
"match as much text as possible. Sometimes this behaviour isn't desired; if "
@ -320,15 +305,7 @@ msgid ""
"perform the match in :dfn:`non-greedy` or :dfn:`minimal` fashion; as *few* "
"characters as possible will be matched. Using the RE ``<.*?>`` will match "
"only ``'<a>'``."
msgstr ""
"Les qualificateurs ``'*'``, ``'+'`` et ``'?'`` sont tous :dfn:`greedy` "
"(gourmands); ils valident autant de texte que possible. Parfois ce "
"comportement n'est pas désiré; si l'expression rationnelle ``<.*>`` est "
"testée avec la chaîne ``<a> b <c>``, cela correspondra à la chaîne entière, "
"et non juste à ``<a>``. Ajouter ``?`` derrière le qualificateur lui fait "
"réaliser l'opération de façon :dfn:`non-greedy` (ou :dfn:`minimal`); le "
"*moins* de caractères possibles seront validés. Utiliser l'expression "
msgstr "Les qualificateurs ``'*'``, ``'+'`` et ``'?'`` sont tous :dfn:`greedy` (gourmands); ils valident autant de texte que possible. Parfois ce comportement n'est pas désiré; si l'expression rationnelle ``<.*>`` est testée avec la chaîne ``'<a> b <c>'``, cela correspondra à la chaîne entière, et non juste à ``'<a>'``. Ajouter ``?`` derrière le qualificateur lui fait réaliser l'opération de façon :dfn:`non-greedy` (ou :dfn:`minimal`); le *moins* de caractères possibles seront validés. Utiliser l'expression rationnelle ``<.*?>`` validera uniquement ``'<a>'``."
#: ../Doc/library/re.rst:140
msgid "``{m}``"
@ -350,7 +327,6 @@ msgid "``{m,n}``"
msgstr "``{m,n}``"
#: ../Doc/library/re.rst:143
#, fuzzy
msgid ""
"Causes the resulting RE to match from *m* to *n* repetitions of the "
"preceding RE, attempting to match as many repetitions as possible. For "
@ -360,15 +336,7 @@ msgid ""
"``'a'`` characters followed by a ``'b'``, but not ``'aaab'``. The comma may "
"not be omitted or the modifier would be confused with the previously "
"described form."
msgstr ""
"Implique à l'expression rationnelle résultante de valider entre *m* et *n* "
"répétitions de l'expression qui précède, cherchant à en valider le plus "
"possible. Par exemple, ``a{3,5}`` validera entre 3 et 5 caractères "
"``'a'``. Omettre *m* revient à spécifier 0 comme borne inférieure, et "
"omettre *n* à avoir une borne supérieure infinie. Par exemple, ``a{4,}b`` "
"correspondra à ``aaaab`` ou à un millier de caractères ``'a'`` suivis d'un "
"``b``, mais pas à ``aaab``. La virgule ne doit pas être omise, auquel cas le "
"modificateur serait confondu avec la forme décrite précédemment."
msgstr "Implique à l'expression rationnelle résultante de valider entre *m* et *n* répétitions de l'expression qui précède, cherchant à en valider le plus possible. Par exemple, ``a{3,5}`` validera entre 3 et 5 caractères ``'a'``. Omettre *m* revient à spécifier 0 comme borne inférieure, et omettre *n* à avoir une borne supérieure infinie. Par exemple, ``a{4,}b`` correspondra à ``'aaaab'`` ou à un millier de caractères ``'a'`` suivis d'un ``'b'``, mais pas à ``'aaab'``. La virgule ne doit pas être omise, auquel cas le modificateur serait confondu avec la forme décrite précédemment."
#: ../Doc/library/re.rst:156
msgid "``{m,n}?``"
@ -440,7 +408,6 @@ msgstr ""
"correspondra à ``'a'``, ``'m'`` ou ``'k'``."
#: ../Doc/library/re.rst:177
#, fuzzy
msgid ""
"Ranges of characters can be indicated by giving two characters and "
"separating them by a ``'-'``, for example ``[a-z]`` will match any lowercase "
@ -448,14 +415,7 @@ msgid ""
"``00`` to ``59``, and ``[0-9A-Fa-f]`` will match any hexadecimal digit. If "
"``-`` is escaped (e.g. ``[a\\-z]``) or if it's placed as the first or last "
"character (e.g. ``[-a]`` or ``[a-]``), it will match a literal ``'-'``."
msgstr ""
"Des intervalles de caractères peuvent être indiqués en donnant deux "
"caractères et les séparant par un ``'-'``, par exemple ``[a-z]`` "
"correspondra à toute lettre minuscule *ASCII*, ``[0-5][0-9]`` à tous nombres "
"de deux chiffres entre ``00` et ``59``, et ``[0-9A-Fa-f]`` correspondra à "
"n'importe quel chiffre hexadécimal. Si ``'-'`` est échappé (``[a\\-z]``) ou "
"s'il est placé comme premier ou dernier caractère (e.g. ``[a-]``), il "
"correspondra à un ``'-'`` littéral."
msgstr "Des intervalles de caractères peuvent être indiqués en donnant deux caractères et les séparant par un ``'-'``, par exemple ``[a-z]`` correspondra à toute lettre minuscule *ASCII*, ``[0-5][0-9]`` à tous nombres de deux chiffres entre ``00` et ``59``, et ``[0-9A-Fa-f]`` correspondra à n'importe quel chiffre hexadécimal. Si ``'-'`` est échappé (``[a\\-z]``) ou s'il est placé comme premier ou dernier caractère (e.g. ``[-a]`` ou ``[a-]``), il correspondra à un ``'-'`` littéral."
#: ../Doc/library/re.rst:184
msgid ""
@ -511,7 +471,6 @@ msgid "``|``"
msgstr ""
#: ../Doc/library/re.rst:204
#, fuzzy
msgid ""
"``A|B``, where *A* and *B* can be arbitrary REs, creates a regular "
"expression that will match either *A* or *B*. An arbitrary number of REs "
@ -522,25 +481,13 @@ msgid ""
"tested further, even if it would produce a longer overall match. In other "
"words, the ``'|'`` operator is never greedy. To match a literal ``'|'``, "
"use ``\\|``, or enclose it inside a character class, as in ``[|]``."
msgstr ""
"``A|B``, où A et B peuvent être deux expressions rationnelles arbitraires, "
"crée une expression rationnelle qui validera à la fois A et B. Un nombre "
"arbitraire d'expressions peuvent être séparées de cette façon par des "
"``'|'``. Cela peut aussi être utilisé au sein de groupes (voir ci-"
"dessous). Quand une chaîne cible est analysée, les expressions séparées par "
"``'|'`` sont essayées de la gauche vers la droite. Quand un motif correspond "
"complètement, cette branche est acceptée. Cela signifie qu'une fois que "
"``A`` correspond, ``B`` ne sera pas testée plus loin, même si elle pourrait "
"provoquer une plus ample correspondance. En d'autres termes, l'opérateur "
"``'|'`` n'est jamais gourmand. Pour valider un ``'|'`` littéral, utilisez ``"
"\\|``, ou enveloppez-le dans une classe de caractères, comme ``[|]``."
msgstr "``A|B``, où *A* et *B* peuvent être deux expressions rationnelles arbitraires, crée une expression rationnelle qui validera à la fois *A* et *B*. Un nombre arbitraire d'expressions peuvent être séparées de cette façon par des ``'|'``. Cela peut aussi être utilisé au sein de groupes (voir ci-dessous). Quand une chaîne cible est analysée, les expressions séparées par ``'|'`` sont essayées de la gauche vers la droite. Quand un motif correspond complètement, cette branche est acceptée. Cela signifie qu'une fois que *A* correspond, *B* ne sera pas testée plus loin, même si elle pourrait provoquer une plus ample correspondance. En d'autres termes, l'opérateur ``'|'`` n'est jamais gourmand. Pour valider un ``'|'`` littéral, utilisez ``\\|``, ou enveloppez-le dans une classe de caractères, comme ``[|]``."
#: ../Doc/library/re.rst:219
msgid "``(...)``"
msgstr "``(...)``"
#: ../Doc/library/re.rst:215
#, fuzzy
msgid ""
"Matches whatever regular expression is inside the parentheses, and indicates "
"the start and end of a group; the contents of a group can be retrieved after "
@ -548,14 +495,7 @@ msgid ""
"``\\number`` special sequence, described below. To match the literals "
"``'('`` or ``')'``, use ``\\(`` or ``\\)``, or enclose them inside a "
"character class: ``[(]``, ``[)]``."
msgstr ""
"Valide n'importe quelle expression rationnelle comprise entre les "
"parenthèses, et indique le début et la fin d'un groupe; le contenu d'un "
"groupe peut être récupéré après qu'une analyse a été effectuée, et peut être "
"réutilisé plus loin dans la chaîne avec une séquence spéciale ``\\number``, "
"décrite ci-dessous. Pour écrire des ``'('`` ou ``')'`` littéraux, utilisez "
"``\\(`` ou ``\\)``, ou enveloppez-les dans une classe de caractères: ``[(] "
"[)]``."
msgstr "Valide n'importe quelle expression rationnelle comprise entre les parenthèses, et indique le début et la fin d'un groupe; le contenu d'un groupe peut être récupéré après qu'une analyse a été effectuée, et peut être réutilisé plus loin dans la chaîne avec une séquence spéciale ``\\number``, décrite ci-dessous. Pour écrire des ``'('`` ou ``')'`` littéraux, utilisez ``\\(`` ou ``\\)``, ou enveloppez-les dans une classe de caractères: ``[(]``, ``[)]``."
#: ../Doc/library/re.rst:226
msgid "``(?...)``"
@ -580,7 +520,6 @@ msgid "``(?aiLmsux)``"
msgstr "``(?aiLmsux)``"
#: ../Doc/library/re.rst:229
#, fuzzy
msgid ""
"(One or more letters from the set ``'a'``, ``'i'``, ``'L'``, ``'m'``, "
"``'s'``, ``'u'``, ``'x'``.) The group matches the empty string; the letters "
@ -592,18 +531,7 @@ msgid ""
"to include the flags as part of the regular expression, instead of passing a "
"*flag* argument to the :func:`re.compile` function. Flags should be used "
"first in the expression string."
msgstr ""
"(Une lettre ou plus de l'ensemble ``'a'``, ``'i'``, ``'L'``, ``'m'``, "
"``'s'``, ``'u'``, ``'x'``.) Le groupe valide la chaîne vide; les lettres "
"activent les modes correspondant: :const:`re.A` (validation *ASCII* "
"seulement), :const:`re.I` (ignorer la casse)`, :const:`re.L` (dépendant de "
"la locale), :const:`re.M` (multi-ligne), :const:`re.S` (les points "
"correspondent à tous les caractères) et :const:`re.X` (verbeux), pour "
"l'ensemble de l'expression rationnelle. (Les options dans décrites dans la "
"section :ref:`contents-of-module-re`.) C'est utile si vous souhaitez "
"préciser l'option dans l'expression rationnelle, plutôt qu'en passant un "
"argument *flag* à la fonction :func:`re.compile`. Les options devraient "
"être spécifiées en premier dans la chaîne de l'expression."
msgstr "(Une lettre ou plus de l'ensemble ``'a'``, ``'i'``, ``'L'``, ``'m'``, ``'s'``, ``'u'``, ``'x'``.) Le groupe valide la chaîne vide; les lettres activent les modes correspondant: :const:`re.A` (validation *ASCII* seulement), :const:`re.I` (ignorer la casse)`, :const:`re.L` (dépendant de la locale), :const:`re.M` (multi-ligne), :const:`re.S` (les points correspondent à tous les caractères), :const:`re.U` (support d'Unicode) et :const:`re.X` (verbeux), pour l'ensemble de l'expression rationnelle. (Les options dans décrites dans la section :ref:`contents-of-module-re`.) C'est utile si vous souhaitez préciser l'option dans l'expression rationnelle, plutôt qu'en passant un argument *flag* à la fonction :func:`re.compile`. Les options devraient être spécifiées en premier dans la chaîne de l'expression."
msgid "in a string passed to the *repl* argument of ``re.sub()``"
msgstr "dans une chaîne passée à l'argument ``repl`` de ``re.sub()``"
msgstr "dans une chaîne passée à l'argument *repl* de ``re.sub()``"
#: ../Doc/library/re.rst:278
msgid "``\\g<quote>``"
@ -742,38 +668,28 @@ msgid "``(?=...)``"
msgstr "``(?=...)``"
#: ../Doc/library/re.rst:291
#, fuzzy
msgid ""
"Matches if ``...`` matches next, but doesn't consume any of the string. "
"This is called a :dfn:`lookahead assertion`. For example, ``Isaac (?"
"=Asimov)`` will match ``'Isaac '`` only if it's followed by ``'Asimov'``."
msgstr ""
"Valide si ``...`` valide la suite, mais ne consomme rien de la chaîne. On "
"appelle cela une assertion *lookahead*. Par exemple, ``Isaac (?=Asimov)`` "
"correspondra à la chaîne ``'Isaac'`` seulement si elle est suivie par "
"``'Asimov'``."
msgstr "Valide si ``...`` valide la suite, mais ne consomme rien de la chaîne. On appelle cela une assertion :dfn:`lookahead`. Par exemple, ``Isaac (?=Asimov)`` correspondra à la chaîne ``'Isaac' `` seulement si elle est suivie par ``'Asimov'``."
#: ../Doc/library/re.rst:298
msgid "``(?!...)``"
msgstr "``(?!...)``"
#: ../Doc/library/re.rst:296
#, fuzzy
msgid ""
"Matches if ``...`` doesn't match next. This is a :dfn:`negative lookahead "
"assertion`. For example, ``Isaac (?!Asimov)`` will match ``'Isaac '`` only "
"if it's *not* followed by ``'Asimov'``."
msgstr ""
"Valide si ``...`` ne valide pas la suite. C'est une assertion *lookahead* "
"négative. Par exemple, ``Isaac (?!Asimov)`` correspondra à la chaîne "
"``'Isaac'`` seulement si elle *n'est pas* suivie par ``'Asimov'``."
msgstr "Valide si ``...`` ne valide pas la suite. C'est une assertion :dfn:`negative lookahead`. Par exemple, ``Isaac (?!Asimov)`` correspondra à la chaîne ``'Isaac '`` seulement si elle *n'est pas* suivie par ``'Asimov'``."
#: ../Doc/library/re.rst:323
msgid "``(?<=...)``"
msgstr "``(?<=...)``"
#: ../Doc/library/re.rst:301
#, fuzzy
msgid ""
"Matches if the current position in the string is preceded by a match for "
"``...`` that ends at the current position. This is called a :dfn:`positive "
@ -785,18 +701,7 @@ msgid ""
"assertions will not match at the beginning of the string being searched; you "
"will most likely want to use the :func:`search` function rather than the :"
"func:`match` function:"
msgstr ""
"Valide si la position courante dans la chaîne est précédée par une "
"correspondance sur ``...`` qui se termine à la position courante. On "
"appelle cela une :dfn:`positive lookbehind assertion`. ``(?<=abc)def`` "
"cherchera une correspondance dans ``abcdef``, puisque le *lookbehind** "
"mettra de côté 3 caractères et vérifiera que le motif contenu correspond. "
"Le motif ne devra correspondre qu'à des chaînes de taille fixe, cela veut "
"dire que ``abc`` ou ``a|b` sont autorisées, mais pas ``a*`` ou ``a{3,4}``. "
"Notez que les motifs qui commencent par des assertions *lookbehind* "
"positives ne peuvent pas correspondre au début de la chaîne analysée; vous "
"préférerez sûrement utiliser la fonction :func:`search` plutôt que la "
"fonction :func:`match`:"
msgstr "Valide si la position courante dans la chaîne est précédée par une correspondance sur ``...`` qui se termine à la position courante. On appelle cela une :dfn:`positive lookbehind assertion`. ``(?<=abc)def`` cherchera une correspondance dans ``'abcdef'``, puisque le *lookbehind** mettra de côté 3 caractères et vérifiera que le motif contenu correspond. Le motif ne devra correspondre qu'à des chaînes de taille fixe, cela veut dire que ``abc`` ou ``a|b` sont autorisées, mais pas ``a*`` ou ``a{3,4}``. Notez que les motifs qui commencent par des assertions *lookbehind* positives ne peuvent pas correspondre au début de la chaîne analysée; vous préférerez sûrement utiliser la fonction :func:`search` plutôt que la fonction :func:`match`:"
#: ../Doc/library/re.rst:316
msgid "This example looks for a word following a hyphen:"
@ -896,7 +801,6 @@ msgid "``\\b``"
msgstr "``\\b``"
#: ../Doc/library/re.rst:360
#, fuzzy
msgid ""
"Matches the empty string, but only at the beginning or end of a word. A word "
"is defined as a sequence of word characters. Note that formally, ``\\b`` is "
@ -904,36 +808,22 @@ msgid ""
"versa), or between ``\\w`` and the beginning/end of the string. This means "
"Correspond à la chaîne vide, mais uniquement au début ou à la fin d'un mot. "
"Un mot est défini comme une séquence de caractères Unicode alphanumériques "
"ou de tirets bas, la fin d'un mot est ainsi indiquée par une espace ou un "
"caractère qui n'est ni alphanumérique ni un tiret bas. Notez que "
"formellement, ``\\b`` est défini comme la liaison entre ``\\w`` et ``\\W`` "
"(et inversement), ou entre ``\\w`` et le début/fin d'un mot. Cela signifie "
"que ``r'\\bfoo\\b'`` validera ``'foo'``, ``'foo.'``, ``'(foo)'`` ou ``'bar "
"foo baz'`` mais pas ``'foobar'`` ou ``'foo3'``."
msgstr "Correspond à la chaîne vide, mais uniquement au début ou à la fin d'un mot. Un mot est défini comme une séquence de \"caractères de mots\". Notez que formellement, ``\\b`` est défini comme la liaison entre ``\\w`` et ``\\W`` (et inversement), ou entre ``\\w`` et le début/fin d'un mot. Cela signifie que ``r'\\bfoo\\b'`` validera ``'foo'``, ``'foo.'``, ``'(foo)'`` ou ``'bar foo baz'`` mais pas ``'foobar'`` ou ``'foo3'``."
#: ../Doc/library/re.rst:367
#, fuzzy
msgid ""
"By default Unicode alphanumerics are the ones used in Unicode patterns, but "
"this can be changed by using the :const:`ASCII` flag. Word boundaries are "
"determined by the current locale if the :const:`LOCALE` flag is used. Inside "
"a character range, ``\\b`` represents the backspace character, for "
"compatibility with Python's string literals."
msgstr ""
"Les caractères alphanumériques Unicode sont utilisés par défaut, mais cela "
"peut être changé en utilisant l'option :const:`ASCII`. À l'intérieur d'un "
"intervalle de caractères, ``\\b`` représente le caractère *backspace*, par "
"compatibilité avec les chaînes littérales Python."
msgstr "Les caractères alphanumériques Unicode sont utilisés par défaut dans les motifs Unicode, mais cela peut être changé en utilisant l'option :const:`ASCII`. Les délimitations de mots sont déterminées par la locale courrante si l'option :const:`LOCALE` est utilisée. À l'intérieur d'un intervalle de caractères, ``\\b`` représente le caractère *backspace*, par compatibilité avec les chaînes littérales Python."
#: ../Doc/library/re.rst:380
msgid "``\\B``"
msgstr "``\\B``"
#: ../Doc/library/re.rst:374
#, fuzzy
msgid ""
"Matches the empty string, but only when it is *not* at the beginning or end "
"of a word. This means that ``r'py\\B'`` matches ``'python'``, ``'py3'``, "
@ -942,13 +832,7 @@ msgid ""
"alphanumerics or the underscore, although this can be changed by using the :"
"const:`ASCII` flag. Word boundaries are determined by the current locale if "
"the :const:`LOCALE` flag is used."
msgstr ""
"Correspond à la chaîne vide, mais uniquement quand elle *n'est pas* au début "
"ou à la fin d'un mot. Cela signifie que ``r'py\\B'`` valide ``'python'``, "
"``'py3'`` ou ``'py2'``, mais pas ``'py'``, ``'py.'`` ou ``'py!'``. ``\\B`` "
"est simplement l'opposé de ``\\b``, donc les caractères de mots sont les "
"alphanumériques et tirets bas Unicode, bien que cela puisse être changé avec "
"l'option :const:`ASCII`."
msgstr "Correspond à la chaîne vide, mais uniquement quand elle *n'est pas* au début ou à la fin d'un mot. Cela signifie que ``r'py\\B'`` valide ``'python'``, ``'py3'`` ou ``'py2'``, mais pas ``'py'``, ``'py.'`` ou ``'py!'``. ``\\B`` est simplement l'opposé de ``\\b``, donc les caractères de mots dans les motifs Unicode sont les alphanumériques et tirets bas Unicode, bien que cela puisse être changé avec l'option :const:`ASCII`. Les délimitations de mots sont déterminées par la locale courrante si l'option :const:`LOCALE` est utilisée."
#: ../Doc/library/re.rst:392
msgid "``\\d``"
@ -988,18 +872,12 @@ msgid "``\\D``"
msgstr "``\\D``"
#: ../Doc/library/re.rst:395
#, fuzzy
msgid ""
"Matches any character which is not a decimal digit. This is the opposite of "
"``\\d``. If the :const:`ASCII` flag is used this becomes the equivalent of "
"``[^0-9]`` (but the flag affects the entire regular expression, so in such "
"cases using an explicit ``[^0-9]`` may be a better choice)."
msgstr ""
"Valide tout caractère qui n'est pas un chiffre décimal Unicode. C'est "
"l'opposé de ``\\d``. Si l'option :const:`ASCII` est utilisée, cela devient "
"équivalent à ``[^0-9]`` (mais l'option affectant l'expression rationnelle "
"entière, il peut être préférable dans ce genre de cas d'utiliser un "
"``[^0-9]`` explicite)."
msgstr "Valide tout caractère qui n'est pas un chiffre décimal. C'est l'opposé de ``\\d``. Si l'option :const:`ASCII` est utilisée, cela devient équivalent à ``[^0-9]`` (mais l'option affectant l'expression rationnelle entière, il peut être préférable dans ce genre de cas d'utiliser explicitement ``[^0-9]``)."
#: ../Doc/library/re.rst:413
msgid "``\\s``"
@ -1035,19 +913,13 @@ msgid "``\\S``"
msgstr "``\\S``"
#: ../Doc/library/re.rst:416
#, fuzzy
msgid ""
"Matches any character which is not a whitespace character. This is the "
"opposite of ``\\s``. If the :const:`ASCII` flag is used this becomes the "
"equivalent of ``[^ \\t\\n\\r\\f\\v]`` (but the flag affects the entire "
"regular expression, so in such cases using an explicit ``[^ \\t\\n\\r\\f"
"\\v]`` may be a better choice)."
msgstr ""
"Valide tout caractère qui n'est pas un caractère d'espacement Unicode. c'est "
"l'opposé de ``\\s``. Si l'option :const:`ASCII` est utilisée, cela devient "
"équivalent à ``[^ \\t\\n\\r\\f\\v]`` (mais l'option affectant l'expression "
"rationnelle entière, il peut être préférable dans ce genre de cas d'utiliser "
"un ``[^ \\t\\n\\r\\f\\v]`` explicite)."
msgstr "Valide tout caractère qui n'est pas un caractère d'espacement. c'est l'opposé de ``\\s``. Si l'option :const:`ASCII` est utilisée, cela devient équivalent à ``[^ \\t\\n\\r\\f\\v]`` (mais l'option affectant l'expression rationnelle entière, il peut être préférable dans ce genre de cas d'utiliser un ``[^ \\t\\n\\r\\f\\v]`` explicite)."
#: ../Doc/library/re.rst:435
msgid "``\\w``"
@ -1069,22 +941,18 @@ msgstr ""
"dans ce genre de cas d'utiliser un ``[a-zA-Z0-9_]`` explicite)."
#: ../Doc/library/re.rst:432
#, fuzzy
msgid ""
"Matches characters considered alphanumeric in the ASCII character set; this "
"is equivalent to ``[a-zA-Z0-9_]``. If the :const:`LOCALE` flag is used, "
"matches characters considered alphanumeric in the current locale and the "
"underscore."
msgstr ""
"Valide les caractères alphanumériques de la table ASCII; équivalent à ``[a-"
"zA-Z0-9_]``."
msgstr "Valide les caractères alphanumériques de la table ASCII; équivalent à ``[a-zA-Z0-9_]``. Si l'option :const:`LOCALE` est utilisée, les caractères considérés alphanumériques dans la locale courrante et le tiret bas seront acceptés."
#: ../Doc/library/re.rst:444
msgid "``\\W``"
msgstr "``\\W``"
#: ../Doc/library/re.rst:438
#, fuzzy
msgid ""
"Matches any character which is not a word character. This is the opposite of "
"``\\w``. If the :const:`ASCII` flag is used this becomes the equivalent of "
@ -1092,12 +960,7 @@ msgid ""
"such cases using an explicit ``[^a-zA-Z0-9_]`` may be a better choice). If "
"the :const:`LOCALE` flag is used, matches characters considered alphanumeric "
"in the current locale and the underscore."
msgstr ""
"Valide tout caractère qui n'est pas un caractère Unicode de mot. C'est "
"l'opposé de ``\\w``. Si l'option :const:`ASCII` est utilisée, cela devient "
"équivalent à ``[^a-zA-Z0-9_]`` (mais l'option affectant l'expression "
"rationnelle entière, il peut être préférable dans ce genre de cas d'utiliser "
"un ``[^a-zA-Z0-9_]`` explicite)."
msgstr "Valide tout caractère qui n'est pas un caractère de mot. C'est l'opposé de ``\\w``. Si l'option :const:`ASCII` est utilisée, cela devient équivalent à ``[^a-zA-Z0-9_]`` (mais l'option affectant l'expression rationnelle entière, il peut être préférable dans ce genre de cas d'utiliser un ``[^a-zA-Z0-9_]`` explicite). Si l'option :const:`LOCALE` est utilisée, les caractères considérés alphanumériques dans la locale courrante, et le tiret bas, seront acceptés."
#: ../Doc/library/re.rst:447
msgid "``\\Z``"
@ -1125,14 +988,10 @@ msgstr ""
"caractères.)"
#: ../Doc/library/re.rst:459
#, fuzzy
msgid ""
"``'\\u'`` and ``'\\U'`` escape sequences are only recognized in Unicode "
"patterns. In bytes patterns they are errors."
msgstr ""
"Les séquences d'échappement ``'\\u'`` et ``'\\U'`` sont seulement reconnues "
"dans les motifs Unicode. Aucun traitement spécifique ne leur est porté dans "
"les motifs 8-bit."
msgstr "Les séquences d'échappement ``'\\u'`` et ``'\\U'`` sont seulement reconnues dans les motifs Unicode. Dans les motifs de *byte*, ce sont des erreurs."
#: ../Doc/library/re.rst:462
msgid ""
@ -1248,16 +1107,12 @@ msgstr ""
"temps n'ont pas à s'inquiéter de la compilation de ces expressions."
#: ../Doc/library/re.rst:532
#, fuzzy
msgid ""
"Make ``\\w``, ``\\W``, ``\\b``, ``\\B``, ``\\d``, ``\\D``, ``\\s`` and ``"
"\\S`` perform ASCII-only matching instead of full Unicode matching. This is "
"only meaningful for Unicode patterns, and is ignored for byte patterns. "
"Corresponds to the inline flag ``(?a)``."
msgstr ""
"Fait correspondre à ``\\w``, ``\\W``, ``\\b``, ``\\B``, ``\\d``, ``\\D``, ``"
"\\s`` et ``\\s`` des caractères ASCII seulement, plutôt qu'Unicode. Cela "
"n'a du sens que pour les motifs Unicode, et est ignoré pour les motifs 8-bit."
msgstr "Fait correspondre à ``\\w``, ``\\W``, ``\\b``, ``\\B``, ``\\d``, ``\\D``, ``\\s`` et ``\\s`` des caractères ASCII seulement, plutôt qu'Unicode. Cela n'a du sens que pour les motifs Unicode, et est ignoré pour les motifs 8-bit. Correspond à l'option en ligne ``(?a)``."
#: ../Doc/library/re.rst:537
msgid ""
@ -1273,14 +1128,12 @@ msgstr ""
"(et que l'analyse Unicode n'est pas permise pour les chaînes 8-bit)."
#: ../Doc/library/re.rst:546
#, fuzzy
msgid ""
"Display debug information about compiled expression. No corresponding inline "
"flag."
msgstr "Affiche des informations de debug à propos de l'expression compilée."
msgstr "Affiche des informations de debug à propos de l'expression compilée. N'a pas d'option en ligne équivalente."
#: ../Doc/library/re.rst:553
#, fuzzy
msgid ""
"Perform case-insensitive matching; expressions like ``[A-Z]`` will also "
"match lowercase letters. Full Unicode matching (such as ``Ü`` matching "
@ -1288,12 +1141,7 @@ msgid ""
"ASCII matches. The current locale does not change the effect of this flag "
"unless the :const:`re.LOCALE` flag is also used. Corresponds to the inline "
"flag ``(?i)``."
msgstr ""
"Effectue une analyse indépendante de la casse. Les motifs tels que ``[A-Z]`` "
"accepteront donc les caractères minuscules. La locale courante n'affecte pas "
"cette option. Les correspondances Unicode (telles que ``Ü`` correspondant à "
"``ü``) fonctionnent aussi, sauf si l'option :const:`re.ASCII` est utilisée "
"pour désactiver explicitement les correspondances non-ASCII."
msgstr "Effectue une analyse indépendante de la casse. Les motifs tels que ``[A-Z]`` accepteront donc les caractères minuscules. L'analyse Unicode complète (tel que ``Ü`` correspondant à ``ü``) fonctionne aussi, tant que l'option :const:`re.ASCII` n'est pas utilisée. La locale courrante n'affecte pas cette option, tant que l'option :const:`re.LOCALE` n'est pas utilisée. Correspond au flag en ligne ``(?i)``."
#: ../Doc/library/re.rst:560
msgid ""
@ -1308,7 +1156,6 @@ msgid ""
msgstr ""
#: ../Doc/library/re.rst:573
#, fuzzy
msgid ""
"Make ``\\w``, ``\\W``, ``\\b``, ``\\B`` and case-insensitive matching "
"dependent on the current locale. This flag can be used only with bytes "
@ -1317,13 +1164,7 @@ msgid ""
"works with 8-bit locales. Unicode matching is already enabled by default in "
"Python 3 for Unicode (str) patterns, and it is able to handle different "
"locales/languages. Corresponds to the inline flag ``(?L)``."
msgstr ""
"Fait dépendre ``\\w``, ``\\W``, ``\\b``, ``\\B``, ``\\s`` et ``\\S`` de la "
"locale courante. L'utilisation de cette option est déconseillée à cause du "
"mécanisme de locale très peu fiable, et ne gérant qu'une «culture» à la "
"fois; vous devriez à la place utiliser l'analyse Unicode, qui est le défaut "
"en Python 3 pour les motifs Unicode (str). Cette option ne peut être "
"utilisée qu'avec les motifs 8-bit."
msgstr "Fait dépendre de la locale courante : ``\\w``, ``\\W``, ``\\b``, ``\\B``, et l'analyse insensible à la casse. Cette option peut être utilisée avec les modifs en *bytes*. L'utilisation de cette option est déconseillée à cause du mécanisme de locale très peu fiable, et ne gérant qu'une «culture» à la fois, et ne fonctionnant que pour les locales 8-bits. L'analyse Unicode est déjà activée par défaut dans Python 3 pour les motifs Unicode (*str*), et elle est capable de gérer plusieurs locales et langages. Correpond à l'option en ligne ``(?L)``."
#: ../Doc/library/re.rst:582
msgid ""
@ -1334,7 +1175,6 @@ msgstr ""
"pas compatible avec :const:`re.ASCII`."
#: ../Doc/library/re.rst:590
#, fuzzy
msgid ""
"When specified, the pattern character ``'^'`` matches at the beginning of "
"the string and at the beginning of each line (immediately following each "
@ -1343,27 +1183,16 @@ msgid ""
"default, ``'^'`` matches only at the beginning of the string, and ``'$'`` "
"only at the end of the string and immediately before the newline (if any) at "
"the end of the string. Corresponds to the inline flag ``(?m)``."
msgstr ""
"Quand spécifiée, le caractère ``'^'`` correspond au début d'une chaîne et au "
"début d'une ligne (caractère suivant directement le saut de ligne); et le "
"caractère ``'$'`` correspond à la fin d'une chaîne et à la fin d'une ligne "
"(juste avant le saut de ligne). Par défaut, ``'^'`` correspond uniquement "
"au début de la chaîne, et ``'$'`` uniquement à la fin de la chaîne, ou "
"immédiatement avant le saut de ligne (s'il y a) à la fin de la chaîne."
msgstr "Quand spécifiée, le caractère ``'^'`` correspond au début d'une chaîne et au début d'une ligne (caractère suivant directement le saut de ligne); et le caractère ``'$'`` correspond à la fin d'une chaîne et à la fin d'une ligne (juste avant le saut de ligne). Par défaut, ``'^'`` correspond uniquement au début de la chaîne, et ``'$'`` uniquement à la fin de la chaîne, ou immédiatement avant le saut de ligne (s'il y a) à la fin de la chaîne. Correspond à l'option en ligne ``(?m)``."
#: ../Doc/library/re.rst:602
#, fuzzy
msgid ""
"Make the ``'.'`` special character match any character at all, including a "
"newline; without this flag, ``'.'`` will match anything *except* a newline. "
"Corresponds to the inline flag ``(?s)``."
msgstr ""
"Fait correspondre tous les caractères possibles à ``'.'``, incluant le saut "
"de ligne; sans cette option, ``'.'`` correspondrait à tout caractère à "
"l'exception du saut de ligne."
msgstr "Fait correspondre tous les caractères possibles à ``'.'``, incluant le saut de ligne; sans cette option, ``'.'`` correspondrait à tout caractère à l'exception du saut de ligne. Correspond à l'option en ligne ``(?s)``."
#: ../Doc/library/re.rst:610
#, fuzzy
msgid ""
"This flag allows you to write regular expressions that look nicer and are "
"more readable by allowing you to visually separate logical sections of the "
@ -1373,15 +1202,7 @@ msgid ""
"``#`` that is not in a character class and is not preceded by an unescaped "
"backslash, all characters from the leftmost such ``#`` through the end of "
"the line are ignored."
msgstr ""
"Cette option vous autorise à écrire des expressions rationnelles qui "
"présentent mieux et sont plus lisibles en vous permettant de séparer "
"visuellement les sections logiques du motif et d'ajouter des commentaires. "
"Les caractères d'espacement à l'intérieur du motif sont ignorés, sauf à "
"l'intérieur des classes de caractères ou quand précédés d'un *backslash* non "
"échappé. Quand une ligne contient un ``#`` qui n'est pas dans une classe de "
"caractères ou précédé d'un *backslash* non échappé, tous les caractères "
"depuis le ``#`` le plus à gauche jusqu'à la fin de la ligne sont ignorés."
msgstr "Cette option vous autorise à écrire des expressions rationnelles qui présentent mieux et sont plus lisibles en vous permettant de séparer visuellement les sections logiques du motif et d'ajouter des commentaires. Les caractères d'espacement à l'intérieur du motif sont ignorés, sauf à l'intérieur des classes de caractères ou quand précédés d'un *backslash* non échappé, ou dans des séquences comme ``*?``, ``(?:`` or ``(?P<...>``. Quand une ligne contient un ``#`` qui n'est pas dans une classe de caractères ou précédé d'un *backslash* non échappé, tous les caractères depuis le ``#`` le plus à gauche jusqu'à la fin de la ligne sont ignorés."
#: ../Doc/library/re.rst:619
msgid ""
@ -1466,15 +1287,11 @@ msgstr ""
"de la liste. : ::"
#: ../Doc/library/re.rst:680
#, fuzzy
msgid ""
"If there are capturing groups in the separator and it matches at the start "
"of the string, the result will start with an empty string. The same holds "
"for the end of the string::"
msgstr ""
"S'il y a des groupes capturants dans le séparateur et qu'ils trouvent une "
"correspondance au début de la chaîne, le résultat commencera par une chaîne "
"vide. La même chose se produit pour la fin de la chaîne:"
msgstr "S'il y a des groupes capturants dans le séparateur et qu'ils trouvent une correspondance au début de la chaîne, le résultat commencera par une chaîne vide. La même chose se produit pour la fin de la chaîne::"
#: ../Doc/library/re.rst:687
msgid ""
@ -1485,13 +1302,10 @@ msgstr ""
"relatifs dans la liste résultante."
#: ../Doc/library/re.rst:692
#, fuzzy
msgid ""
":func:`split` doesn't currently split a string on an empty pattern match. "
"For example::"
msgstr ""
":func:`split` ne sépare actuellement pas une chaîne sur une correspondance "
"vide. Par exemple:"
msgstr ":func:`split` ne sépare actuellement pas une chaîne sur une correspondance vide. Par exemple::"
#: ../Doc/library/re.rst:698
msgid ""
@ -1568,7 +1382,6 @@ msgstr ""
"dans le résultat sauf si elles touchent le début d'une autre correspondance."
#: ../Doc/library/re.rst:743
#, fuzzy
msgid ""
"Return the string obtained by replacing the leftmost non-overlapping "
"occurrences of *pattern* in *string* by the replacement *repl*. If the "
@ -1578,34 +1391,18 @@ msgid ""
"\\r`` is converted to a carriage return, and so forth. Unknown escapes such "
"as ``\\&`` are left alone. Backreferences, such as ``\\6``, are replaced "
"with the substring matched by group 6 in the pattern. For example::"
msgstr ""
"Renvoie la chaîne obtenue en remplaçant les occurrences (sans chevauchement) "
"les plus à gauche de *pattern* dans *string* par le remplacement *repl*. Si "
"le motif n'est pas trouvé, *string* est renvoyée inchangée. *repl* peut "
"être une chaîne de caractères ou une fonction; si c'est une chaîne, toutes "
"les séquences d'échappement qu'elle contient sont traduites. Ainsi, ``\\n`` "
"est convertie en un simple saut de ligne, ``\\r`` en un retour chariot, et "
"ainsi de suite. Les séquences inconnues telles que ``\\&`` sont laissées "
"intactes. Les références arrières, telles que ``\\6``, sont remplacées par "
"la sous-chaîne correspondant au groupe 6 dans le motif. Par exemple:"
msgstr "Renvoie la chaîne obtenue en remplaçant les occurrences (sans chevauchement) les plus à gauche de *pattern* dans *string* par le remplacement *repl*. Si le motif n'est pas trouvé, *string* est renvoyée inchangée. *repl* peut être une chaîne de caractères ou une fonction; si c'est une chaîne, toutes les séquences d'échappement qu'elle contient sont traduites. Ainsi, ``\\n`` est convertie en un simple saut de ligne, ``\\r`` en un retour chariot, et ainsi de suite. Les séquences inconnues telles que ``\\&`` sont laissées intactes. Les références arrières, telles que ``\\6``, sont remplacées par la sous-chaîne correspondant au groupe 6 dans le motif. Par exemple::"
#: ../Doc/library/re.rst:757
#, fuzzy
msgid ""
"If *repl* is a function, it is called for every non-overlapping occurrence "
"of *pattern*. The function takes a single :ref:`match object <match-"
"objects>` argument, and returns the replacement string. For example::"
msgstr ""
"Si *repl* est une fonction, elle est appelée pour chaque occurrence non "
"chevauchante de *pattern*. La fonction prend comme argument un objet de "
"correspondance, et renvoie la chaîne de remplacement. Par exemple:"
msgstr "Si *repl* est une fonction, elle est appelée pour chaque occurrence non chevauchante de *pattern*. La fonction prend comme argument un :ref:`objet de correspondance <match-objects>`, et renvoie la chaîne de remplacement. Par exemple::"
#: ../Doc/library/re.rst:769
#, fuzzy
msgid "The pattern may be a string or a :ref:`pattern object <re-objects>`."
msgstr ""
"Le motif peut être une chaîne de caractères ou un objet expression "
"rationnelle."
msgstr "Le motif peut être une chaîne de caractères ou un :ref:`objet expression rationnelle <re-objects>`."
#: ../Doc/library/re.rst:771
msgid ""
@ -1791,7 +1588,6 @@ msgstr ""
"un saut de ligne, mais pas nécessairement à l'index où la recherche commence."
#: ../Doc/library/re.rst:901
#, fuzzy
msgid ""
"The optional parameter *endpos* limits how far the string will be searched; "
"it will be as if the string is *endpos* characters long, so only the "
@ -1799,14 +1595,7 @@ msgid ""
"*endpos* is less than *pos*, no match will be found; otherwise, if *rx* is a "
"compiled regular expression object, ``rx.search(string, 0, 50)`` is "
"equivalent to ``rx.search(string[:50], 0)``. ::"
msgstr ""
"Le paramètre optionnel *endpos* limite la longueur sur laquelle la chaîne "
"sera analysée; ce sera comme si la chaîne faisait *endpos* caractères de "
"long, donc uniquement les caractères de *pos* à ``endpos - 1`` seront "
"analysés pour trouver une correspondance. Si *endpos* est inférieur à "
"*pos*, aucune correspondance ne sera trouvée; dit autrement, avec *rx* une "
"expression rationnelle compilée, ``rx.search(string, 0, 50)`` est équivalent "
"à ``rx.search(string[:50], 0)``."
msgstr "Le paramètre optionnel *endpos* limite la longueur sur laquelle la chaîne sera analysée; ce sera comme si la chaîne faisait *endpos* caractères de long, donc uniquement les caractères de *pos* à ``endpos - 1`` seront analysés pour trouver une correspondance. Si *endpos* est inférieur à *pos*, aucune correspondance ne sera trouvée; dit autrement, avec *rx* une expression rationnelle compilée, ``rx.search(string, 0, 50)`` est équivalent à ``rx.search(string[:50], 0)``. ::"
#: ../Doc/library/re.rst:916
msgid ""
@ -1821,13 +1610,10 @@ msgstr ""
"notez que cela est différent d'une correspondance vide."
"The optional *pos* and *endpos* parameters have the same meaning as for the :"
"meth:`~regex.search` method. ::"
msgstr ""
"Les paramètres optionnels *pos* et *endpos* ont le même sens que pour la "
"méthode :meth:`~regex.search`."
msgstr "Les paramètres optionnels *pos* et *endpos* ont le même sens que pour la méthode :meth:`~regex.search`. ::"
#: ../Doc/library/re.rst:929
msgid ""
@ -1854,26 +1640,18 @@ msgid "Identical to the :func:`split` function, using the compiled pattern."
msgstr "Identique à la fonction :func:`split`, en utilisant le motif compilé."
#: ../Doc/library/re.rst:958
#, fuzzy
msgid ""
"Similar to the :func:`findall` function, using the compiled pattern, but "
"also accepts optional *pos* and *endpos* parameters that limit the search "
"region like for :meth:`search`."
msgstr ""
"Similaire à la fonction :func:`findall`, en utilisant le motif compilé, mais "
"accepte aussi des paramètres *pos* et *endpos* optionnels qui limitent la "
"région de recherche comme pour :meth:`match`."
msgstr "Similaire à la fonction :func:`findall`, en utilisant le motif compilé, mais accepte aussi des paramètres *pos* et *endpos* optionnels qui limitent la région de recherche comme pour :meth:`search`."
#: ../Doc/library/re.rst:965
#, fuzzy
msgid ""
"Similar to the :func:`finditer` function, using the compiled pattern, but "
"also accepts optional *pos* and *endpos* parameters that limit the search "
"region like for :meth:`search`."
msgstr ""
"Similaire à la fonction :func:`finditer`, en utilisant le motif compilé, "
"mais accepte aussi des paramètres *pos* et *endpos* optionnels qui limitent "
"la région de recherche comme pour :meth:`match`."
msgstr "Similaire à la fonction :func:`finditer`, en utilisant le motif compilé, mais accepte aussi des paramètres *pos* et *endpos* optionnels qui limitent la région de recherche comme pour :meth:`search`."
#: ../Doc/library/re.rst:972
msgid "Identical to the :func:`sub` function, using the compiled pattern."
@ -1950,7 +1728,6 @@ msgstr ""
"correspondant."
#: ../Doc/library/re.rst:1035
#, fuzzy
msgid ""
"Returns one or more subgroups of the match. If there is a single argument, "
"the result is a single string; if there are multiple arguments, the result "
@ -1963,19 +1740,7 @@ msgid ""
"raised. If a group is contained in a part of the pattern that did not match, "
"the corresponding result is ``None``. If a group is contained in a part of "
"the pattern that matched multiple times, the last match is returned. ::"
msgstr ""
"Renvoie un ou plus sous-groupes de la correspondance. Si un seul argument "
"est donné, le résultat est une chaîne simple; s'il y a plusieurs arguments, "
"le résultat est un *tuple* comprenant un élément par argument. Sans "
"arguments, *group1* vaut par défaut zéro (la correspondance entière est "
"renvoyée). Si un argument *groupN* vaut zéro, l'élément associé sera la "
"chaîne de correspondance entière; s'il est dans l'intervalle fermé [1..99], "
"c'est la correspondance avec le groupe de parenthèses associé. Si un numéro "
"de groupe est négatif ou supérieur au nombre de groupes définis dans le "
"motif, une exception :exc:`indexError` est levée. Si un groupe est contenu "
"dans une partie du motif qui n'a aucune correspondance, l'élément associé "
"sera ``None``. Si un groupe est contenu dans une partie du motif qui a "
"plusieurs correspondances, seule la dernière correspondance est renvoyée."
msgstr "Renvoie un ou plus sous-groupes de la correspondance. Si un seul argument est donné, le résultat est une chaîne simple; s'il y a plusieurs arguments, le résultat est un *tuple* comprenant un élément par argument. Sans arguments, *group1* vaut par défaut zéro (la correspondance entière est renvoyée). Si un argument *groupN* vaut zéro, l'élément associé sera la chaîne de correspondance entière; s'il est dans l'intervalle fermé [1..99], c'est la correspondance avec le groupe de parenthèses associé. Si un numéro de groupe est négatif ou supérieur au nombre de groupes définis dans le motif, une exception :exc:`indexError` est levée. Si un groupe est contenu dans une partie du motif qui n'a aucune correspondance, l'élément associé sera ``None``. Si un groupe est contenu dans une partie du motif qui a plusieurs correspondances, seule la dernière correspondance est renvoyée. ::"
#: ../Doc/library/re.rst:1057
msgid ""
@ -1990,29 +1755,22 @@ msgstr ""
"comme nom de groupe dans le motif, une exception :exc:`IndexError` est levée."
#: ../Doc/library/re.rst:1062
#, fuzzy
msgid "A moderately complicated example::"
msgstr "Un exemple modérément compliqué:"
msgstr "Un exemple modérément compliqué::"
#: ../Doc/library/re.rst:1070
#, fuzzy
msgid "Named groups can also be referred to by their index::"
msgstr "Les groupes nommés peuvent aussi être référencés par leur index:"
msgstr "Les groupes nommés peuvent aussi être référencés par leur index::"
#: ../Doc/library/re.rst:1077
#, fuzzy
msgid "If a group matches multiple times, only the last match is accessible::"
msgstr ""
"Si un groupe a plusieurs correspondances, seule la dernière est accessible:"
msgstr "Si un groupe a plusieurs correspondances, seule la dernière est accessible::"
#: ../Doc/library/re.rst:1086
#, fuzzy
msgid ""
"This is identical to ``m.group(g)``. This allows easier access to an "
"individual group from a match::"
msgstr ""
"Cela est identique à ``m.group(g)``. Cela permet un accès plus facile à un "
"groupe individuel depuis une correspondance:"
msgstr "Cela est identique à ``m.group(g)``. Cela permet un accès plus facile à un groupe individuel depuis une correspondance::"
#: ../Doc/library/re.rst:1102
msgid ""
@ -2029,28 +1787,18 @@ msgid "For example::"
msgstr "Par exemple : ::"
#: ../Doc/library/re.rst:1112
#, fuzzy
msgid ""
"If we make the decimal place and everything after it optional, not all "
"groups might participate in the match. These groups will default to "
"``None`` unless the *default* argument is given::"
msgstr ""
"Si on rend la partie décimale et tout ce qui la suit optionnels, tous les "
"groupes ne figureront pas dans la correspondance. Ces groupes sans "
"correspondance vaudront ``None`` sauf si une autre valeur est donnée à "
"l'argument *default*:"
msgstr "Si on rend la partie décimale et tout ce qui la suit optionnels, tous les groupes ne figureront pas dans la correspondance. Ces groupes sans correspondance vaudront ``None`` sauf si une autre valeur est donnée à l'argument *default*::"
#: ../Doc/library/re.rst:1125
#, fuzzy
msgid ""
"Return a dictionary containing all the *named* subgroups of the match, keyed "
"by the subgroup name. The *default* argument is used for groups that did "
"not participate in the match; it defaults to ``None``. For example::"
msgstr ""
"Renvoie un dictionnaire contenant tous les sous-groupes *nommés* de la "
"correspondance, accessibles par leurs noms. L'argument *default* est "
"utilisé pour les groupes qui ne figurent pas dans la correspondance; il "
"vaut ``None`` par défaut. Par exemple:"
msgstr "Renvoie un dictionnaire contenant tous les sous-groupes *nommés* de la correspondance, accessibles par leurs noms. L'argument *default* est utilisé pour les groupes qui ne figurent pas dans la correspondance; il vaut ``None`` par défaut. Par exemple::"
#: ../Doc/library/re.rst:1137
msgid ""
@ -2081,9 +1829,8 @@ msgstr ""
"`IndexError`."
#: ../Doc/library/re.rst:1150
#, fuzzy
msgid "An example that will remove *remove_this* from email addresses::"
msgstr "Un exemple qui supprimera *remove_this* d'une adresse email:"
msgstr "Un exemple qui supprimera *remove_this* d'une adresse email::"
#: ../Doc/library/re.rst:1160
msgid ""
@ -2141,13 +1888,10 @@ msgstr ""
"de nom, ou si aucun groupe ne correspondait."
#: ../Doc/library/re.rst:1196
#, fuzzy
msgid ""
"The :ref:`regular expression object <re-objects>` whose :meth:`~regex.match` "
"or :meth:`~regex.search` method produced this match instance."
msgstr ""
"L'expression rationnelle dont la méthode :meth:`~regex.match` ou :meth:"
"`~regex.search` a produit cet objet de correspondance."
msgstr ":ref:`L'expression rationnelle <re-objects>` dont la méthode :meth:`~regex.match` ou :meth:`~regex.search` a produit cet objet de correspondance."
#: ../Doc/library/re.rst:1202
msgid "The string passed to :meth:`~regex.match` or :meth:`~regex.search`."
@ -2184,22 +1928,15 @@ msgstr ""
"valeurs."
#: ../Doc/library/re.rst:1229
#, fuzzy
msgid "To see if a given string is a valid hand, one could do the following::"
msgstr ""
"Pour vérifier qu'une chaîne donnée est une main valide, on pourrait faire "
"comme suit:"
msgstr "Pour vérifier qu'une chaîne donnée est une main valide, on pourrait faire comme suit::"
#: ../Doc/library/re.rst:1239
#, fuzzy
msgid ""
"That last hand, ``\"727ak\"``, contained a pair, or two of the same valued "
"cards. To match this with a regular expression, one could use backreferences "
"as such::"
msgstr ""
"La dernière main, ``\"727ak\"``, contenait une paire, deux cartes de la même "
"valeur. Pour valider cela avec une expression rationnelle, on pourrait "
"utiliser des références arrière comme:"
msgstr "La dernière main, ``\"727ak\"``, contenait une paire, deux cartes de la même valeur. Pour valider cela avec une expression rationnelle, on pourrait utiliser des références arrière comme::"
#: ../Doc/library/re.rst:1249
msgid ""
@ -2342,16 +2079,12 @@ msgstr ""
"avec :func:`search` pour restreindre la recherche au début de la chaîne: ::"
#: ../Doc/library/re.rst:1340
#, fuzzy
msgid ""
"Note however that in :const:`MULTILINE` mode :func:`match` only matches at "
"the beginning of the string, whereas using :func:`search` with a regular "
"expression beginning with ``'^'`` will match at the beginning of each "
"line. ::"
msgstr ""
"Notez cependant qu'en mode :const:`MULTILINE`, :func:`match` ne recherche "
"qu'au début de la chaîne, alors que :func:`search` avec une expression "
"rationnelle commençant par ``'^'`` recherchera au début de chaque ligne."
msgstr "Notez cependant qu'en mode :const:`MULTILINE`, :func:`match` ne recherche qu'au début de la chaîne, alors que :func:`search` avec une expression rationnelle commençant par ``'^'`` recherchera au début de chaque ligne. ::"
#: ../Doc/library/re.rst:1350
msgid "Making a Phonebook"
@ -2370,13 +2103,10 @@ msgstr ""
"démontré dans l'exemple suivant qui crée un répertoire téléphonique."
#: ../Doc/library/re.rst:1357
#, fuzzy
msgid ""
"First, here is the input. Normally it may come from a file, here we are "
"using triple-quoted string syntax::"
msgstr ""
"Premièrement, voici l'entrée. Elle provient normalement d'un fichier, nous "
"utilisons ici une chaîne à guillemets triples:"
msgstr "Premièrement, voici l'entrée. Elle provient normalement d'un fichier, nous utilisons ici une chaîne à guillemets triples::"
#: ../Doc/library/re.rst:1368
msgid ""
@ -2429,24 +2159,18 @@ msgid "Finding all Adverbs"
msgstr "Trouver tous les adverbes"
#: ../Doc/library/re.rst:1430
#, fuzzy
msgid ""
":func:`findall` matches *all* occurrences of a pattern, not just the first "
"one as :func:`search` does. For example, if one was a writer and wanted to "
"find all of the adverbs in some text, he or she might use :func:`findall` in "
"the following manner::"
msgstr ""
":func:`findall` trouve *toutes* les occurrences d'un motif, pas juste la "
"première comme le fait :func:`search`. Par exemple, si un(e) écrivain(e) "
"voulait trouver tous les adverbes dans un texte, il/elle devrait utiliser :"
"func:`findall` de la manière suivante:"
msgstr ":func:`findall` trouve *toutes* les occurrences d'un motif, pas juste la première comme le fait :func:`search`. Par exemple, si un(e) écrivain(e) voulait trouver tous les adverbes dans un texte, il/elle devrait utiliser :func:`findall` de la manière suivante::"
#: ../Doc/library/re.rst:1441
msgid "Finding all Adverbs and their Positions"
msgstr "Trouver tous les adverbes et leurs positions"
#: ../Doc/library/re.rst:1443
#, fuzzy
msgid ""
"If one wants more information about all matches of a pattern than the "
"matched text, :func:`finditer` is useful as it provides :ref:`match objects "
@ -2454,44 +2178,27 @@ msgid ""
"if one was a writer who wanted to find all of the adverbs *and their "
"positions* in some text, he or she would use :func:`finditer` in the "
"following manner::"
msgstr ""
"Pour obtenir plus d'informations sur les correspondances que juste le texte "
"trouvé, :func:`finditer` est utile en fournissant des :ref:`objets de "
"correspondance <match-objects>` plutôt que des chaînes. En continuant avec "
"le précédent exemple, si l'écrivain(e) voulait trouver tous les adverbes *et "
"leurs positions* dans un texte, il/elle utiliserait :func:`finditer` de la "
"manière suivante:"
msgstr "Pour obtenir plus d'informations sur les correspondances que juste le texte trouvé, :func:`finditer` est utile en fournissant des :ref:`objets de correspondance <match-objects>` plutôt que des chaînes. En continuant avec le précédent exemple, si l'écrivain(e) voulait trouver tous les adverbes *et leurs positions* dans un texte, il/elle utiliserait :func:`finditer` de la manière suivante::"
#: ../Doc/library/re.rst:1457
msgid "Raw String Notation"
msgstr "Notation brutes de chaînes"
#: ../Doc/library/re.rst:1459
#, fuzzy
msgid ""
"Raw string notation (``r\"text\"``) keeps regular expressions sane. Without "
"it, every backslash (``'\\'``) in a regular expression would have to be "
"prefixed with another one to escape it. For example, the two following "
"lines of code are functionally identical::"
msgstr ""
"La notation brute de chaînes (``r\"text\"``) garde saines les expressions "
"rationnelles. Sans elle, chaque *backslash* (``'\\'``) dans une expression "
"rationnelle devrait être préfixé d'un autre *backslash* pour l'échapper. "
"Par exemple, les deux lignes de code suivantes sont fonctionnellement "
"identiques:"
msgstr "La notation brute de chaînes (``r\"text\"``) garde saines les expressions rationnelles. Sans elle, chaque *backslash* (``'\\'``) dans une expression rationnelle devrait être préfixé d'un autre *backslash* pour l'échapper. Par exemple, les deux lignes de code suivantes sont fonctionnellement identiques::"
#: ../Doc/library/re.rst:1469
#, fuzzy
msgid ""
"When one wants to match a literal backslash, it must be escaped in the "
"regular expression. With raw string notation, this means ``r\"\\\\\"``. "
"Without raw string notation, one must use ``\"\\\\\\\\\"``, making the "
"following lines of code functionally identical::"
msgstr ""
"Pour rechercher un *backslash* littéral, il faut l'échapper dans "
"l'expression rationnelle. Avec la notation brute, cela signifie ``r\"\\\\"
"\"``. Sans elle, il faudrait utiliser ``\"\\\\\\\\\"``, faisant que les "
"deux lignes de code suivantes sont fonctionnellement identiques:"
msgstr "Pour rechercher un *backslash* littéral, il faut l'échapper dans l'expression rationnelle. Avec la notation brute, cela signifie ``r\"\\\\\"``. Sans elle, il faudrait utiliser ``\"\\\\\\\\\"``, faisant que les deux lignes de code suivantes sont fonctionnellement identiques::"
#: ../Doc/library/re.rst:1481
msgid "Writing a Tokenizer"
@ -2558,39 +2265,3 @@ msgstr "L'analyseur produit la sortie suivante: ::"
#~ "Z]`` valideront aussi les lettres minuscules. Cela n'est pas affecté par "
#~ "la locale courante et fonctionne comme convenu avec les caractères "
"Split the sequence at the first occurrence of *sep*, and return a 3-tuple "
"containing the part before the separator, the separator itself or its "
"bytearray copy, and the part after the separator. If the separator is not "
"found, return a 3-tuple containing a copy of the original sequence, followed "
"by two empty bytes or bytearray objects."
msgstr ""
"Divise la séquence à la première occurrence de *sep*, et renvoie un 3-tuple "
"contenant la partie précédant le séparateur, le séparateur, et la partie "
"suivant le séparateur. Si le séparateur est pas trouvé, le 3-tuple renvoyé "
"contiendra une copie de la séquence d'origine, suivi de deux *bytes* ou "
"*bytearray* vides."
msgstr "Divise la séquence à la première occurrence de *sep*, et renvoie un 3-tuple contenant la partie précédant le séparateur, le séparateur lui même (ou sa copie en *byterray*), et la partie suivant le séparateur. Si le séparateur est pas trouvé, le 3-tuple renvoyé contiendra une copie de la séquence d'origine, suivi de deux *bytes* ou *bytearray* vides."
msgid "The separator to search for may be any :term:`bytes-like object`."
@ -4442,19 +4436,13 @@ msgstr ""
"*sub* est introuvable."
#: ../Doc/library/stdtypes.rst:2623
#, fuzzy
msgid ""
"Split the sequence at the last occurrence of *sep*, and return a 3-tuple "
"containing the part before the separator, the separator itself or its "
"bytearray copy, and the part after the separator. If the separator is not "
"found, return a 3-tuple containing a copy of the original sequence, followed "
"by two empty bytes or bytearray objects."
msgstr ""
"Coupe la séquence à la dernière occurrence de *sep*, et renvoie un tuple de "
"trois elements contenant la partie précédent le séparateur, le séparateur, "
"et la partie suivant le séparateur. Si le séparateur n'est pas trouvé, le "
"tuple contiendra une copie de la séquence d'origine, suivi de deux *bytes* "
"ou *bytesarray* vides."
msgstr "Coupe la séquence à la dernière occurrence de *sep*, et renvoie un tuple de trois elements contenant la partie précédent le séparateur, le séparateur lui même (ou sa copie, un *bytearray*), et la partie suivant le séparateur. Si le séparateur n'est pas trouvé, le tuple contiendra une copie de la séquence d'origine, suivi de deux *bytes* ou *bytesarray* vides."
"*idpattern* -- This is the regular expression describing the pattern for non-"
"braced placeholders (the braces will be added automatically as appropriate). "
"The default value is the regular expression ``(?-i:[_a-zA-Z][_a-zA-Z0-9]*)``."
msgstr ""
"*idpattern* -- L'expression rationnelle décrivant le motif pour les "
"substituants non entourés d'accolades (les accolades sont ajoutées "
"automatiquement si c'est approprié). La valeur par défaut de cette "
"expression rationnelle est ``[_a-z][_a-z0-9]*``."
msgstr "*idpattern* -- L'expression rationnelle décrivant le motif pour les substituants non entourés d'accolades (les accolades sont ajoutées automatiquement si c'est approprié). La valeur par défaut de cette expression rationnelle est ``(?-i:[_a-zA-Z][_a-zA-Z0-9]*)``."
"ce paramètre a une syntaxe invalide, renvoie ``None``."
#: ../Doc/library/urllib.robotparser.rst:71
#, fuzzy
msgid ""
"Returns the contents of the ``Request-rate`` parameter from ``robots.txt`` "
"as a :term:`named tuple` ``RequestRate(requests, seconds)``. If there is no "
"such parameter or it doesn't apply to the *useragent* specified or the "
"``robots.txt`` entry for this parameter has invalid syntax, return ``None``."
msgstr ""
"Renvoie le contenu du paramètre ``Request-rate`` du ``robots.txt`` sous la "
"forme d'un :func:`~collections.namedtuple` ``(requests, seconds)``. S'il "
"n'y a pas de tel paramètre ou qu'il ne s'applique pas au *useragent* "
"spécifié ou si l'entrée du ``robots.txt`` pour ce paramètre a une syntaxe "
"invalide, renvoie ``None``."
msgstr "Renvoie le contenu du paramètre ``Request-rate`` du ``robots.txt`` sous la forme d'un :term:`named tuple` ``RequestRate(requests, seconds)``. S'il n'y a pas de tel paramètre ou qu'il ne s'applique pas au *useragent* spécifié ou si l'entrée du ``robots.txt`` pour ce paramètre a une syntaxe invalide, ``None`` est renvoyé."
