# SOME DESCRIPTIVE TITLE.

# Copyright (C) 1990-2016, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 2.7\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2016-10-30 10:44+0100\n"

"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: LANGUAGE <LL@li.org>\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

#: ../Doc/library/argparse.rst:2

msgid ""

":mod:`argparse` --- Parser for command-line options, arguments and sub-"

"commands"

msgstr ""

":mod:`argparse` -- Parseur d'arguments, d'options, et de sous-commandes de "

"ligne de commande"

#: ../Doc/library/argparse.rst:11

msgid "**Source code:** :source:`Lib/argparse.py`"

msgstr "**Code source:** :source:`Lib/argparse.py`"

#: ../Doc/library/argparse.rst:0

msgid "Tutorial"

msgstr "Tutoriel"

#: ../Doc/library/argparse.rst:17

msgid ""

"This page contains the API reference information. For a more gentle "

"introduction to Python command-line parsing, have a look at the :ref:"

"`argparse tutorial <argparse-tutorial>`."

msgstr ""

"Cette page est la référence de l'API. Pour une introduction plus en douceur "

"à l'analyse des arguments de la ligne de commande, regardez :ref:`le "

"tutoriel argparse <argparse-tutorial>`."

#: ../Doc/library/argparse.rst:21

msgid ""

"The :mod:`argparse` module makes it easy to write user-friendly command-line "

"interfaces. The program defines what arguments it requires, and :mod:"

"`argparse` will figure out how to parse those out of :data:`sys.argv`. The :"

"mod:`argparse` module also automatically generates help and usage messages "

"and issues errors when users give the program invalid arguments."

msgstr ""

"Le module :mod:`argparse` facilite l'écriture d'interfaces en ligne de "

"commande agréables à l'emploi. Le programme définit les arguments requis et :"

"mod:`argparse` s'arrange pour analyser ceux provenant de :data:`sys.argv`. "

"Le module :mod:`argparse` génère aussi automatiquement les messages d'aide, "

"le mode d'emploi, et lève des erreurs lorsque les utilisateurs fournissent "

"au programme des arguments invalides."

#: ../Doc/library/argparse.rst:29

msgid "Example"

msgstr "Exemple"

#: ../Doc/library/argparse.rst:31

msgid ""

"The following code is a Python program that takes a list of integers and "

"produces either the sum or the max::"

msgstr ""

"Le code suivant est un programme Python acceptant une liste de nombre "

"entiers et en donnant soit la somme, soit le maximum ::"

#: ../Doc/library/argparse.rst:46

msgid ""

"Assuming the Python code above is saved into a file called ``prog.py``, it "

"can be run at the command line and provides useful help messages:"

msgstr ""

"En supposant que le code Python ci-dessus est sauvegardé dans un fichier "

"nommé ``prog.py``, il peut être lancé en ligne de commande et fournit des "

"messages d'aide utiles :"

#: ../Doc/library/argparse.rst:63

msgid ""

"When run with the appropriate arguments, it prints either the sum or the max "

"of the command-line integers:"

msgstr ""

"Lorsqu'il est lancé avec les arguments appropriés, il affiche la somme ou le "

"maximum des entiers fournis en ligne de commande :"

#: ../Doc/library/argparse.rst:74

msgid "If invalid arguments are passed in, it will issue an error:"

msgstr "Si des arguments invalides sont passés, il lève une erreur :"

#: ../Doc/library/argparse.rst:82

msgid "The following sections walk you through this example."

msgstr "Les sections suivantes vous guident au travers de cet exemple."

#: ../Doc/library/argparse.rst:86

msgid "Creating a parser"

msgstr "Créer un analyseur (*parser* en anglais)"

#: ../Doc/library/argparse.rst:88

msgid ""

"The first step in using the :mod:`argparse` is creating an :class:"

"`ArgumentParser` object::"

msgstr ""

"La première étape dans l'utilisation de :mod:`argparse` est de créer un "

"objet :class:`ArgumentParser` ::"

#: ../Doc/library/argparse.rst:93

msgid ""

"The :class:`ArgumentParser` object will hold all the information necessary "

