"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 "
"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` "
"`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 "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`."
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
msgid ""
@ -1290,7 +1296,17 @@ 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 "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:"
"``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 à via 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 "
"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 ""
@ -390,7 +398,13 @@ msgid ""
"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 ""
@ -432,14 +446,19 @@ msgstr ""
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
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-ci. Sinon, renvoie *singular* si *n* vaut 1, *plural* sinon. Surchargé dans les classes dérivées."
msgstr ""
"Si un objet de substitution a été défini, transmet :meth:`!ngettext` à celui-"
"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`. "
"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 (: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."
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 ""
@ -180,7 +186,11 @@ 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."
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 ""
@ -254,7 +264,7 @@ msgstr ""
#: ../Doc/library/re.rst:117
msgid "``*``"
msgstr ""
msgstr "``*``"
#: ../Doc/library/re.rst:115
msgid ""
@ -282,7 +292,7 @@ msgstr ""
#: ../Doc/library/re.rst:126
msgid "``?``"
msgstr ""
msgstr "``?``"
#: ../Doc/library/re.rst:125
msgid ""
@ -305,7 +315,15 @@ 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 rationnelle ``<.*?>`` validera uniquement ``'<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 "
"``'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}?``"
@ -415,7 +441,14 @@ 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]`` ou ``[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 ""
@ -481,7 +514,19 @@ 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 "``(...)``"
@ -495,7 +540,14 @@ 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 "``(?...)``"
@ -531,7 +583,19 @@ 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), :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."
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."
#: ../Doc/library/re.rst:246
msgid "``(?:...)``"
@ -672,7 +736,11 @@ 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 :dfn:`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 "``(?!...)``"
@ -683,7 +751,10 @@ 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 :dfn:`negative lookahead`. 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 "``(?<=...)``"
@ -701,7 +772,18 @@ 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:"
@ -808,7 +890,13 @@ msgid ""
"versa), or between ``\\w`` and the beginning/end of the string. This means "
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'``."
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
msgid ""
@ -817,7 +905,13 @@ msgid ""
"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 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."
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``"
@ -832,7 +926,15 @@ 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 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."
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``"
@ -877,7 +979,12 @@ msgid ""
"``\\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. 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]``)."
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``"
@ -919,7 +1026,12 @@ msgid ""
"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. 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``"
@ -946,7 +1058,11 @@ msgid ""
"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_]``. 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."
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``"
@ -960,7 +1076,14 @@ 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 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."
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 à "
"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``"
@ -991,7 +1114,9 @@ msgstr ""
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. Dans les motifs de *byte*, ce sont des erreurs."
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 ""
@ -1112,7 +1237,11 @@ msgid ""
"\\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. Correspond à l'option en ligne ``(?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. Correspond à l'option en ligne ``(?a)``."
#: ../Doc/library/re.rst:537
msgid ""
@ -1131,7 +1260,9 @@ msgstr ""
msgid ""
"Display debug information about compiled expression. No corresponding inline "
"flag."
msgstr "Affiche des informations de debug à propos de l'expression compilée. N'a pas d'option en ligne équivalente."
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
msgid ""
@ -1141,7 +1272,13 @@ 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. 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)``."
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 ""
@ -1164,7 +1301,15 @@ 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 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)``."
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 ""
@ -1183,14 +1328,24 @@ 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. Correspond à l'option en ligne ``(?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. "
"Correspond à l'option en ligne ``(?m)``."
#: ../Doc/library/re.rst:602
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. Correspond à l'option en ligne ``(?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. Correspond à l'option en ligne ``(?s)``."
#: ../Doc/library/re.rst:610
msgid ""
@ -1202,7 +1357,16 @@ 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é, 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."
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 ""
@ -1291,7 +1455,10 @@ 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 ""
@ -1305,7 +1472,9 @@ msgstr ""
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 ""
@ -1391,18 +1560,33 @@ 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
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 :ref:`objet de correspondance <match-objects>`, 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
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 :ref:`objet expression rationnelle <re-objects>`."
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 ""
@ -1595,7 +1779,14 @@ 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 ""
@ -1613,7 +1804,9 @@ msgstr ""
msgid ""
"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 ""
@ -1644,14 +1837,20 @@ 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:`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:`search`."
#: ../Doc/library/re.rst:965
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:`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:`search`."
#: ../Doc/library/re.rst:972
msgid "Identical to the :func:`sub` function, using the compiled pattern."
@ -1740,7 +1939,19 @@ 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 ""
@ -1764,13 +1975,16 @@ msgstr "Les groupes nommés peuvent aussi être référencés par leur index::
#: ../Doc/library/re.rst:1077
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
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 ""
@ -1791,14 +2005,22 @@ 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
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 ""
@ -1891,7 +2113,9 @@ msgstr ""
msgid ""
"The :ref:`regular expression object <re-objects>` whose :meth:`~regex.match` "
"or :meth:`~regex.search` method produced this match instance."
msgstr ":ref:`L'expression rationnelle <re-objects>` 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`."
@ -1929,14 +2153,19 @@ msgstr ""
#: ../Doc/library/re.rst:1229
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
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 ""
@ -2084,7 +2313,10 @@ msgid ""
"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"
@ -2106,7 +2338,9 @@ msgstr ""
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 ""
@ -2164,7 +2398,11 @@ msgid ""
"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"
@ -2178,7 +2416,13 @@ 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"
@ -2190,7 +2434,12 @@ msgid ""
"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
msgid ""
@ -2198,7 +2447,11 @@ msgid ""
"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::"
"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 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."
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,7 +4447,12 @@ msgid ""
"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 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."
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 ``(?-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 ``(?-i:[_a-zA-Z][_a-zA-Z0-9]*)``."
"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 :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é."
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, "
