diff --git a/library/re.po b/library/re.po index bc6f1f1f..70048c97 100644 --- a/library/re.po +++ b/library/re.po @@ -19,17 +19,19 @@ msgstr "" #: ../Doc/library/re.rst:2 msgid ":mod:`re` --- Regular expression operations" -msgstr "" +msgstr ":mod:`re` --- Opérations à base d'expressions rationnelles" #: ../Doc/library/re.rst:10 msgid "**Source code:** :source:`Lib/re.py`" -msgstr "" +msgstr "**Code source :** :source:`Lib/re.py`" #: ../Doc/library/re.rst:14 msgid "" "This module provides regular expression matching operations similar to those " "found in Perl." msgstr "" +"Ce module fournit des opérations sur les expressions rationnelles " +"similaires à celles que l'on trouve dans Perl." #: ../Doc/library/re.rst:17 msgid "" @@ -39,6 +41,12 @@ msgid "" "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." #: ../Doc/library/re.rst:23 msgid "" @@ -50,6 +58,14 @@ msgid "" "string, because the regular expression must be ``\\\\``, and each backslash " "must be expressed as ``\\\\`` inside a regular Python string literal." msgstr "" +"Les expressions rationnelles utilisent le caractère *backslash* (``'\\'``) " +"pour indiquer des formes spéciales ou permettre d'utiliser des caractères " +"spéciaux sans en invoquer le sens. Cela entre en conflit avec l'utilisation " +"en Python du même caractère pour la même raison dans les chaînes " +"littérales ; par exemple, pour rechercher un *backslash* littéral il " +"faudrait écrire ``'\\\\\\\\'`` comme motif, parce que l'expression " +"rationnelle devrait être ``\\\\``, et chaque *backslash* exprimé par ``\\" +"\\`` au sein des chaînes littérales Python." #: ../Doc/library/re.rst:32 msgid "" @@ -60,6 +76,13 @@ msgid "" "a newline. Usually patterns will be expressed in Python code using this raw " "string notation." msgstr "" +"La solution est d'utiliser la notation des chaînes brutes en Python pour les " +"expressions rationnelles ; Les *backslashes* ne provoquent aucun traitement " +"spécifique dans les chaînes littérales préfixées par ``'r'``. Ainsi, ``r" +"\"\\n\"`` est une chaîne de deux caractères contenant ``'\\'`` et ``'n'``, " +"tandis que ``\"\\n\"`` est une chaîne contenant un unique caractère : un " +"saut de ligne. Généralement, les motifs seront exprimés en Python à l'aide " +"de chaînes brutes." #: ../Doc/library/re.rst:39 msgid "" @@ -68,6 +91,12 @@ msgid "" "expressions `. The functions are shortcuts that don't require " "you to compile a regex object first, but miss some fine-tuning parameters." msgstr "" +"Il est important de noter que la plupart des opérations sur les expressions " +"rationnelles sont disponibles comme fonctions au niveau du module et comme " +"méthodes des :ref:`expressions rationnelles compilées `. Les " +"fonctions sont des raccourcis qui ne vous obligent pas à d'abord compiler un " +"objet *regex*, mais auxquelles manquent certains paramètres de configuration " +"fine." #: ../Doc/library/re.rst:47 msgid "" @@ -75,10 +104,14 @@ msgid "" "has an API compatible with the standard library :mod:`re` module, but offers " "additional functionality and a more thorough Unicode support." msgstr "" +"Le module tiers `regex `_, dont " +"l'interface est compatible avec le module :mod:`re` de la bibliothèque " +"standard, mais offre des fonctionnalités additionnelles et un meilleur " +"support de l'Unicode." #: ../Doc/library/re.rst:55 msgid "Regular Expression Syntax" -msgstr "" +msgstr "Syntaxe des Expressions Rationnelles" #: ../Doc/library/re.rst:57 msgid "" @@ -87,6 +120,11 @@ msgid "" "given regular expression (or if a given regular expression matches a " "particular string, which comes down to the same thing)." msgstr "" +"Une expression rationnelle (*regular expression* ou *RE*) spécifie un " +"ensemble de chaînes de caractères qui lui correspondent ; les fonctions de " +"ce module vous permettent de vérifier si une chaîne particulière correspond " +"à une expression rationnelle donnée (ou si un expression rationnelle donnée " +"correspond à une chaîne particulière, ce qui revient à la même chose)." #: ../Doc/library/re.rst:62 msgid "" @@ -101,6 +139,18 @@ msgid "" "consult the Friedl book referenced above, or almost any textbook about " "compiler construction." msgstr "" +"Les expressions rationnelles peuvent être concaténées pour former de " +"nouvelles expressions : si *A* et *B* sont deux expressions rationnelles, " +"alors *AB* est aussi une expression rationnelle. En général, si une chaîne " +"*p* valide *A* et qu'une autre chaîne *q* valide *B*, la chaîne *pq* " +"validera AB. Cela est vrai tant que *A* et *B* ne contiennent pas " +"d'opérations de précédence ; de conditions liées entre *A* et *B* ; ou de " +"références vers des groupes numérotés. Ainsi, des expressions complexes " +"peuvent facilement être construites depuis de plus simples expressions " +"primitives comme celles décrites ici. Pour plus de détails sur la théorie " +"et l'implémentation des expressions rationnelles, consultez le livre de " +"Frield référencé plus tôt, ou à peu près n'importe quel livre dédié à la " +"construction de compilateurs." #: ../Doc/library/re.rst:72 msgid "" @@ -108,6 +158,9 @@ msgid "" "further information and a gentler presentation, consult the :ref:`regex-" "howto`." msgstr "" +"Une brève explication sur le format des expressions rationnelles suit. Pour " +"de plus amples informations, et une meilleure présentation, référez-vous au :" +"ref:`regex-howto`." #: ../Doc/library/re.rst:75 msgid "" @@ -118,6 +171,14 @@ msgid "" "rest of this section, we'll write RE's in ``this special style``, usually " "without quotes, and strings to be matched ``'in single quotes'``.)" msgstr "" +"Les expressions rationnelles peuvent contenir à la fois des caractères " +"spéciaux et ordinaires. Les plus ordinaires, comme ``'A'``, ``'a'`` ou " +"``'0'`` sont les expressions rationnelles les plus simples : elles " +"correspondent simplement à elles-mêmes. Vous pouvez concaténer deux " +"caractères ordinaires, donc ``last`` correspond à la chaîne ``'last'``. " +"(Dans la suite de cette section, nous écrirons les expressions rationnelles " +"dans ``ce style spécifique``, généralement sans guillemets, et les chaînes à " +"tester ``'entourées de simples guillemets'``.)" #: ../Doc/library/re.rst:82 msgid "" @@ -127,6 +188,12 @@ msgid "" "may not contain null bytes, but can specify the null byte using a ``" "\\number`` notation such as ``'\\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. 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``." #: ../Doc/library/re.rst:88 msgid "" @@ -136,10 +203,17 @@ msgid "" "repetition to an inner repetition, parentheses may be used. For example, the " "expression ``(?:a{6})*`` matches any multiple of six ``'a'`` characters." msgstr "" +"Les caractères de répétition (``*``, ``+``, ``?``, ``{m,n}``, etc.) ne " +"peuvent être directement imbriqués. Cela empêche l'ambiguïté avec le suffixe " +"modificateur non gourmand ``?``, et avec les autres modificateurs dans " +"d'autres implémentations. Pour appliquer une seconde répétition à une " +"première, des parenthèses peuvent être utilisées. Par exemple, l'expression " +"``(?:a{6})*`` valide toutes les chaînes composées d'un nombre de caractères " +"``'a'`` multiple de six." #: ../Doc/library/re.rst:95 msgid "The special characters are:" -msgstr "" +msgstr "Les caractères spéciaux sont :" #: ../Doc/library/re.rst:100 msgid "``'.'``" @@ -151,6 +225,9 @@ msgid "" "If the :const:`DOTALL` flag has been specified, this matches any character " "including a newline." msgstr "" +"(Point.) Dans le mode par défaut, il valide tout caractère à l'exception du " +"saut de ligne. Si l'option :const:`DOTALL` a été spécifiée, il valide tout " +"caractère, saut de ligne compris." #: ../Doc/library/re.rst:104 msgid "``'^'``" @@ -161,6 +238,8 @@ msgid "" "(Caret.) Matches the start of the string, and in :const:`MULTILINE` mode " "also matches immediately after each newline." msgstr "" +"(Accent circonflexe.) Valide le début d'une chaîne de caractères, ainsi que " +"ce qui suit chaque saut de ligne en mode :const:`MULTILINE`." #: ../Doc/library/re.rst:113 msgid "``'$'``" @@ -177,6 +256,14 @@ msgid "" "(empty) matches: one just before the newline, and one at the end of the " "string." msgstr "" +"Valide la fin d'une chaîne de caractères, ou juste avant le saut de ligne à " +"la fin de la chaîne, ainsi qu'avant chaque saut de ligne en mode :const:" +"`MULTILINE`. ``foo`` valide à la fois 'foo' et 'foobar', tandis que " +"l'expression rationnelle ``foo$`` ne correspond qu'à 'foo'. Plus " +"intéressant, chercher ``foo.$`` dans ``'foo1\\nfoo2\\n'`` trouve normalement " +"'foo2', mais 'foo1' en mode :const:`MULTILINE` ; chercher un simple ``$`` " +"dans ``'foo\\n'`` trouvera deux correspondances (vides) : une juste avant le " +"saut de ligne, et une à la fin de la chaîne." #: ../Doc/library/re.rst:118 msgid "``'*'``" @@ -188,6 +275,9 @@ msgid "" "as many repetitions as are possible. ``ab*`` will match 'a', 'ab', or 'a' " "followed by any number of 'b's." msgstr "" +"Implique à l'expression rationnelle résultante de valider 0 répétition ou " +"plus de l'expression qui précède, avec autant de répétitions que possible. " +"``ab*`` validera 'a', 'ab' ou 'a' suivi de n'importe quel nombre de 'b'." #: ../Doc/library/re.rst:123 msgid "``'+'``" @@ -199,6 +289,9 @@ msgid "" "``ab+`` will match 'a' followed by any non-zero number of 'b's; it will not " "match just 'a'." msgstr "" +"Implique à l'expression rationnelle résultante de valider une répétition ou " +"plus de l'expression qui précède. ``ab+`` validera 'a' suivi de n'importe " +"quel nombre non nul de 'b' ; ça ne validera pas la chaîne 'a'." #: ../Doc/library/re.rst:127 msgid "``'?'``" @@ -209,6 +302,8 @@ msgid "" "Causes the resulting RE to match 0 or 1 repetitions of the preceding RE. " "``ab?`` will match either 'a' or 'ab'." msgstr "" +"Implique à l'expression rationnelle résultante de valider 0 ou 1 répétition " +"de l'expression qui précède. ``ab?`` correspondra à la fois à 'a' et 'ab'." #: ../Doc/library/re.rst:136 msgid "``*?``, ``+?``, ``??``" @@ -224,6 +319,14 @@ msgid "" "characters as possible will be matched. Using the RE ``<.*?>`` will match " "only ````." 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 `` b ``, cela correspondra à la chaîne entière, " +"et non juste à ````. 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 ````." #: ../Doc/library/re.rst:141 msgid "``{m}``" @@ -235,6 +338,10 @@ msgid "" "fewer matches cause the entire RE not to match. For example, ``a{6}`` will " "match exactly six ``'a'`` characters, but not five." msgstr "" +"Spécifie qu'exactement *m* copies de l'expression rationnelle qui précède " +"devront être validées ; un nombre plus faible de correspondances empêche " +"l'expression entière de correspondre. Par exemple, ``a{6}`` correspondra " +"exactement à six caractères ``'a'``, mais pas à cinq." #: ../Doc/library/re.rst:150 msgid "``{m,n}``" @@ -251,6 +358,14 @@ msgid "" "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." #: ../Doc/library/re.rst:157 msgid "``{m,n}?``" @@ -264,6 +379,12 @@ msgid "" "character string ``'aaaaaa'``, ``a{3,5}`` will match 5 ``'a'`` characters, " "while ``a{3,5}?`` will only match 3 characters." 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 moins " +"possible. Il s'agit de la version non gourmande du précédent " +"qualificateur. Par exemple, dans la chaîne de 6 caractères ``'aaaaaa'``, " +"``a{3,5}`` trouvera 5 caractères ``'a'``, alors que ``a{3,5}?`` n'en " +"trouvera que 3." #: ../Doc/library/re.rst:170 msgid "``'\\'``" @@ -275,6 +396,9 @@ msgid "" "``'*'``, ``'?'``, and so forth), or signals a special sequence; special " "sequences are discussed below." msgstr "" +"Échappe à la fois les caractères spéciaux (permettant d'utiliser des " +"caractères comme ``'*'``, ``'?'`` et autres), ou signale une séquence " +"spéciale ; les séquences spéciales sont décrites ci-dessous." #: ../Doc/library/re.rst:164 msgid "" @@ -286,6 +410,15 @@ msgid "" "repeated twice. This is complicated and hard to understand, so it's highly " "recommended that you use raw strings for all but the simplest expressions." msgstr "" +"Si vous n'utilisez pas de chaînes brutes pour exprimer le motif, souvenez-" +"vous que Python utilise aussi le *backslash* comme une séquence " +"d'échappement dans les chaînes littérales ; si la séquence d'échappement " +"n'est pas reconnue par le parseur Python, le *backslash* et les caractères " +"qui le suivent sont inclus dans la chaîne retournée. Cependant, si Python " +"avait reconnu la séquence, le *backslash* aurait dû être doublé. C'est " +"assez compliqué et difficile à comprendre, c'est pourquoi il est hautement " +"recommandé d'utiliser des chaînes brutes pour tout sauf les expressions les " +"plus simples." #: ../Doc/library/re.rst:202 msgid "``[]``" @@ -293,13 +426,15 @@ msgstr "``[]``" #: ../Doc/library/re.rst:173 msgid "Used to indicate a set of characters. In a set:" -msgstr "" +msgstr "Utilisé pour indiquer un ensemble de caractères. Dans un ensemble :" #: ../Doc/library/re.rst:175 msgid "" "Characters can be listed individually, e.g. ``[amk]`` will match ``'a'``, " "``'m'``, or ``'k'``." msgstr "" +"Les caractères peuvent être listés individuellement, e.g. ``[amk]`` " +"correspondra à ``'a'``, ``'m'`` ou ``'k'``." #: ../Doc/library/re.rst:178 msgid "" @@ -310,6 +445,13 @@ msgid "" "``-`` is escaped (e.g. ``[a\\-z]``) or if it's placed as the first or last " "character (e.g. ``[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." #: ../Doc/library/re.rst:185 msgid "" @@ -317,6 +459,9 @@ msgid "" "``[(+*)]`` will match any of the literal characters ``'('``, ``'+'``, " "``'*'``, or ``')'``." msgstr "" +"Les caractères spéciaux perdent leur sens à l'intérieur des ensembles. Par " +"exemple, ``[(+*)]`` validera chacun des caractères littéraux ``'('``, " +"``'+'``, ``'*'`` ou ``')'``." #: ../Doc/library/re.rst:189 msgid "" @@ -324,6 +469,10 @@ msgid "" "accepted inside a set, although the characters they match depends on " "whether :const:`ASCII` or :const:`LOCALE` mode is in force." msgstr "" +"Les classes de caractères telles que ``\\w`` ou ``\\S`` (définies ci-" +"dessous) sont aussi acceptées à l'intérieur d'un ensemble, bien que les " +"caractères correspondant dépendent de quel mode est actif entre :const:" +"`ASCII` et :const:`LOCALE`." #: ../Doc/library/re.rst:193 msgid "" @@ -334,6 +483,13 @@ msgid "" "any character except ``'^'``. ``^`` has no special meaning if it's not the " "first character in the set." msgstr "" +"Les caractères qui ne sont pas dans un intervalle peuvent être trouvés avec " +"l'ensemble complémentaire (:dfn:`complementing`). Si le premier caractère " +"de l'ensemble est ``'^'``, tous les caractères qui *ne sont pas* dans " +"l'ensemble seront validés. Par exemple, ``[^5]`` correspondra à tout " +"caractère autre que ``'5'``, et ``[^^]`` validera n'importe quel caractère " +"excepté ``'^'``. ``^`` n'a pas de sens particulier s'il n'est pas le " +"premier caractère de l'ensemble." #: ../Doc/library/re.rst:200 msgid "" @@ -341,6 +497,10 @@ msgid "" "place it at the beginning of the set. For example, both ``[()[\\]{}]`` and " "``[]()[{}]`` will both match a parenthesis." msgstr "" +"Pour insérer un ``']'`` littéral dans un ensemble, il faut le précéder d'un " +"*backslash* ou le placer au début de l'ensemble. Par exemple, ``[()[\\]" +"{}]`` et ``[]()[{}]`` vont tous deux correspondre à une parenthèse, un " +"crochet ou une accolade." #: ../Doc/library/re.rst:213 msgid "``'|'``" @@ -358,6 +518,17 @@ msgid "" "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 ``[|]``." #: ../Doc/library/re.rst:220 msgid "``(...)``" @@ -372,6 +543,13 @@ msgid "" "``'('`` 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 : ``[(] " +"[)]``." #: ../Doc/library/re.rst:227 msgid "``(?...)``" @@ -385,6 +563,11 @@ msgid "" "do not create a new group; ``(?P...)`` is the only exception to this " "rule. Following are the currently supported extensions." msgstr "" +"Il s'agit d'une notation pour les extensions (un ``'?'`` suivant une ``'('`` " +"n'a pas de sens autrement). Le premier caractère après le ``'?'`` détermine " +"quel sens donner à l'expression. Les extensions ne créent généralement pas " +"de nouveaux groupes ; ``(?P...)`` est la seule exception à la règle. " +"Retrouvez ci-dessous la liste des extensions actuellement supportées." #: ../Doc/library/re.rst:240 msgid "``(?aiLmsux)``" @@ -402,6 +585,17 @@ msgid "" "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." #: ../Doc/library/re.rst:246 msgid "``(?:...)``" @@ -414,10 +608,14 @@ msgid "" "*cannot* be retrieved after performing a match or referenced later in the " "pattern." msgstr "" +"Une version non capturante des parenthèses habituelles. Valide n'importe " +"quelle expression rationnelle à l'intérieur des parenthèses, mais la sous-" +"chaîne correspondant au groupe *ne peut pas* être récupérée après l'analyse " +"ou être référencée plus loin dans le motif." #: ../Doc/library/re.rst:256 msgid "``(?imsx-imsx:...)``" -msgstr "" +msgstr "``(?imsx-imsx:...)``" #: ../Doc/library/re.rst:249 msgid "" @@ -428,6 +626,13 @@ msgid "" "and :const:`re.X` (verbose), for the part of the expression. (The flags are " "described in :ref:`contents-of-module-re`.)" msgstr "" +"(Zéro lettres ou plus de l'ensemble ``'i'``, ``'m'``, ``'s'``, ``'x'``, " +"optionnellement suivies par ``'-'`` ainsi qu'une ou plusieurs lettres du " +"même ensemble.) Les lettres activent ou désactivent les options " +"correspondantes : :const:`re.I` (ignorer la casse), :const:`re.M` (multi-" +"ligne), :const:`re.S` (les points correspondent à tous les caractères) et :" +"const:`re.X` (verbeux), pour cette partie de l'expression. (Les options " +"sont décrites dans la section :ref:`contents-of-module-re`.)" #: ../Doc/library/re.rst:281 msgid "``(?P...)``" @@ -441,6 +646,12 @@ msgid "" "regular expression. A symbolic group is also a numbered group, just as if " "the group were not named." msgstr "" +"Similaires aux parenthèses habituelles, mais la sous-chaîne validée par le " +"groupe est accessible via le nom *name* du groupe symbolique. Les noms de " +"groupes doivent être des identifiants Python valides, et chaque nom de " +"groupe ne doit être défini qu'une seule fois dans une expression " +"rationnelle. Un groupe symbolique est aussi un groupe numéroté, de la même " +"manière que si le groupe n'était pas nommé." #: ../Doc/library/re.rst:265 msgid "" @@ -448,22 +659,25 @@ msgid "" "P['\"]).*?(?P=quote)`` (i.e. matching a string quoted with either " "single or double quotes):" msgstr "" +"Les groupes nommés peuvent être référencés dans trois contextes. Si le " +"motif est ``(?P['\"]).*?(?P=quote)`` (i.e. correspondant à une chaîne " +"entourée de guillemets simples ou doubles)." #: ../Doc/library/re.rst:270 msgid "Context of reference to group \"quote\"" -msgstr "" +msgstr "Contexte de référence au groupe \"quote\"" #: ../Doc/library/re.rst:270 msgid "Ways to reference it" -msgstr "" +msgstr "Manières de le référencer" #: ../Doc/library/re.rst:272 msgid "in the same pattern itself" -msgstr "" +msgstr "lui-même dans le même motif" #: ../Doc/library/re.rst:272 msgid "``(?P=quote)`` (as shown)" -msgstr "" +msgstr "``(?P=quote)`` (comme vu)" #: ../Doc/library/re.rst:273 ../Doc/library/re.rst:280 msgid "``\\1``" @@ -471,7 +685,7 @@ msgstr "``\\1``" #: ../Doc/library/re.rst:275 msgid "when processing match object ``m``" -msgstr "" +msgstr "en analysant l'objet résultat ``m``" #: ../Doc/library/re.rst:275 msgid "``m.group('quote')``" @@ -479,11 +693,11 @@ msgstr "``m.group('quote')``" #: ../Doc/library/re.rst:276 msgid "``m.end('quote')`` (etc.)" -msgstr "" +msgstr "``m.end('quote')`` (etc.)" #: ../Doc/library/re.rst:278 msgid "in a string passed to the ``repl`` argument of ``re.sub()``" -msgstr "" +msgstr "dans une chaîne passée à l'argument ``repl`` de ``re.sub()``" #: ../Doc/library/re.rst:278 msgid "``\\g``" @@ -502,6 +716,8 @@ msgid "" "A backreference to a named group; it matches whatever text was matched by " "the earlier group named *name*." msgstr "" +"Une référence arrière à un groupe nommé ; elle correspond à n'importe quel " +"texte validé plus tôt par le groupe nommé *name*." #: ../Doc/library/re.rst:288 msgid "``(?#...)``" @@ -509,7 +725,7 @@ msgstr "``(?#...)``" #: ../Doc/library/re.rst:288 msgid "A comment; the contents of the parentheses are simply ignored." -msgstr "" +msgstr "Un commentaire ; le contenu des parenthèses est simplement ignoré." #: ../Doc/library/re.rst:293 msgid "``(?=...)``" @@ -521,6 +737,10 @@ msgid "" "This is called a 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'``." #: ../Doc/library/re.rst:298 msgid "``(?!...)``" @@ -532,6 +752,9 @@ msgid "" "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'``." #: ../Doc/library/re.rst:323 msgid "``(?<=...)``" @@ -550,14 +773,25 @@ msgid "" "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` :" #: ../Doc/library/re.rst:316 msgid "This example looks for a word following a hyphen:" -msgstr "" +msgstr "Cet exemple recherche un mot suivi d'un trait d'union :" #: ../Doc/library/re.rst:322 msgid "Added support for group references of fixed length." -msgstr "" +msgstr "Ajout du support des références aux groupes de taille fixe." #: ../Doc/library/re.rst:330 msgid "``(?'`` as well as ``'user@host.com'``, but not with " "``''``." msgstr "" +"Essaiera de faire la correspondance avec ``yes-pattern`` si le groupe " +"indiqué par *id* ou *name* existe, et avec ``no-pattern`` s'il n'existe pas. " +"``no-pattern`` est optionnel et peut être omis. Par exemple, ``(<)?(\\w+@\\w" +"+(?:\\.\\w+)+)(?(1)>|$)`` est un motif simpliste pour identifier une adresse " +"courriel, qui validera ``''`` ainsi que ``'user@host.com'`` " +"mais pas ``''``." #: ../Doc/library/re.rst:341 msgid "" @@ -593,6 +839,11 @@ msgid "" "then the resulting RE will match the second character. For example, ``\\$`` " "matches the character ``'$'``." msgstr "" +"Les séquences spéciales sont composées de ``'\\'`` et d'un caractère de la " +"liste qui suit. Si le caractère ordinaire n'est pas un chiffre *ASCII* ou " +"une lettre *ASCII*, alors l'expression rationnelle résultante validera le " +"second caractère de la séquence. Par exemple, ``\\$`` correspond au " +"caractère ``'$'``." #: ../Doc/library/re.rst:354 msgid "``\\number``" diff --git a/library/string.po b/library/string.po index 484b00eb..e1542f92 100644 --- a/library/string.po +++ b/library/string.po @@ -39,7 +39,7 @@ msgstr "Chaînes constantes" #: ../Doc/library/string.rst:20 msgid "The constants defined in this module are:" -msgstr "" +msgstr "Les constantes définies dans ce module sont :" #: ../Doc/library/string.rst:25 msgid "" @@ -320,6 +320,11 @@ msgid "" "related to that of :ref:`formatted string literals `, but there " "are differences." msgstr "" +"La méthode :meth:`str.format` et la classe :class:`Formatter` partagent la " +"même syntaxe pour les chaînes de formatage (bien que dans le cas de :class:" +"`Formatter` les sous-classes puissent définir leur propre syntaxe). La " +"syntaxe est liée à celle des :ref:`chaînes de formatage littérales `, mais il y a quelques différences." #: ../Doc/library/string.rst:195 msgid "" @@ -485,6 +490,12 @@ msgid "" "to the built-in :func:`format` function. Each formattable type may define " "how the format specification is to be interpreted." msgstr "" +"Les \"Spécifications de format\" sont utilisées avec les champs de " +"remplacement contenus dans les chaînes de formatage, pour définir comment " +"les valeurs doivent être représentées (voir :ref:`formatstrings` et :ref:`f-" +"strings`). Elles peuvent aussi être passées directement à la fonction " +"native :func:`format`. Chaque type *formatable* peut définir comment les " +"spécifications sur les valeurs de ce type doivent être interprétées." #: ../Doc/library/string.rst:293 msgid "" @@ -520,6 +531,14 @@ msgid "" "curly brace with a nested replacement field. This limitation doesn't affect " "the :func:`format` function." msgstr "" +"Si une valeur valide est spécifiée pour *align*, elle peut être précédée par " +"un caractère *fill*, qui peut être n'importe quel caractère (espace par " +"défaut si la valeur est omise). Il n'est pas possible d'utiliser une " +"accolade littérale (\"``{``\" ou \"``}``\") comme caractère *fill* dans une :" +"ref:`chaîne de formatage littérale ` ou avec la méthode :meth:" +"`str.format`. Cependant, il est possible d'insérer une accolade à l'aide " +"d'un champ de remplacement imbriqué. Cette limitation n'affecte pas la " +"fonction :func:`format`." #: ../Doc/library/string.rst:321 msgid "The meaning of the various alignment options is as follows:" @@ -570,6 +589,11 @@ msgid "" "alignment option is only valid for numeric types. It becomes the default " "when '0' immediately precedes the field width." msgstr "" +"Force le remplissage (*padding*) à être placé après le signe (si signe il y " +"a) mais avant les chiffres. L'option est utilisée pour afficher les champs " +"sous la forme '+000000120'. Cette option d'alignement est valide uniquement " +"pour les types numériques. Elle devient activée par défaut quand '0' " +"précède directement la largeur de champ." #: ../Doc/library/string.rst:338 msgid "``'^'``" @@ -680,10 +704,16 @@ msgid "" "``'X'``, underscores will be inserted every 4 digits. For other " "presentation types, specifying this option is an error." msgstr "" +"L'option ``'_'`` demande l'utilisation d'un tiret bas comme séparateur des " +"milliers pour les représentations de nombres flottants et pour les entiers " +"représentés par le type ``'d'``. Pour les types de représentation d'entiers " +"``'b'``, ``o'``, ``'x'`` et ``'X``', les tirets bas seront insérés tous les " +"4 chiffres. Pour les autres types de représentation, spécifier cette option " +"est une erreur." #: ../Doc/library/string.rst:389 msgid "Added the ``'_'`` option (see also :pep:`515`)." -msgstr "" +msgstr "Ajout de l'option ``'_'`` (voir aussi :pep`515`)." #: ../Doc/library/string.rst:392 msgid "" @@ -701,6 +731,11 @@ msgid "" "is equivalent to a *fill* character of ``'0'`` with an *alignment* type of " "``'='``." msgstr "" +"Quand aucun alignement explicite n'est donné, précéder le champs *width* " +"d'un caractère zéro (``'0'``) active le remplissage par zéro des types " +"numériques selon leur signe. Cela est équivalent à un caractère de " +"remplissage *fill* valant ``'0'`` avec le type d'alignement *alignment* " +"valant ``'='``." #: ../Doc/library/string.rst:400 msgid "" @@ -733,7 +768,7 @@ msgstr "Les types disponibles de représentation de chaîne sont :" #: ../Doc/library/string.rst:412 ../Doc/library/string.rst:423 #: ../Doc/library/string.rst:455 msgid "Type" -msgstr "" +msgstr "Type" #: ../Doc/library/string.rst:414 msgid "``'s'``" @@ -748,7 +783,7 @@ msgstr "" #: ../Doc/library/string.rst:417 ../Doc/library/string.rst:444 #: ../Doc/library/string.rst:505 msgid "None" -msgstr "" +msgstr "*None*" #: ../Doc/library/string.rst:417 msgid "The same as ``'s'``." @@ -841,6 +876,11 @@ msgid "" "``None``). When doing so, :func:`float` is used to convert the integer to a " "floating point number before formatting." msgstr "" +"En plus des types de représentation ci-dessus, les entiers peuvent aussi " +"être formatés avec les types de représentation des flottans listés ci-" +"dessous (à l'exception de ``'n'`` et ''None``). Dans ce cas, la fonction :" +"func:`float` est utilisée pour convertir l'entier en flottant avant le " +"formatage." #: ../Doc/library/string.rst:452 msgid ""