"to parse the command line into Python data types."

msgstr ""

"L'objet :class:`ArgumentParser` contiendra toutes les informations "

"nécessaires pour interpréter la ligne de commande comme des types de données "

"de Python."

#: ../Doc/library/argparse.rst:98

msgid "Adding arguments"

msgstr "Ajouter des arguments"

#: ../Doc/library/argparse.rst:100

msgid ""

"Filling an :class:`ArgumentParser` with information about program arguments "

"is done by making calls to the :meth:`~ArgumentParser.add_argument` method. "

"Generally, these calls tell the :class:`ArgumentParser` how to take the "

"strings on the command line and turn them into objects. This information is "

"stored and used when :meth:`~ArgumentParser.parse_args` is called. For "

"example::"

msgstr ""

"Alimenter un :class:`ArgumentParser` avec des informations sur les arguments "

"du programme s'effectue en faisant des appels à la méthode :meth:"

"`~ArgumentParser.add_argument`. En général ces appels disent à l':class:"

"`ArgumentParser` comment prendre les chaînes de caractères de la ligne de "

"commande et les transformer en objets. Cette information est stockée et "

"utilisée lorsque :meth:`~ArgumentParser.parse_args` est appelée. Par "

"exemple ::"

#: ../Doc/library/argparse.rst:112

msgid ""

"Later, calling :meth:`~ArgumentParser.parse_args` will return an object with "

"two attributes, ``integers`` and ``accumulate``. The ``integers`` attribute "

"will be a list of one or more ints, and the ``accumulate`` attribute will be "

"either the :func:`sum` function, if ``--sum`` was specified at the command "

"line, or the :func:`max` function if it was not."

msgstr ""

"Ensuite, appeler :meth:`~ArgumentParser.parse_args` va renvoyer un objet "

"avec deux attributs, ``integers`` et ``accumulate``. L'attribut ``integers`` "

"est une liste d'un ou plusieurs entiers, et l'attribut ``accumulate`` est "

"soit la fonction :func:`sum`, si ``--sum`` était fourni à la ligne de "

"commande, soit la fonction :func:`max` dans le cas contraire."

#: ../Doc/library/argparse.rst:120

msgid "Parsing arguments"

msgstr "Analyse des arguments"

#: ../Doc/library/argparse.rst:122

msgid ""

":class:`ArgumentParser` parses arguments through the :meth:`~ArgumentParser."

"parse_args` method. This will inspect the command line, convert each "

"argument to the appropriate type and then invoke the appropriate action. In "

"most cases, this means a simple :class:`Namespace` object will be built up "

"from attributes parsed out of the command line::"

msgstr ""

":class:`ArgumentParser` analyse les arguments avec la méthode :meth:"

"`~ArgumentParser.parse_args`. Cette méthode inspecte la ligne de commande, "

"convertit chaque argument au type approprié et invoque l'action requise. "

"Dans la plupart des cas, le résultat est la construction d'un objet :class:"

"`Namespace` à partir des attributs analysés dans la ligne de commande ::"

#: ../Doc/library/argparse.rst:131

msgid ""

"In a script, :meth:`~ArgumentParser.parse_args` will typically be called "

"with no arguments, and the :class:`ArgumentParser` will automatically "

"determine the command-line arguments from :data:`sys.argv`."

msgstr ""

"Dans un script, :meth:`~ArgumentParser.parse_args` est généralement appelée "

"sans arguments et l'objet :class:`ArgumentParser` détermine automatiquement "

"les arguments de la ligne de commande à partir de :data:`sys.argv`."

#: ../Doc/library/argparse.rst:137

msgid "ArgumentParser objects"

msgstr "Objets ArgumentParser"

#: ../Doc/library/argparse.rst:146

msgid ""

"Create a new :class:`ArgumentParser` object. All parameters should be passed "

"as keyword arguments. Each parameter has its own more detailed description "

"below, but in short they are:"

msgstr ""

"Crée un nouvel objet :class:`ArgumentParser`. Tous les paramètres doivent "

"être passés en arguments nommés. Chaque paramètre a sa propre description "

