From 98137cf8928e87e5378bdc1d7a7c241ff3fcc298 Mon Sep 17 00:00:00 2001
From: Yannick Gingras <ygingras@ygingras.net>
Date: Wed, 30 Sep 2020 08:40:58 -0600
Subject: [PATCH] Traduction de library/argparse.po, suite (#1412)

---
 library/argparse.po | 389 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 376 insertions(+), 13 deletions(-)

diff --git a/library/argparse.po b/library/argparse.po
index 19c921d0..a3514e04 100644
--- a/library/argparse.po
+++ b/library/argparse.po
@@ -6,7 +6,7 @@ msgstr ""
 "Project-Id-Version: Python 3\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2020-07-20 10:51+0200\n"
-"PO-Revision-Date: 2020-09-07 08:33-0700\n"
+"PO-Revision-Date: 2020-09-11 12:04-0700\n"
 "Last-Translator: Yannick Gingras <ygingras@ygingras.net>\n"
 "Language-Team: FRENCH <traductions@lists.afpy.org>\n"
 "Language: fr\n"
@@ -612,6 +612,9 @@ msgid ""
 "The ``fromfile_prefix_chars=`` argument defaults to ``None``, meaning that "
 "arguments will never be treated as file references."
 msgstr ""
+"Par défaut, l'argument ``fromfile_prefix_chars=`` est ``None``, ce qui "
+"signifie que les arguments ne seront pas traités en tant que références à "
+"des fichiers."
 
 #: library/argparse.rst:529
 msgid "argument_default"
@@ -628,6 +631,16 @@ msgid ""
 "suppress attribute creation on :meth:`~ArgumentParser.parse_args` calls, we "
 "supply ``argument_default=SUPPRESS``::"
 msgstr ""
+"Généralement, les valeurs par défaut des arguments sont spécifiées soit en "
+"passant la valeur désirée à :meth:`~ArgumentParser.add_argument` soit par un "
+"appel à la méthode :meth:`~ArgumentParser.set_defaults`. Cette méthode "
+"accepte un ensemble de paires nom-valeur. Il est parfois pertinent de "
+"configurer une valeur par défaut pour tous les arguments d'un analyseur. On "
+"peut activer ce comportement en passant la valeur désirée à l'argument nommé "
+"``argument_default=`` du constructeur de :class:`ArgumentParser`. Par "
+"exemple, pour supprimer globalement la création d'attributs pendant l'appel "
+"de :meth:`~ArgumentParser.parse_args`, on fournit "
+"``argument_default=SUPPRESS`` ::"
 
 #: library/argparse.rst:551
 msgid "allow_abbrev"
@@ -639,10 +652,15 @@ msgid ""
 "parse_args` method of an :class:`ArgumentParser`, it :ref:`recognizes "
 "abbreviations <prefix-matching>` of long options."
 msgstr ""
+"En temps normal, lorsque vous passez une liste d'arguments à la méthode :"
+"meth:`~ArgumentParser.parse_args` d':class:`ArgumentParser` :ref:`elle "
+"accepte les abréviations <prefix-matching>` des options longues."
 
 #: library/argparse.rst:557
 msgid "This feature can be disabled by setting ``allow_abbrev`` to ``False``::"
 msgstr ""
+"Cette fonctionnalité peut être désactivée en passant ``False`` à "
+"``allow_abbrev`` ::"
 
 #: library/argparse.rst:570
 msgid "conflict_handler"
@@ -655,6 +673,10 @@ msgid ""
 "exception if an attempt is made to create an argument with an option string "
 "that is already in use::"
 msgstr ""
+"Les objets :class:`ArgumentParser` ne peuvent pas avoir plus d'une option "
+"avec la même chaîne d'option. Par défaut, les objets :class:`ArgumentParser` "
+"lèvent une exception si on essaie de créer un argument avec une chaîne "
+"d'option qui est déjà utilisée ::"
 
 #: library/argparse.rst:584
 msgid ""
@@ -663,6 +685,10 @@ msgid ""
 "value ``'resolve'`` can be supplied to the ``conflict_handler=`` argument "
 "of :class:`ArgumentParser`::"
 msgstr ""
+"Parfois, par exemple si on utilise des analyseurs parents_, il est "
+"souhaitable de surcharger les anciens arguments qui partagent la même chaîne "
+"d'option. Pour obtenir ce comportement, vous devez passer ``'resolve'`` à "
+"l'argument ``conflict_handler=`` du constructeur d':class:`ArgumentParser` ::"
 
 #: library/argparse.rst:600
 msgid ""
@@ -671,6 +697,10 @@ msgid ""
 "foo`` action is retained as the ``-f`` action, because only the ``--foo`` "
 "option string was overridden."
 msgstr ""
+"Prenez note que les objets :class:`ArgumentParser` n'enlèvent une action que "
+"si toutes ses chaînes d'options sont surchargées. Ainsi dans l'exemple ci-"
+"dessus, l'action ``-f/--foo`` du parent est conservée comme l'action ``-f`` "
+"puisque ``--foo`` est la seule chaîne d'options qui a été surchargée."
 
 #: library/argparse.rst:607
 msgid "add_help"
@@ -682,12 +712,17 @@ msgid ""
 "parser's help message. For example, consider a file named ``myprogram.py`` "
 "containing the following code::"
 msgstr ""
+"Par défaut, les objets ``ArgumentParser`` ajoutent une option qui offre "
+"l'affichage du message d'aide de l'analyseur. Par exemple, prenons le "
+"fichier ``myprogram.py`` qui contient le code suivant ::"
 
 #: library/argparse.rst:618
 msgid ""
 "If ``-h`` or ``--help`` is supplied at the command line, the ArgumentParser "
 "help will be printed:"
 msgstr ""
+"Si ``-h`` ou ``--help`` est passé sur la ligne de commande, le message "
+"d'aide de l'``ArgumentParser`` sera affiché :"
 
 #: library/argparse.rst:630
 msgid ""
@@ -695,6 +730,9 @@ msgid ""
 "This can be achieved by passing ``False`` as the ``add_help=`` argument to :"
 "class:`ArgumentParser`::"
 msgstr ""
+"Il est parfois utile de désactiver l'ajout de cette option d'aide. Pour ce "
+"faire, vous devez passer ``False`` à l'argument ``add_help=`` du "
+"constructeur d':class:`ArgumentParser` ::"
 
 #: library/argparse.rst:642
 msgid ""
@@ -703,10 +741,15 @@ msgid ""
 "h`` and ``--help`` are not valid options.  In this case, the first character "
 "in ``prefix_chars`` is used to prefix the help options::"
 msgstr ""
+"En général, l'option d'aide est ``-h/--help``. L'exception à cette règle est "
+"quand une valeur est passée à ``prefix_chars=`` et qu'elle n'inclue pas ``-"
+"``, auquel cas, ``-h`` et ``--help`` ne sont pas des options valides. Dans "
+"ce cas, le premier caractère de ``prefix_chars`` est utilisé comme préfixe "
+"des options d'aide ::"
 
 #: library/argparse.rst:657
 msgid "exit_on_error"
-msgstr ""
+msgstr "Le paramètre *exit_on_error*"
 
 #: library/argparse.rst:659
 msgid ""
@@ -714,12 +757,17 @@ msgid ""
 "`~ArgumentParser.parse_args` method of an :class:`ArgumentParser`, it will "
 "exit with error info."
 msgstr ""
+"En général, quand vous passez une liste d'arguments dont au moins un est "
+"invalide à la méthode :meth:`~ArgumentParser.parse_args` d'une instance d':"
+"class:`ArgumentParser`, l'exécution se termine avec un message d'erreur."
 
 #: library/argparse.rst:662
 msgid ""
 "If the user would like catch errors manually, the feature can be enable by "
 "setting ``exit_on_error`` to ``False``::"
 msgstr ""
+"Si vous souhaitez intercepter les erreurs manuellement, la fonctionnalité "
+"peut être activée en assignant ``False`` à ``exit_on_error`` ::"
 
 #: library/argparse.rst:679
 msgid "The add_argument() method"
@@ -730,66 +778,82 @@ msgid ""
 "Define how a single command-line argument should be parsed.  Each parameter "
 "has its own more detailed description below, but in short they are:"
 msgstr ""
+"Définie comment une option de ligne de commande doit être analysée. Chacun "
+"des paramètres est décrit plus en détails ci-bas, mais en résumé ils sont :"
 
 #: library/argparse.rst:688
 msgid ""
 "`name or flags`_ - Either a name or a list of option strings, e.g. ``foo`` "
 "or ``-f, --foo``."
 msgstr ""
+"`name_or_flags`_ – un nom ou une liste de chaînes d'options. Par exemple : "
+"``foo`` ou ``-f, --foo``."
 
 #: library/argparse.rst:691
 msgid ""
 "action_ - The basic type of action to be taken when this argument is "
 "encountered at the command line."
 msgstr ""
+"action_ – Type élémentaire de l'action à entreprendre quand cet argument est "
+"reconnu sur la ligne de commande."
 
 #: library/argparse.rst:694
 msgid "nargs_ - The number of command-line arguments that should be consumed."
-msgstr ""
+msgstr "nargs_ – Nombre d'arguments de la ligne de commande à capturer."
 
 #: library/argparse.rst:696
 msgid ""
 "const_ - A constant value required by some action_ and nargs_ selections."
 msgstr ""
+"const_ – Valeur constante requise par certains choix d'action_ et de nargs_."
 
 #: library/argparse.rst:698
 msgid ""
 "default_ - The value produced if the argument is absent from the command "
 "line."
 msgstr ""
+"default_ – Valeur produite si l'argument est absent de la ligne de commande."
 
 #: library/argparse.rst:701
 msgid ""
 "type_ - The type to which the command-line argument should be converted."
 msgstr ""
+"type_ – Type vers lequel l'argument sur la ligne de commande doit être "
+"converti."
 
 #: library/argparse.rst:703
 msgid "choices_ - A container of the allowable values for the argument."
 msgstr ""
+"choices_ – Conteneur qui contient toutes les valeurs permises pour cet "
+"argument."
 
 #: library/argparse.rst:705
 msgid ""
 "required_ - Whether or not the command-line option may be omitted (optionals "
 "only)."
 msgstr ""
+"required_ – ``True`` si l'option sur la ligne de commande est obligatoire "
+"(ne s'applique qu'aux arguments optionnels)."
 
 #: library/argparse.rst:708
 msgid "help_ - A brief description of what the argument does."
-msgstr ""
+msgstr "help_ – Brève description de ce que fait l'argument."
 
 #: library/argparse.rst:710
 msgid "metavar_ - A name for the argument in usage messages."
-msgstr ""
+msgstr "metavar_ – Nom de l'argument dans les messages d'utilisations."
 
 #: library/argparse.rst:712
 msgid ""
 "dest_ - The name of the attribute to be added to the object returned by :"
 "meth:`parse_args`."
 msgstr ""
+"dest_ – Nom de l'attribut qui sera ajouté à l'objet retourné par :meth:"
+"`parse_args`."
 
 #: library/argparse.rst:719
 msgid "name or flags"
-msgstr "Les paramètres *name* et *flags*"
+msgstr "Le paramètre *name_or_flags*"
 
 #: library/argparse.rst:721
 msgid ""
@@ -800,10 +864,17 @@ msgid ""
 "or a simple argument name.  For example, an optional argument could be "
 "created like::"
 msgstr ""
+"La méthode :meth:`~ArgumentParser.add_argument` doit savoir si c'est un "
+"argument optionnel (tel que ``-f`` ou ``--foo``) ou plutôt un argument "
+"positionnel (tel qu'une liste de noms de fichiers) qui est attendu. Le "
+"premier argument passé à :meth:`~ArgumentParser.add_argument` doit donc être "
+"soit une série de noms d'options tels qu'ils apparaissent sur la ligne de "
+"commande, soit simplement un nom si on désire un argument positionnel. Par "
+"exemple, un argument optionnel est créé comme suit ::"
 
 #: library/argparse.rst:730
 msgid "while a positional argument could be created like::"
-msgstr ""
+msgstr "alors qu'un argument positionnel est créé comme suit ::"
 
 #: library/argparse.rst:734
 msgid ""
@@ -811,6 +882,9 @@ msgid ""
 "be identified by the ``-`` prefix, and the remaining arguments will be "
 "assumed to be positional::"
 msgstr ""
+"Lors le l'appel de :meth:`~ArgumentParser.parse_args`, les arguments qui "
+"commencent par le préfixe ``-`` sont présumés optionnels et tous les autres "
+"sont présumés positionnels ::"
 
 #: library/argparse.rst:751
 msgid "action"
@@ -825,12 +899,21 @@ msgid ""
 "``action`` keyword argument specifies how the command-line arguments should "
 "be handled. The supplied actions are:"
 msgstr ""
+"Les objets :class:`ArgumentParser` associent les arguments de la ligne de "
+"commande avec des actions. Ces actions peuvent soumettre les arguments de la "
+"ligne de commande auxquels elles sont associées à un traitement arbitraire, "
+"mais la majorité des actions se contentent d'ajouter un attribut à l'objet "
+"renvoyé par :meth:`~ArgumentParser.parse_args`. L'argument nommé ``action`` "
+"indique comment l'argument de la ligne de commande sera traité. Les actions "
+"natives sont :"
 
 #: library/argparse.rst:759
 msgid ""
 "``'store'`` - This just stores the argument's value.  This is the default "
 "action. For example::"
 msgstr ""
+"``'store'`` – Stocke la valeur de l'argument sans autre traitement. Ceci est "
+"l'action par défaut. Par exemple ::"
 
 #: library/argparse.rst:767
 msgid ""
@@ -838,6 +921,10 @@ msgid ""
 "argument.  The ``'store_const'`` action is most commonly used with optional "
 "arguments that specify some sort of flag.  For example::"
 msgstr ""
+"``'store_const'`` – Stocke la valeur passée à l'argument nommé const_. "
+"L'action ``'store_const'`` est typiquement utilisée avec des arguments "
+"optionnels qui représentent un drapeau ou une condition similaire. Par "
+"exemple ::"
 
 #: library/argparse.rst:776
 msgid ""
@@ -846,6 +933,10 @@ msgid ""
 "respectively.  In addition, they create default values of ``False`` and "
 "``True`` respectively.  For example::"
 msgstr ""
+"``'store_true'`` et ``'store_false'`` – Ces actions sont des cas "
+"particuliers de ``'store_const'`` pour lesquelles la valeur stockée est "
+"``True`` et ``False``, respectivement. Aussi, ces actions ont comme valeur "
+"par défaut ``False`` et ``True``, respectivement. Par exemple ::"
 
 #: library/argparse.rst:788
 msgid ""
@@ -853,6 +944,9 @@ msgid ""
 "list.  This is useful to allow an option to be specified multiple times. "
 "Example usage::"
 msgstr ""
+"``'append'`` – Stocke une liste et ajoute la valeur de l'argument à la "
+"liste. Ceci est pratique pour les options qui peuvent être répétées sur la "
+"ligne de commande ::"
 
 #: library/argparse.rst:797
 msgid ""
@@ -862,16 +956,25 @@ msgid ""
 "useful when multiple arguments need to store constants to the same list. For "
 "example::"
 msgstr ""
+"``'append_const'`` – Stocke une liste et ajoute la valeur passée à "
+"l'argument nommé const_ à la fin de la liste. Notez que la valeur par défaut "
+"de l'argument nommé const_ est ``None``. L'action ``'append_const'`` est "
+"pratique quand plusieurs arguments ont besoin de stocker des constantes dans "
+"la même liste. Par exemple ::"
 
 #: library/argparse.rst:809
 msgid ""
 "``'count'`` - This counts the number of times a keyword argument occurs. For "
 "example, this is useful for increasing verbosity levels::"
 msgstr ""
+"``'count'`` – Compte le nombre d'occurrences de l'argument nommé. Ceci est "
+"pratique, par exemple, pour augmenter le niveau de verbosité ::"
 
 #: library/argparse.rst:817
 msgid "Note, the *default* will be ``None`` unless explicitly set to *0*."
 msgstr ""
+"Prenez note que la valeur de *default* sera ``None`` à moins qu'elle soit "
+"explicitement définie à ``0``."
 
 #: library/argparse.rst:819
 msgid ""
@@ -880,6 +983,10 @@ msgid ""
 "added to the parser. See :class:`ArgumentParser` for details of how the "
 "output is created."
 msgstr ""
+"``'help'`` – Affiche le message d'aide complet pour toutes les options de "
+"l'analyseur puis termine l'exécution. Une action ``help`` est "
+"automatiquement ajoutée à l'analyseur par défaut. Consultez :class:"
+"`ArgumentParser` pour les détails de la création du contenu de l'aide."
 
 #: library/argparse.rst:824
 msgid ""
@@ -887,12 +994,17 @@ msgid ""
 "`~ArgumentParser.add_argument` call, and prints version information and "
 "exits when invoked::"
 msgstr ""
+"``'version'`` – Affiche la version du programme puis termine l'exécution. "
+"Cette action requiert l'argument nommé ``version=`` dans l'appel à :meth:"
+"`~ArgumentParser.add_argument` ::"
 
 #: library/argparse.rst:834
 msgid ""
 "``'extend'`` - This stores a list, and extends each argument value to the "
 "list. Example usage::"
 msgstr ""
+"``'extend'`` – Stock une liste et ajoute à la liste chacune des valeurs de "
+"l'argument reçues. Voici un exemple de son utilisation ::"
 
 #: library/argparse.rst:845
 msgid ""
@@ -901,6 +1013,10 @@ msgid ""
 "``BooleanOptionalAction`` is available in ``argparse`` and adds support for "
 "boolean actions such as ``--foo`` and ``--no-foo``::"
 msgstr ""
+"Vous pouvez aussi spécifier une action arbitraire en passant une sous-classe "
+"d'``Action`` ou un objet qui implémente la même interface. La classe "
+"``BooleanOptionalAction`` est disponible dans ``argparse`` et elle ajoute la "
+"gestion des options booléennes telles que ``--foo`` et ``--no-foo`` ::"
 
 #: library/argparse.rst:856
 msgid ""
@@ -908,6 +1024,9 @@ msgid ""
 "overriding the ``__call__`` method and optionally the ``__init__`` and "
 "``format_usage`` methods."
 msgstr ""
+"La façon recommandée pour créer une action personnalisée est d'hériter d':"
+"class:`Action` en surchargeant la méthode ``__call__``. Vous avez également "
+"l'option de surcharger les méthodes ``__init__`` et ``format_usage``."
 
 #: library/argparse.rst:860
 msgid "An example of a custom action::"
@@ -928,18 +1047,27 @@ msgid ""
 "different number of command-line arguments with a single action.  The "
 "supported values are:"
 msgstr ""
+"En général, les objets ``ArgumentParser`` associent un seul argument de la "
+"ligne de commande à une seule action à entreprendre. L'argument nommé "
+"``nargs`` associe un nombre différent d'arguments de la ligne de commande à "
+"une action. Les valeurs reconnues sont :"
 
 #: library/argparse.rst:890
 msgid ""
 "``N`` (an integer).  ``N`` arguments from the command line will be gathered "
 "together into a list.  For example::"
 msgstr ""
+"``N`` (un entier). ``N`` arguments de la ligne de commande seront capturés "
+"ensemble et stockés dans une liste. Par exemple ::"
 
 #: library/argparse.rst:899
 msgid ""
 "Note that ``nargs=1`` produces a list of one item.  This is different from "
 "the default, in which the item is produced by itself."
 msgstr ""
+"Prenez note que ``nargs=1`` produit une liste avec un seul élément. Ceci est "
+"différent du comportement par défaut qui produit l'élément directement "
+"(comme un scalaire)."
 
 #: library/argparse.rst:904
 msgid ""
@@ -950,12 +1078,20 @@ msgid ""
 "by a command-line argument.  In this case the value from const_ will be "
 "produced.  Some examples to illustrate this::"
 msgstr ""
+"``'?'``. Un argument sera capturé de la ligne de commande et produit "
+"directement. Si aucun argument n'est présent sur la ligne de commande, la "
+"valeur de default_ est produite. Prenez note que pour les arguments "
+"optionnels, il est aussi possible que la chaîne d'option soit présente mais "
+"qu'elle ne soit pas suivie d'un argument. Dans ce cas, la valeur de const_ "
+"est produite. Voici quelques exemples pour illustrer ceci ::"
 
 #: library/argparse.rst:921
 msgid ""
 "One of the more common uses of ``nargs='?'`` is to allow optional input and "
 "output files::"
 msgstr ""
+"``nargs='?'`` est fréquemment utilisé pour accepter des fichiers d'entrée et "
+"de sortie optionnels ::"
 
 #: library/argparse.rst:938
 msgid ""
@@ -964,6 +1100,11 @@ msgid ""
 "argument with ``nargs='*'``, but multiple optional arguments with "
 "``nargs='*'`` is possible.  For example::"
 msgstr ""
+"``'*'``. Tous les arguments présents sur la ligne de commande sont capturés "
+"dans une liste. Prenez note qu'il n'est pas logique d'avoir plus d'un "
+"argument positionnel avec ``nargs='*'``, mais il est par contre possible "
+"d'avoir plusieurs arguments optionnels qui spécifient ``nargs='*'``. Par "
+"exemple ::"
 
 #: library/argparse.rst:952
 msgid ""
@@ -971,6 +1112,10 @@ msgid ""
 "a list.  Additionally, an error message will be generated if there wasn't at "
 "least one command-line argument present.  For example::"
 msgstr ""
+"``'+'``. Comme pour ``'*'``, tous les arguments présents sur la ligne de "
+"commande sont capturés dans une liste. De plus, un message d'erreur est "
+"produit s'il n'y a pas au moins un argument présent sur la ligne de "
+"commande. Par exemple ::"
 
 #: library/argparse.rst:964
 msgid ""
@@ -979,6 +1124,9 @@ msgid ""
 "command-line argument will be consumed and a single item (not a list) will "
 "be produced."
 msgstr ""
+"Si l'argument nommé ``nargs`` n'est pas fourni, le nombre d'arguments "
+"capturés est déterminé par l'action_. En général, c'est un seul argument de "
+"la ligne de commande qui est capturé et il est produit directement."
 
 #: library/argparse.rst:970
 msgid "const"
@@ -991,6 +1139,10 @@ msgid ""
 "required for the various :class:`ArgumentParser` actions.  The two most "
 "common uses of it are:"
 msgstr ""
+"L'argument ``const`` d':meth:`~ArgumentParser.add_argument` est utilisé pour "
+"stocker une constante qui n'est pas lue depuis la ligne de commande mais qui "
+"est requise par certaines actions d':class:`ArgumentParser`. Les deux "
+"utilisations les plus communes sont :"
 
 #: library/argparse.rst:976
 msgid ""
@@ -999,7 +1151,13 @@ msgid ""
 "the ``const`` value to one of the attributes of the object returned by :meth:"
 "`~ArgumentParser.parse_args`. See the action_ description for examples."
 msgstr ""
+"quand :meth:`~ArgumentParser.add_argument` est appelée avec "
+"``action='store_const'`` ou ``action='append_const'``. Ces actions ajoutent "
+"la valeur de ``const`` à l'un des attributs de l'objet renvoyé par :meth:"
+"`~ArgumentParser.parse_args`. Consultez la description d'action_ pour voir "
+"quelques exemples ;"
 
+# Nous sommes dans une énumération après un :, donc pas de majuscule et le paragraphe doit se terminer par ;.
 #: library/argparse.rst:981
 msgid ""
 "When :meth:`~ArgumentParser.add_argument` is called with option strings "
@@ -1009,12 +1167,22 @@ msgid ""
 "command-line argument following it, the value of ``const`` will be assumed "
 "instead. See the nargs_ description for examples."
 msgstr ""
+"quand la méthode :meth:`~ArgumentParser.add_argument` est appelée avec des "
+"chaînes d'options (telles que ``-f`` ou ``--foo``) et ``nargs='?'``. Ceci "
+"crée un argument optionnel qui peut être suivi de zéro ou un argument de "
+"ligne de commande. Quand la ligne de commande est analysée, si la chaîne "
+"d'option est trouvée mais qu'elle n'est pas suivie par un argument, la "
+"valeur de ``const`` est utilisée. Consultez la description de nargs_ pour "
+"voir quelques exemples."
 
 #: library/argparse.rst:988
 msgid ""
 "With the ``'store_const'`` and ``'append_const'`` actions, the ``const`` "
 "keyword argument must be given.  For other actions, it defaults to ``None``."
 msgstr ""
+"Pour les actions ``'store_const'`` et ``'append_const'``, l'argument nommé "
+"``const`` doit être spécifié. Pour toutes les autres actions, il est "
+"optionnel et sa valeur par défaut est ``None``."
 
 #: library/argparse.rst:993
 msgid "default"
@@ -1029,6 +1197,12 @@ msgid ""
 "the ``default`` value is used when the option string was not present at the "
 "command line::"
 msgstr ""
+"Tous les arguments optionnels et certains arguments positionnels peuvent "
+"être omis à la ligne de commande. L'argument nommé ``default`` de la "
+"méthode :meth:`~ArgumentParser.add_argument` (qui vaut ``None`` par défaut), "
+"indique quelle valeur sera utilisé si l'argument est absent de la ligne de "
+"commande. Pour les arguments optionnels, la valeur de ``default`` est "
+"utilisée si la chaîne d'option n'est pas présente sur la ligne de commande ::"
 
 #: library/argparse.rst:1009
 msgid ""
@@ -1037,18 +1211,29 @@ msgid ""
 "conversion argument, if provided, before setting the attribute on the :class:"
 "`Namespace` return value.  Otherwise, the parser uses the value as is::"
 msgstr ""
+"Si la valeur de ``default`` est une chaîne, l'analyseur analyse cette valeur "
+"comme si c'était un argument de la ligne de commande. En particulier, "
+"l'analyseur applique la conversion spécifiée par l'argument type_ (si elle "
+"est fournie) avant d'affecter l'attribut à l'objet :class:`Namespace` "
+"renvoyé. Autrement, l'analyseur utilise la valeur telle qu'elle ::"
 
 #: library/argparse.rst:1020
 msgid ""
 "For positional arguments with nargs_ equal to ``?`` or ``*``, the "
 "``default`` value is used when no command-line argument was present::"
 msgstr ""
+"Pour les arguments positionnels pour lesquels nargs_ est ``?`` ou ``*``, la "
+"valeur de ``default`` est utilisée quand l'argument est absent de la ligne "
+"de commande ::"
 
 #: library/argparse.rst:1031
 msgid ""
 "Providing ``default=argparse.SUPPRESS`` causes no attribute to be added if "
 "the command-line argument was not present::"
 msgstr ""
+"Si vous passez ``default=argparse.SUPPRESS``, aucun attribut ne sera ajouté "
+"à l'objet ``Namespace`` quand l'argument est absent de la ligne de "
+"commande ::"
 
 #: library/argparse.rst:1043
 msgid "type"
@@ -1064,12 +1249,21 @@ msgid ""
 "performed.  Common built-in types and functions can be used directly as the "
 "value of the ``type`` argument::"
 msgstr ""
+"Par défaut, les objets :class:`ArgumentParser` capturent les arguments de la "
+"ligne de commande comme des chaînes. Très souvent par contre, on désire "
+"interpréter les chaînes de la ligne de commande comme un autre type, tel "
+"que :class:`float` ou :class:`int`. L'argument nommé ``type`` d':meth:"
+"`~ArgumentParser.add_argument` nous permet de faire les vérifications et les "
+"conversions de type nécessaires. Les types et les fonctions natives peuvent "
+"être utilisés directement pour la valeur de l'argument ``type`` ::"
 
 #: library/argparse.rst:1058
 msgid ""
 "See the section on the default_ keyword argument for information on when the "
 "``type`` argument is applied to default arguments."
 msgstr ""
+"Consultez la rubrique de l'argument nommé default_ pour plus d'information "
+"sur quand l'argument ``type`` est appliqué aux arguments par défaut."
 
 #: library/argparse.rst:1061
 msgid ""
@@ -1078,22 +1272,32 @@ msgid ""
 "``errors=`` arguments of the :func:`open` function.  For example, "
 "``FileType('w')`` can be used to create a writable file::"
 msgstr ""
+"Pour faciliter l'utilisation de types de fichiers variés, le module "
+"``argparse`` fournit le type fabrique ``FileType`` qui accepte les arguments "
+"``mode=``, ``bufsize=``, ``encoding=`` et ``errors=`` de la fonction :func:"
+"`open`. Par exemple, ``FileType('w')`` peut être utilisé pour créer un "
+"fichier en mode écriture ::"
 
 #: library/argparse.rst:1071
 msgid ""
 "``type=`` can take any callable that takes a single string argument and "
 "returns the converted value::"
 msgstr ""
+"``type=`` peut prendre n'importe quelle fonction ou objet appelable qui "
+"prend une seule chaîne de caractère comme argument et qui renvoie la valeur "
+"convertie ::"
 
 #: library/argparse.rst:1090
 msgid ""
 "The choices_ keyword argument may be more convenient for type checkers that "
 "simply check against a range of values::"
 msgstr ""
+"L'argument nommé choices_ est parfois plus facile d'utilisation pour les "
+"vérificateurs de type qui comparent la valeur à une gamme prédéfinie ::"
 
 #: library/argparse.rst:1101
 msgid "See the choices_ section for more details."
-msgstr "Voir le chapitre choices_ pour plus de détails."
+msgstr "Voir la rubrique de choices_ pour plus de détails."
 
 #: library/argparse.rst:1105
 msgid "choices"
@@ -1107,6 +1311,12 @@ msgid ""
 "line is parsed, argument values will be checked, and an error message will "
 "be displayed if the argument was not one of the acceptable values::"
 msgstr ""
+"Certains arguments de la ligne de commande doivent être choisis parmi un "
+"ensemble fermé de valeurs. Ceux-ci peuvent être gérés en passant un "
+"conteneur à l'argument nommé *choices* de la méthode :meth:`~ArgumentParser."
+"add_argument`. Quand la ligne de commande est analysée, les valeurs de "
+"l'argument sont comparées et un message d'erreur est affiché si l'argument "
+"n'est pas parmi les valeurs acceptables ::"
 
 #: library/argparse.rst:1122
 msgid ""
@@ -1114,6 +1324,9 @@ msgid ""
 "conversions have been performed, so the type of the objects in the *choices* "
 "container should match the type_ specified::"
 msgstr ""
+"Prenez note que le test d'inclusion dans le conteur *choices* est fait après "
+"la conversion de type_. Le type des objets dans le conteneur *choices* "
+"doivent donc correspondre au type_ spécifié ::"
 
 #: library/argparse.rst:1134
 msgid ""
@@ -1123,6 +1336,11 @@ msgid ""
 "choices; if we reuse previous rock/paper/scissors game example, this could "
 "be as follows::"
 msgstr ""
+"N'importe quel conteneur peut être fourni pour la valeur de *choices*, donc "
+"les objets :class:`list`, les objets :class:`set` et les conteurs "
+"personnalisés sont tous acceptés. Ceci inclus :class:`enum.Enum` qui peut "
+"être utilisé pour limiter le choix des arguments. Si on revient à notre "
+"exemple pierre-papier-ciseaux, on peut faire comme suit ::"
 
 #: library/argparse.rst:1153
 msgid "required"
@@ -1135,6 +1353,11 @@ msgid ""
 "command line. To make an option *required*, ``True`` can be specified for "
 "the ``required=`` keyword argument to :meth:`~ArgumentParser.add_argument`::"
 msgstr ""
+"En général, le module :mod:`argparse` prend pour acquis que les drapeaux "
+"comme ``-f`` et ``--bar`` annoncent un argument *optionnel* qui peut "
+"toujours être omis de la ligne de commande. Pour rendre une option "
+"*obligatoire*, ``True`` peut être passé à l'argument nommé ``required=`` d':"
+"meth:`~ArgumentParser.add_argument` ::"
 
 #: library/argparse.rst:1168
 msgid ""
@@ -1142,12 +1365,18 @@ msgid ""
 "`~ArgumentParser.parse_args` will report an error if that option is not "
 "present at the command line."
 msgstr ""
+"Tel qu'illustré' dans l'exemple, quand l'option est marquée comme "
+"``required``, :meth:`~ArgumentParser.parse_args` mentionne une erreur si "
+"l'option est absente de la ligne de commande."
 
 #: library/argparse.rst:1174
 msgid ""
 "Required options are generally considered bad form because users expect "
 "*options* to be *optional*, and thus they should be avoided when possible."
 msgstr ""
+"En général, les options obligatoires manifestent un style boiteux, car les "
+"utilisateurs s'attendent que les *options* soient *optionnelles*. Elles "
+"devraient donc être évitées si possible."
 
 #: library/argparse.rst:1179
 msgid "help"
@@ -1160,6 +1389,10 @@ msgid ""
 "at the command line), these ``help`` descriptions will be displayed with "
 "each argument::"
 msgstr ""
+"La valeur de ``help`` est une chaîne qui contient une brève description de "
+"l'argument. Quand un utilisateur demande de l'aide (en général par "
+"l'utilisation de ``-h`` ou ``--help`` sur la ligne de commande), ces "
+"descriptions d'aide seront affichées pour chacun des arguments ::"
 
 #: library/argparse.rst:1201
 msgid ""
@@ -1169,18 +1402,29 @@ msgid ""
 "arguments to :meth:`~ArgumentParser.add_argument`, e.g. ``%(default)s``, ``"
 "%(type)s``, etc.::"
 msgstr ""
+"La chaîne ``help`` peut contenir des spécificateurs de formatage afin "
+"d'éviter la répétition de contenu tel que le nom du programme et la valeur "
+"par défaut de l'argument (voir default_). Les spécificateurs de formatage "
+"disponibles incluent entre autres le nom du programme, ``%(prog)s``, et la "
+"plupart des arguments nommés d':meth:`~ArgumentParser.add_argument`, tels "
+"que ``%(default)s``, ``%(type)s``, etc. ::"
 
 #: library/argparse.rst:1218
 msgid ""
 "As the help string supports %-formatting, if you want a literal ``%`` to "
 "appear in the help string, you must escape it as ``%%``."
 msgstr ""
+"Comme la chaîne d'aide utilise le caractère ``%`` pour le formatage, si vous "
+"désirez afficher un ``%`` littéral dans la chaîne d'aide, vous devez en "
+"faire l’échappement avec ``%%``."
 
 #: library/argparse.rst:1221
 msgid ""
 ":mod:`argparse` supports silencing the help entry for certain options, by "
 "setting the ``help`` value to ``argparse.SUPPRESS``::"
 msgstr ""
+":mod:`argparse` peut supprimer la rubrique d'aide de certaines options. Pour "
+"ce faire, passez ``argparse.SUPPRESS`` à ``help`` ::"
 
 #: library/argparse.rst:1234
 msgid "metavar"
@@ -1197,10 +1441,19 @@ msgid ""
 "optional argument ``--foo`` that should be followed by a single command-line "
 "argument will be referred to as ``FOO``.  An example::"
 msgstr ""
+"Quand un objet :class:`ArgumentParser` construit le message d'aide, il doit "
+"pouvoir faire référence à chacun des arguments attendus. Par défaut, les "
+"objets ``ArgumentParser`` utilisent la valeur de dest_ pour le nom de chaque "
+"objet. Par défaut, la valeur de dest_ est utilisée telle quelle pour les "
+"actions d'arguments positionnels et elle (dest_) est convertie en majuscules "
+"pour les actions d'arguments optionnels. Ainsi, un argument positionnel "
+"unique avec ``dest='bar'`` sera affiché comme ``bar`` et un argument "
+"positionnel unique ``--foo`` qui prend un seul argument sur la ligne de "
+"commande sera affiché comme ``FOO``. Par exemple ::"
 
 #: library/argparse.rst:1260
 msgid "An alternative name can be specified with ``metavar``::"
-msgstr ""
+msgstr "Un nom alternatif peut être fourni à ``metavar`` ::"
 
 #: library/argparse.rst:1277
 msgid ""
@@ -1208,6 +1461,9 @@ msgid ""
 "attribute on the :meth:`~ArgumentParser.parse_args` object is still "
 "determined by the dest_ value."
 msgstr ""
+"Prenez note que ``metavar`` ne change que le nom *affiché*. Le nom de "
+"l'attribut ajouté à l'objet renvoyé par :meth:`~ArgumentParser.parse_args` "
+"est toujours déterminé par la valeur de dest_."
 
 #: library/argparse.rst:1281
 msgid ""
@@ -1215,6 +1471,9 @@ msgid ""
 "times. Providing a tuple to ``metavar`` specifies a different display for "
 "each of the arguments::"
 msgstr ""
+"Certaines valeurs de ``nargs`` peuvent provoquer l'affichage de ``metavar`` "
+"plus d'une fois. Passer un n-uplet à ``metavar`` indique les différents noms "
+"à afficher pour chacun des arguments ::"
 
 #: library/argparse.rst:1298
 msgid "dest"
@@ -1229,6 +1488,12 @@ msgid ""
 "is normally supplied as the first argument to :meth:`~ArgumentParser."
 "add_argument`::"
 msgstr ""
+"La plupart des actions d':class:`ArgumentParser` ajoutent une valeur dans un "
+"attribut de l'objet renvoyé par :meth:`~ArgumentParser.parse_args`. Le nom "
+"de l'attribut est déterminé par l'argument nommé ``dest`` d':meth:"
+"`~ArgumentParser.add_argument`. Pour les arguments positionnels, ``dest`` "
+"est généralement le premier argument d':meth:`~ArgumentParser."
+"add_argument` ::"
 
 #: library/argparse.rst:1312
 msgid ""
@@ -1241,10 +1506,18 @@ msgid ""
 "characters to make sure the string is a valid attribute name.  The examples "
 "below illustrate this behavior::"
 msgstr ""
+"Pour les actions d'arguments optionnels, la valeur de ``dest`` est "
+"généralement inférée à partir des chaînes d'option. :class:`ArgumentParser` "
+"génère la valeur de ``dest`` en prenant la première chaîne d'option longue "
+"et en retirant le préfixe ``--``. Si une chaîne d'option longue n'est pas "
+"fournie, ``dest`` sera dérivée de la première chaîne d'option courte sans le "
+"préfixe ``-``. Tous les ``-`` subséquents seront convertis en ``_`` pour "
+"s'assurer que le chaîne est un nom d'attribut valide. Les exemples suivants "
+"illustrent ce comportement ::"
 
 #: library/argparse.rst:1329
 msgid "``dest`` allows a custom attribute name to be provided::"
-msgstr ""
+msgstr "``dest`` vous permet de fournir un nom d'attribut personnalisé ::"
 
 #: library/argparse.rst:1337
 msgid "Action classes"
@@ -1256,6 +1529,10 @@ msgid ""
 "which processes arguments from the command-line. Any object which follows "
 "this API may be passed as the ``action`` parameter to :meth:`add_argument`."
 msgstr ""
+"Les classes ``Action`` implémentent l'API Action, un appelable qui retourne "
+"un appelable qui traite les arguments de la ligne de commande. Tout objet "
+"qui suit cette API peut être passé comme paramètre ``action`` d':meth:"
+"`add_argument`."
 
 #: library/argparse.rst:1348
 msgid ""
@@ -1265,6 +1542,11 @@ msgid ""
 "keyword arguments passed to :meth:`ArgumentParser.add_argument` except for "
 "the ``action`` itself."
 msgstr ""
+"Les objets ``Action`` sont utilisés par un ``ArgumentParser`` pour "
+"représenter l'information nécessaire à l'analyse d'un seul argument à partir "
+"d'une ou plusieurs chaînes de la ligne de commande. La classe ``Action`` "
+"doit accepter les deux arguments positionnels d':meth:`ArgumentParser."
+"add_argument` ainsi que tous ses arguments nommés, sauf ``action``."
 
 #: library/argparse.rst:1354
 msgid ""
@@ -1273,16 +1555,24 @@ msgid ""
 "\"type\", \"required\", \"help\", etc. defined. The easiest way to ensure "
 "these attributes are defined is to call ``Action.__init__``."
 msgstr ""
+"Les instances d'``Action`` (ou la valeur de retour de l'appelable passé au "
+"paramètre ``action``) doivent définir les attributs nécessaires : *dest*, "
+"*option_strings*, *default*, *type*, *required*, *help*, etc. La façon la "
+"plus simple de s'assurer que ces attributs sont définis est d'appeler "
+"``Action.__init__``."
 
 #: library/argparse.rst:1359
 msgid ""
 "Action instances should be callable, so subclasses must override the "
 "``__call__`` method, which should accept four parameters:"
 msgstr ""
+"Les instances d'``Action`` doivent être appelables et donc les sous-classes "
+"doivent surcharger la méthode ``__call__``. Cette méthode doit accepter "
+"quatre paramètres :"
 
 #: library/argparse.rst:1362
 msgid "``parser`` - The ArgumentParser object which contains this action."
-msgstr ""
+msgstr "``parser`` – L'objet ``ArgumentParser`` qui contient cette action."
 
 #: library/argparse.rst:1364
 msgid ""
@@ -1290,6 +1580,9 @@ msgid ""
 "`~ArgumentParser.parse_args`.  Most actions add an attribute to this object "
 "using :func:`setattr`."
 msgstr ""
+"``namespace`` – L'objet :class:`Namespace` qui sera renvoyé par :meth:"
+"`~ArgumentParser.parse_args`. La majorité des actions ajoutent un attribut à "
+"cet objet avec :func:`setattr`."
 
 #: library/argparse.rst:1368
 msgid ""
@@ -1297,6 +1590,10 @@ msgid ""
 "conversions applied.  Type conversions are specified with the type_ keyword "
 "argument to :meth:`~ArgumentParser.add_argument`."
 msgstr ""
+"``values`` – Les arguments de la ligne de commande associés à l'action après "
+"les avoir soumis à la conversion de type. Les conversions de types sont "
+"spécifiées grâce à l’argument nommé type_ d':meth:`~ArgumentParser."
+"add_argument`."
 
 #: library/argparse.rst:1372
 msgid ""
@@ -1304,12 +1601,18 @@ msgid ""
 "The ``option_string`` argument is optional, and will be absent if the action "
 "is associated with a positional argument."
 msgstr ""
+"``option_string`` – La chaîne d'option utilisée pour invoquer cette action. "
+"L'argument ``option_string`` est optionnel et est absent si l'action est "
+"associée à un argument positionnel."
 
 #: library/argparse.rst:1376
 msgid ""
 "The ``__call__`` method may perform arbitrary actions, but will typically "
 "set attributes on the ``namespace`` based on ``dest`` and ``values``."
 msgstr ""
+"La méthode ``__call__`` peut réaliser un traitement arbitraire, mais en "
+"général elle affect des attributs sur ``namespace`` en fonction de ``dest`` "
+"et de ``values``."
 
 #: library/argparse.rst:1379
 msgid ""
@@ -1317,6 +1620,11 @@ msgid ""
 "argument and return a string which will be used when printing the usage of "
 "the program. If such method is not provided, a sensible default will be used."
 msgstr ""
+"Les classes dérivées d'``Action`` peuvent définir une méthode "
+"``format_usage`` qui ne prends aucun argument et qui renvoie une chaîne qui "
+"sera utilisée lors de l'affichage du message d'utilisation du programme. Si "
+"cette méthode n'est pas fournie, une valeur raisonnable sera utilisée par "
+"défaut."
 
 #: library/argparse.rst:1384
 msgid "The parse_args() method"
@@ -1327,6 +1635,8 @@ msgid ""
 "Convert argument strings to objects and assign them as attributes of the "
 "namespace.  Return the populated namespace."
 msgstr ""
+"Convertie les chaînes d'arguments en objets et les assigne comme attributs "
+"de l'objet ``namespace``. Retourne l'objet ``namespace`` rempli."
 
 #: library/argparse.rst:1391
 msgid ""
@@ -1334,18 +1644,25 @@ msgid ""
 "created and how they are assigned. See the documentation for :meth:"
 "`add_argument` for details."
 msgstr ""
+"Les appels à :meth:`add_argument` qui ont été faits déterminent exactement "
+"quels objets sont créés et comment ils sont affectés. Consultez la rubrique "
+"d':meth:`add_argument` pour les détails."
 
 #: library/argparse.rst:1395
 msgid ""
 "args_ - List of strings to parse.  The default is taken from :data:`sys."
 "argv`."
 msgstr ""
+"args_ – Liste de chaînes à analyser. La valeur par défaut est récupérée "
+"dans : :data:`sys.argv`."
 
 #: library/argparse.rst:1398
 msgid ""
 "namespace_ - An object to take the attributes.  The default is a new empty :"
 "class:`Namespace` object."
 msgstr ""
+"namespace_ – Un objet pour recevoir les attributs. Par défaut : une nouvelle "
+"instance (vide) de :class:`Namespace`."
 
 #: library/argparse.rst:1403
 msgid "Option value syntax"
@@ -1370,12 +1687,17 @@ msgid ""
 "For short options (options only one character long), the option and its "
 "value can be concatenated::"
 msgstr ""
+"Pour les options courtes (les options qui utilisent un seul caractère), "
+"l'option et sa valeur peuvent être concaténées ::"
 
 #: library/argparse.rst:1430
 msgid ""
 "Several short options can be joined together, using only a single ``-`` "
 "prefix, as long as only the last option (or none of them) requires a value::"
 msgstr ""
+"Plusieurs options courtes peuvent être groupées ensemble après un seul "
+"préfixe ``-`` pour autant que seule la dernière (ou aucune) nécessite une "
+"valeur ::"
 
 #: library/argparse.rst:1442
 msgid "Invalid arguments"
@@ -1429,6 +1751,9 @@ msgid ""
 "An error is produced for arguments that could produce more than one options. "
 "This feature can be disabled by setting :ref:`allow_abbrev` to ``False``."
 msgstr ""
+"Une erreur est générée pour les arguments qui peuvent produire plus d'une "
+"option. Ce comportement peut être désactivé en passant ``False`` à :ref:"
+"`allow_abbrev`."
 
 #: library/argparse.rst:1544
 msgid "Beyond ``sys.argv``"
@@ -1444,13 +1769,16 @@ msgstr ""
 
 #: library/argparse.rst:1566
 msgid "The Namespace object"
-msgstr "L'objet namespace"
+msgstr "L'objet ``Namespace``"
 
 #: library/argparse.rst:1570
 msgid ""
 "Simple class used by default by :meth:`~ArgumentParser.parse_args` to create "
 "an object holding attributes and return it."
 msgstr ""
+"Classe rudimentaire qui est utilisé par défaut par :meth:`~ArgumentParser."
+"parse_args` pour créer un objet qui stock les attributs. Cet objet est "
+"renvoyé par ``ArgumentParser.parse_args``."
 
 #: library/argparse.rst:1573
 msgid ""
@@ -1458,6 +1786,10 @@ msgid ""
 "readable string representation. If you prefer to have dict-like view of the "
 "attributes, you can use the standard Python idiom, :func:`vars`::"
 msgstr ""
+"Cette classe est délibérément rudimentaire : une sous-classe d':class:"
+"`object` avec une représentation textuelle intelligible. Si vous préférez "
+"une vue *dict-compatible*, vous devez utiliser :func:`vars` (un idiome "
+"Python classique) ::"
 
 #: library/argparse.rst:1583
 msgid ""
@@ -1465,6 +1797,10 @@ msgid ""
 "to an already existing object, rather than a new :class:`Namespace` object.  "
 "This can be achieved by specifying the ``namespace=`` keyword argument::"
 msgstr ""
+"Il est parfois utile de demander à :class:`ArgumentParser` de faire "
+"l'affectation des attributs sur un objet existant plutôt que de faire la "
+"création d'un nouvel objet :class:`Namespace`. Ceci peut être réalisé avec "
+"l'argument nommé ``namespace=`` ::"
 
 #: library/argparse.rst:1599
 msgid "Other utilities"
@@ -1881,6 +2217,8 @@ msgid ""
 "The :mod:`argparse` module improves on the standard library :mod:`optparse` "
 "module in a number of ways including:"
 msgstr ""
+"Le module :mod:`argparse` fournit plusieurs améliorations par rapport au "
+"module :mod:`optparse` de la bibliothèque standard :"
 
 #: library/argparse.rst:2121
 msgid "Handling positional arguments."
@@ -1910,13 +2248,15 @@ msgstr ""
 
 #: library/argparse.rst:2128
 msgid "A partial upgrade path from :mod:`optparse` to :mod:`argparse`:"
-msgstr ""
+msgstr "Le portage partiel d':mod:`optparse` à :mod:`argparse` :"
 
 #: library/argparse.rst:2130
 msgid ""
 "Replace all :meth:`optparse.OptionParser.add_option` calls with :meth:"
 "`ArgumentParser.add_argument` calls."
 msgstr ""
+"Remplacer tous les appels à :meth:`optparse.OptionParser.add_option` par des "
+"appels à :meth:`ArgumentParser.add_argument`."
 
 #: library/argparse.rst:2133
 msgid ""
@@ -1925,6 +2265,11 @@ msgid ""
 "for the positional arguments. Keep in mind that what was previously called "
 "``options``, now in the :mod:`argparse` context is called ``args``."
 msgstr ""
+"Remplacer ``(options, args) = parser.parse_args()`` par ``args = parser."
+"parse_args()`` et ajouter des appels à :meth:`ArgumentParser.add_argument` "
+"pour les arguments positionnels. Prenez note que les valeurs précédemment "
+"appelées ``options`` sont appelées ``args`` dans le contexte d':mod:"
+"`argparse`."
 
 #: library/argparse.rst:2138
 msgid ""
@@ -1932,24 +2277,35 @@ msgid ""
 "meth:`~ArgumentParser.parse_intermixed_args` instead of :meth:"
 "`~ArgumentParser.parse_args`."
 msgstr ""
+"Remplacer :meth:`optparse.OptionParser.disable_interspersed_args` en "
+"appelant :meth:`~ArgumentParser.parse_intermixed_args` plutôt que :meth:"
+"`~ArgumentParser.parse_args`."
 
 #: library/argparse.rst:2142
 msgid ""
 "Replace callback actions and the ``callback_*`` keyword arguments with "
 "``type`` or ``action`` arguments."
 msgstr ""
+"Remplacer les actions de rappel (*callback actions* en anglais) et les "
+"arguments nommés ``callback_*`` par des arguments ``type`` et ``actions``."
 
 #: library/argparse.rst:2145
 msgid ""
 "Replace string names for ``type`` keyword arguments with the corresponding "
 "type objects (e.g. int, float, complex, etc)."
 msgstr ""
+"Remplacer les chaînes représentant le nom des types pour l'argument nommé "
+"``type`` par les objets types correspondants (par exemple : ``int``, "
+"``float``, ``complex``, etc)."
 
 #: library/argparse.rst:2148
 msgid ""
 "Replace :class:`optparse.Values` with :class:`Namespace` and :exc:`optparse."
 "OptionError` and :exc:`optparse.OptionValueError` with :exc:`ArgumentError`."
 msgstr ""
+"Remplacer :class:`optparse.Values` par :class:`Namespace` ; et :exc:"
+"`optparse.OptionError` et :exc:`optparse.OptionValueError` par :exc:"
+"`ArgumentError`."
 
 #: library/argparse.rst:2152
 msgid ""
@@ -1957,6 +2313,10 @@ msgid ""
 "with the standard Python syntax to use dictionaries to format strings, that "
 "is, ``%(default)s`` and ``%(prog)s``."
 msgstr ""
+"Remplacer les chaînes avec des arguments de formatage implicite (tels que ``"
+"%default`` ou ``%prog``) par la syntaxe standard de Python pour "
+"l'interpolation d'un dictionnaire dans les chaînes de formatage (c'est-à-"
+"dire ``%(default)s`` et ``%(prog)s``)."
 
 #: library/argparse.rst:2156
 msgid ""
@@ -1964,3 +2324,6 @@ msgid ""
 "``parser.add_argument('--version', action='version', version='<the "
 "version>')``."
 msgstr ""
+"Remplacer l'argument ``version`` du constructeur d'``OptionParser`` par un "
+"appel à ``parser.add_argument('--version', action='version', version='<la "
+"version>')``."