"détaillée ci-dessous, mais en résumé ils sont :"

#: ../Doc/library/argparse.rst:150

msgid "prog_ - The name of the program (default: ``sys.argv[0]``)"

msgstr "prog_ – Nom du programme (par défaut : ``sys.argv[0]``) ;"

#: ../Doc/library/argparse.rst:152

msgid ""

"usage_ - The string describing the program usage (default: generated from "

"arguments added to parser)"

msgstr ""

"usage_ – Chaîne décrivant l'utilisation du programme (par défaut : générée à "

"partir des arguments ajoutés à l'analyseur) ;"

#: ../Doc/library/argparse.rst:155

msgid "description_ - Text to display before the argument help (default: none)"

msgstr ""

"description_ – Texte à afficher avant l'aide des arguments (par défaut : "

"vide) ;"

#: ../Doc/library/argparse.rst:157

msgid "epilog_ - Text to display after the argument help (default: none)"

msgstr ""

"epilog_ – Texte à afficher après l'aide des arguments (par défaut : vide) ;"

#: ../Doc/library/argparse.rst:159

msgid ""

"parents_ - A list of :class:`ArgumentParser` objects whose arguments should "

"also be included"

msgstr ""

"parents_ – Liste d'objets :class:`ArgumentParser` contenant des arguments "

"qui devraient aussi être inclus ;"

#: ../Doc/library/argparse.rst:162

msgid "formatter_class_ - A class for customizing the help output"

msgstr ""

"formatter_class_ – Classe pour personnaliser la sortie du message d'aide ;"

#: ../Doc/library/argparse.rst:164

msgid ""

"prefix_chars_ - The set of characters that prefix optional arguments "

"(default: '-')"

msgstr ""

"prefix_chars_ – Jeu de caractères qui précède les arguments optionnels (par "

"défaut : ``'-'``) ;"

#: ../Doc/library/argparse.rst:167

msgid ""

"fromfile_prefix_chars_ - The set of characters that prefix files from which "

"additional arguments should be read (default: ``None``)"

msgstr ""

"fromfile_prefix_chars_ – Jeu de caractères qui précède les fichiers d'où des "

"arguments additionnels doivent être lus (par défaut : ``None``) ;"

#: ../Doc/library/argparse.rst:170

msgid ""

"argument_default_ - The global default value for arguments (default: "

"``None``)"

msgstr ""

"argument_default_ – Valeur globale par défaut pour les arguments (par "

"défaut : ``None``) ;"

#: ../Doc/library/argparse.rst:173

msgid ""

"conflict_handler_ - The strategy for resolving conflicting optionals "

"(usually unnecessary)"

msgstr ""

"conflict_handler_ – Stratégie pour résoudre les conflits entre les arguments "

"optionnels (non-nécessaire en général) ;"

#: ../Doc/library/argparse.rst:176

msgid "add_help_ - Add a -h/--help option to the parser (default: ``True``)"

msgstr ""

#: ../Doc/library/argparse.rst:178 ../Doc/library/argparse.rst:635

msgid "The following sections describe how each of these are used."

msgstr ""

"Les sections suivantes décrivent comment chacune de ces options sont "

"utilisées."

#: ../Doc/library/argparse.rst:182

msgid "prog"

msgstr "prog"

#: ../Doc/library/argparse.rst:184

msgid ""

"By default, :class:`ArgumentParser` objects use ``sys.argv[0]`` to determine "

"how to display the name of the program in help messages. This default is "

"almost always desirable because it will make the help messages match how the "

"program was invoked on the command line. For example, consider a file named "

"``myprogram.py`` with the following code::"

msgstr ""

"Par défaut, l'objet :class:`ArgumentParser` utilise ``sys.argv[0]`` pour "

"déterminer comment afficher le nom du programme dans les messages d'aide. "

"Cette valeur par défaut est presque toujours souhaitable, car elle produit "

"un message d'aide qui correspond à la méthode utilisée pour lancer le "

"programme sur la ligne de commande. Par exemple, si on a un fichier nommé "

"``myprogram.py`` avec le code suivant ::"

#: ../Doc/library/argparse.rst:195

msgid ""

"The help for this program will display ``myprogram.py`` as the program name "

"(regardless of where the program was invoked from):"

msgstr ""

"Le message d'aide pour ce programme affiche ``myprogram.py`` pour le nom du "

"programme (peu importe d'où le programme est lancé) :"

#: ../Doc/library/argparse.rst:214

msgid ""

"To change this default behavior, another value can be supplied using the "

"``prog=`` argument to :class:`ArgumentParser`::"

msgstr ""

"Pour changer ce comportement par défaut, une valeur alternative est passée "

"par l'argument ``prog=`` du constructeur d':class:`ArgumentParser` ::"

#: ../Doc/library/argparse.rst:224

msgid ""

"Note that the program name, whether determined from ``sys.argv[0]`` or from "

"the ``prog=`` argument, is available to help messages using the ``%(prog)s`` "

"format specifier."

msgstr ""

"Prenez note que le nom du programme, peu importe s'il provient de ``sys."

"argv[0]`` ou de l'argument ``prog=``, est accessible aux messages d'aide "

"grâce au spécificateur de formatage ``%(prog)s``."

#: ../Doc/library/argparse.rst:241

msgid "usage"

msgstr "usage"

#: ../Doc/library/argparse.rst:243

msgid ""

"By default, :class:`ArgumentParser` calculates the usage message from the "

"arguments it contains::"

msgstr ""

"Par défaut, l'objet :class:`ArgumentParser` construit le message relatif à "

"l'utilisation à partir des arguments qu'il contient ::"

#: ../Doc/library/argparse.rst:259

msgid ""

"The default message can be overridden with the ``usage=`` keyword argument::"

msgstr ""

"Le message par défaut peut être remplacé grâce à l'argument nommé "

"``usage=`` ::"

#: ../Doc/library/argparse.rst:274

msgid ""

"The ``%(prog)s`` format specifier is available to fill in the program name "

"in your usage messages."

msgstr ""

"Le spécificateur de formatage ``%(prog)s`` est disponible pour insérer le "

"nom du programme dans vos messages d'utilisation."

#: ../Doc/library/argparse.rst:279

msgid "description"

msgstr "description"

#: ../Doc/library/argparse.rst:281

msgid ""

"Most calls to the :class:`ArgumentParser` constructor will use the "

"``description=`` keyword argument. This argument gives a brief description "

"of what the program does and how it works. In help messages, the "

"description is displayed between the command-line usage string and the help "

"messages for the various arguments::"

msgstr ""

"La plupart des appels au constructeur d':class:`ArgumentParser` utilisent "

"l'argument nommé ``description=``. Cet argument donne une brève description "

"de ce que fait le programme et de comment il fonctionne. Dans les messages "

"d'aide, cette description est affichée entre le prototype de ligne de "

"commande et les messages d'aide des arguments ::"

#: ../Doc/library/argparse.rst:296

msgid ""

"By default, the description will be line-wrapped so that it fits within the "

"given space. To change this behavior, see the formatter_class_ argument."

msgstr ""

"Par défaut, la description est sujette au retour à la ligne automatique pour "

"se conformer à l'espace disponible. Pour changer ce comportement, voyez "

"l'argument formatter_class_."

#: ../Doc/library/argparse.rst:301

msgid "epilog"

msgstr "epilog"

#: ../Doc/library/argparse.rst:303

msgid ""

"Some programs like to display additional description of the program after "

"the description of the arguments. Such text can be specified using the "

"``epilog=`` argument to :class:`ArgumentParser`::"

msgstr ""

"Certains programmes aiment afficher un texte supplémentaire après la "

"description des arguments. Un tel texte peut être spécifié grâce à "

"l'argument ``epilog=`` du constructeur d':class:`ArgumentParser` ::"

#: ../Doc/library/argparse.rst:320

msgid ""

"As with the description_ argument, the ``epilog=`` text is by default line-"

"wrapped, but this behavior can be adjusted with the formatter_class_ "

"argument to :class:`ArgumentParser`."

msgstr ""

"De même que pour l'argument description_, le texte passé à ``epilog=`` est "

"sujet au retour à la ligne automatique. Ce comportement peut être ajusté "

"grâce à l'argument formatter_class_ du constructeur d':class:"

"`ArgumentParser`."

#: ../Doc/library/argparse.rst:326

msgid "parents"

msgstr "parents"

#: ../Doc/library/argparse.rst:328

msgid ""

"Sometimes, several parsers share a common set of arguments. Rather than "

"repeating the definitions of these arguments, a single parser with all the "

"shared arguments and passed to ``parents=`` argument to :class:"

"`ArgumentParser` can be used. The ``parents=`` argument takes a list of :"

"class:`ArgumentParser` objects, collects all the positional and optional "

"actions from them, and adds these actions to the :class:`ArgumentParser` "

"object being constructed::"

msgstr ""

"Parfois, plusieurs analyseurs partagent un jeu commun d'arguments. Plutôt "

"que de répéter les définitions de ces arguments, un analyseur commun qui "

"contient tous les arguments partagés peut être utilisé, puis passé à "

"l'argument ``parents=`` du constructeur d':class:`ArgumentParser`. "

"L'argument ``parents=`` accepte une liste d'objets :class:`ArgumentParser`, "

"accumule toutes les actions positionnelles et optionnelles de ces objets, "

"puis les ajoute à l'instance d':class:`ArgumentParser` en cours de "

"création ::"

#: ../Doc/library/argparse.rst:348

msgid ""

"Note that most parent parsers will specify ``add_help=False``. Otherwise, "

"the :class:`ArgumentParser` will see two ``-h/--help`` options (one in the "

"parent and one in the child) and raise an error."

msgstr ""

"Prenez note que la majorité des analyseurs parents doivent spécifier "

"``add_help=False``. Autrement, le constructeur d':class:`ArgumentParser` va "

"voir plus d'une option ``-h/--help`` (une pour le parent et une pour "

"l'instance en cours de création) et va lever une erreur."

#: ../Doc/library/argparse.rst:353

msgid ""

"You must fully initialize the parsers before passing them via ``parents=``. "

"If you change the parent parsers after the child parser, those changes will "

"not be reflected in the child."

msgstr ""

"Vous devez initialiser complètement les analyseurs avant de les passer à "

"``parents=``. Si vous changez les analyseurs parents après la création de "

"l'analyseur enfant, ces changements ne seront pas répercutés sur l'enfant."

#: ../Doc/library/argparse.rst:359

msgid "formatter_class"

msgstr "formatter_class"

#: ../Doc/library/argparse.rst:361

msgid ""

":class:`ArgumentParser` objects allow the help formatting to be customized "

"by specifying an alternate formatting class. Currently, there are three "

"such classes:"

msgstr ""

#: ../Doc/library/argparse.rst:369

msgid ""

"The first two allow more control over how textual descriptions are "

"displayed, while the last automatically adds information about argument "

"default values."

msgstr ""

#: ../Doc/library/argparse.rst:372

msgid ""

"By default, :class:`ArgumentParser` objects line-wrap the description_ and "

"epilog_ texts in command-line help messages::"

msgstr ""

#: ../Doc/library/argparse.rst:395

msgid ""

"Passing :class:`RawDescriptionHelpFormatter` as ``formatter_class=`` "

"indicates that description_ and epilog_ are already correctly formatted and "

"should not be line-wrapped::"

msgstr ""

"Passer :class:`RawDescriptionHelpFormatter` à ``formatter_class=`` indique "

"que les textes de description_ et d'epilog_ ont déjà été formatés "

"correctement et qu'ils ne doivent pas faire l'objet d'un retour à la ligne "

"automatique ::"

#: ../Doc/library/argparse.rst:421

msgid ""

":class:`RawTextHelpFormatter` maintains whitespace for all sorts of help "

"text, including argument descriptions."

msgstr ""

#: ../Doc/library/argparse.rst:424

msgid ""

"The other formatter class available, :class:`ArgumentDefaultsHelpFormatter`, "

"will add information about the default value of each of the arguments::"

msgstr ""

#: ../Doc/library/argparse.rst:444

msgid "prefix_chars"

msgstr "prefix_chars"

#: ../Doc/library/argparse.rst:446

msgid ""

"Most command-line options will use ``-`` as the prefix, e.g. ``-f/--foo``. "

"Parsers that need to support different or additional prefix characters, e.g. "

"for options like ``+f`` or ``/foo``, may specify them using the "

"``prefix_chars=`` argument to the ArgumentParser constructor::"

msgstr ""

"La majorité des options sur la ligne de commande utilisent ``-`` comme "

"préfixe (par exemple : ``-f/--foo``). Pour les analyseurs qui doivent "

"accepter des caractères préfixes autres ou additionnels (par exemple pour "

"les options ``+f`` ou ``/foo``), vous devez les spécifier en utilisant "

"l'argument ``prefix_chars=`` du constructeur d'``ArgumentParser`` ::"

#: ../Doc/library/argparse.rst:458

msgid ""

"The ``prefix_chars=`` argument defaults to ``'-'``. Supplying a set of "

"characters that does not include ``-`` will cause ``-f/--foo`` options to be "

"disallowed."

msgstr ""

"La valeur par défaut de ``prefix_chars=`` est ``'-'``. Passer un jeu de "

"caractères qui n'inclut pas ``-`` provoquera le refus des options comme ``-"

"f/--foo``."

#: ../Doc/library/argparse.rst:464

msgid "fromfile_prefix_chars"

msgstr "fromfile_prefix_chars"

#: ../Doc/library/argparse.rst:466

msgid ""

"Sometimes, for example when dealing with a particularly long argument lists, "

"it may make sense to keep the list of arguments in a file rather than typing "

"it out at the command line. If the ``fromfile_prefix_chars=`` argument is "

"given to the :class:`ArgumentParser` constructor, then arguments that start "

"with any of the specified characters will be treated as files, and will be "

"replaced by the arguments they contain. For example::"

msgstr ""

"Parfois, par exemple quand on traite une liste d'arguments particulièrement "

"longue, il est logique de stocker la liste d'arguments dans un fichier "

"plutôt que de la saisir sur la ligne de commande. Si un jeu de caractères "

"est passé à l'argument ``fromfile_prefix_chars=`` du constructeur de :class:"

"`ArgumentParser`, alors les arguments qui commencent par l'un des caractères "

"spécifiés seront traités comme des fichiers et seront remplacés par les "

"arguments contenus dans ces fichiers. Par exemple ::"

#: ../Doc/library/argparse.rst:480

msgid ""

"Arguments read from a file must by default be one per line (but see also :"

"meth:`~ArgumentParser.convert_arg_line_to_args`) and are treated as if they "

"were in the same place as the original file referencing argument on the "

"command line. So in the example above, the expression ``['-f', 'foo', "

"'@args.txt']`` is considered equivalent to the expression ``['-f', 'foo', '-"

"f', 'bar']``."

msgstr ""

"Par défaut, les arguments lus à partir d'un fichier doivent être chacun sur "

"une nouvelle ligne (voir aussi :meth:`~ArgumentParser."

"convert_arg_line_to_args`) et ils sont traités comme s'ils étaient au même "

"emplacement que le fichier original référençant les arguments de la ligne de "

"commande. Ainsi dans l'exemple ci-dessus, l'expression ``['-f', 'foo', "

"'@args.txt']`` est équivalente à l'expression ``['-f', 'foo', '-f', 'bar']``."

#: ../Doc/library/argparse.rst:486

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."

#: ../Doc/library/argparse.rst:491

msgid "argument_default"

msgstr "argument_default"

#: ../Doc/library/argparse.rst:493

msgid ""

"Generally, argument defaults are specified either by passing a default to :"

"meth:`~ArgumentParser.add_argument` or by calling the :meth:`~ArgumentParser."

"set_defaults` methods with a specific set of name-value pairs. Sometimes "

"however, it may be useful to specify a single parser-wide default for "

"arguments. This can be accomplished by passing the ``argument_default=`` "

"keyword argument to :class:`ArgumentParser`. For example, to globally "

"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`` ::"

#: ../Doc/library/argparse.rst:512

msgid "conflict_handler"

msgstr "conflict_handler"

#: ../Doc/library/argparse.rst:514

msgid ""

":class:`ArgumentParser` objects do not allow two actions with the same "

"option string. By default, :class:`ArgumentParser` objects raise an "

"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 ::"

#: ../Doc/library/argparse.rst:526

msgid ""

"Sometimes (e.g. when using parents_) it may be useful to simply override any "

"older arguments with the same option string. To get this behavior, the "

"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` ::"

#: ../Doc/library/argparse.rst:542

msgid ""

"Note that :class:`ArgumentParser` objects only remove an action if all of "

"its option strings are overridden. So, in the example above, the old ``-f/--"

"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."

#: ../Doc/library/argparse.rst:549

msgid "add_help"

msgstr "add_help"

#: ../Doc/library/argparse.rst:551

msgid ""

"By default, ArgumentParser objects add an option which simply displays the "

"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 ::"

#: ../Doc/library/argparse.rst:560

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é :"

#: ../Doc/library/argparse.rst:572

msgid ""

"Occasionally, it may be useful to disable the addition of this help option. "

"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` ::"

#: ../Doc/library/argparse.rst:584

msgid ""

"The help option is typically ``-h/--help``. The exception to this is if the "

"``prefix_chars=`` is specified and does not include ``-``, in which case ``-"

"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 ::"

#: ../Doc/library/argparse.rst:599

msgid "The add_argument() method"

msgstr "La méthode *add_argument()*"

#: ../Doc/library/argparse.rst:605

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 :"

#: ../Doc/library/argparse.rst:608

msgid ""

"`name or flags`_ - Either a name or a list of option strings, e.g. ``foo`` "

"or ``-f, --foo``."

msgstr ""

"`name_or_flags`_ – Nom ou liste de chaînes d'options. Par exemple : ``foo`` "

"ou ``-f, --foo`` ;"

#: ../Doc/library/argparse.rst:611

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 ;"

#: ../Doc/library/argparse.rst:614

msgid "nargs_ - The number of command-line arguments that should be consumed."

msgstr "nargs_ – Nombre d'arguments de la ligne de commande à capturer ;"

#: ../Doc/library/argparse.rst:616

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_ ;"

#: ../Doc/library/argparse.rst:618

msgid ""

"default_ - The value produced if the argument is absent from the command "

"line."

msgstr ""

#: ../Doc/library/argparse.rst:621

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 ;"

#: ../Doc/library/argparse.rst:623

msgid "choices_ - A container of the allowable values for the argument."

msgstr ""

"choices_ – Conteneur qui contient toutes les valeurs permises pour cet "

"argument ;"

#: ../Doc/library/argparse.rst:625

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) ;"

#: ../Doc/library/argparse.rst:628

msgid "help_ - A brief description of what the argument does."

msgstr "help_ – Brève description de ce que fait l'argument ;"

#: ../Doc/library/argparse.rst:630

msgid "metavar_ - A name for the argument in usage messages."

msgstr "metavar_ – Nom de l'argument dans les messages d'utilisations ;"

#: ../Doc/library/argparse.rst:632

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`."

#: ../Doc/library/argparse.rst:639

msgid "name or flags"

msgstr "nom ou option"

#: ../Doc/library/argparse.rst:641

msgid ""

"The :meth:`~ArgumentParser.add_argument` method must know whether an "

"optional argument, like ``-f`` or ``--foo``, or a positional argument, like "

"a list of filenames, is expected. The first arguments passed to :meth:"

"`~ArgumentParser.add_argument` must therefore be either a series of flags, "

"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 ::"

#: ../Doc/library/argparse.rst:650

msgid "while a positional argument could be created like::"

msgstr "alors qu'un argument positionnel est créé comme suit ::"

#: ../Doc/library/argparse.rst:654

msgid ""

"When :meth:`~ArgumentParser.parse_args` is called, optional arguments will "

"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 ::"

#: ../Doc/library/argparse.rst:671

msgid "action"

msgstr "action"

#: ../Doc/library/argparse.rst:673

msgid ""

":class:`ArgumentParser` objects associate command-line arguments with "

"actions. These actions can do just about anything with the command-line "

"arguments associated with them, though most actions simply add an attribute "

"to the object returned by :meth:`~ArgumentParser.parse_args`. The "

"``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 :"

#: ../Doc/library/argparse.rst:679

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 ::"

#: ../Doc/library/argparse.rst:687

msgid ""

"``'store_const'`` - This stores the value specified by the const_ keyword "

"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 ::"

#: ../Doc/library/argparse.rst:696

msgid ""

"``'store_true'`` and ``'store_false'`` - These are special cases of "

"``'store_const'`` using for storing the values ``True`` and ``False`` "

"respectively. In addition, they create default values of ``False`` and "

"``True`` respectively. For example::"

msgstr ""

#: ../Doc/library/argparse.rst:708

msgid ""

"``'append'`` - This stores a list, and appends each argument value to the "

"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 ::"

#: ../Doc/library/argparse.rst:717

msgid ""

"``'append_const'`` - This stores a list, and appends the value specified by "

"the const_ keyword argument to the list. (Note that the const_ keyword "

"argument defaults to ``None``.) The ``'append_const'`` action is typically "

"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 ::"

#: ../Doc/library/argparse.rst:729

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é ::"

#: ../Doc/library/argparse.rst:737

msgid ""

"``'help'`` - This prints a complete help message for all the options in the "

"current parser and then exits. By default a help action is automatically "

"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."

#: ../Doc/library/argparse.rst:742

msgid ""

"``'version'`` - This expects a ``version=`` keyword argument in the :meth:"

"`~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` ::"

#: ../Doc/library/argparse.rst:752

msgid ""

"You may also specify an arbitrary action by passing an Action subclass or "

"other object that implements the same interface. The recommended way to do "

"this is to extend :class:`Action`, overriding the ``__call__`` method and "

"optionally the ``__init__`` method."

msgstr ""

#: ../Doc/library/argparse.rst:757

msgid "An example of a custom action::"

msgstr "Un exemple d'action personnalisée : ::"

#: ../Doc/library/argparse.rst:777

msgid "For more details, see :class:`Action`."

msgstr "Pour plus d'information, voir :class:`Action`."

#: ../Doc/library/argparse.rst:780

msgid "nargs"

msgstr "nargs"

#: ../Doc/library/argparse.rst:782

msgid ""

"ArgumentParser objects usually associate a single command-line argument with "

"a single action to be taken. The ``nargs`` keyword argument associates a "

"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 :"

#: ../Doc/library/argparse.rst:787

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 ::"

#: ../Doc/library/argparse.rst:796

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)."

#: ../Doc/library/argparse.rst:799

msgid ""

"``'?'``. One argument will be consumed from the command line if possible, "

"and produced as a single item. If no command-line argument is present, the "

"value from default_ will be produced. Note that for optional arguments, "

"there is an additional case - the option string is present but not followed "

"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 ::"

#: ../Doc/library/argparse.rst:816

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 ::"

#: ../Doc/library/argparse.rst:831

msgid ""

"``'*'``. All command-line arguments present are gathered into a list. Note "

"that it generally doesn't make much sense to have more than one positional "

"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 ::"

#: ../Doc/library/argparse.rst:843

msgid ""

"``'+'``. Just like ``'*'``, all command-line args present are gathered into "

"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 ::"

#: ../Doc/library/argparse.rst:855

msgid ""

"``argparse.REMAINDER``. All the remaining command-line arguments are "

"gathered into a list. This is commonly useful for command line utilities "

"that dispatch to other command line utilities::"

msgstr ""

#: ../Doc/library/argparse.rst:866

msgid ""

"If the ``nargs`` keyword argument is not provided, the number of arguments "

"consumed is determined by the action_. Generally this means a single "

"command-line argument will be consumed and a single item (not a list) will "

"be produced."

msgstr ""