# SOME DESCRIPTIVE TITLE. # Copyright (C) 1990-2016, Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , 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 \n" "Language-Team: LANGUAGE \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 `." 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 `." #: ../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 "" "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." #: ../Doc/library/argparse.rst:872 msgid "const" msgstr "const" #: ../Doc/library/argparse.rst:874 msgid "" "The ``const`` argument of :meth:`~ArgumentParser.add_argument` is used to " "hold constant values that are not read from the command line but are " "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 :" #: ../Doc/library/argparse.rst:878 msgid "" "When :meth:`~ArgumentParser.add_argument` is called with " "``action='store_const'`` or ``action='append_const'``. These actions add " "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 ;" #: ../Doc/library/argparse.rst:883 msgid "" "When :meth:`~ArgumentParser.add_argument` is called with option strings " "(like ``-f`` or ``--foo``) and ``nargs='?'``. This creates an optional " "argument that can be followed by zero or one command-line arguments. When " "parsing the command line, if the option string is encountered with no " "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." #: ../Doc/library/argparse.rst:890 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``." #: ../Doc/library/argparse.rst:895 msgid "default" msgstr "default" #: ../Doc/library/argparse.rst:897 msgid "" "All optional arguments and some positional arguments may be omitted at the " "command line. The ``default`` keyword argument of :meth:`~ArgumentParser." "add_argument`, whose value defaults to ``None``, specifies what value should " "be used if the command-line argument is not present. For optional arguments, " "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 ::" #: ../Doc/library/argparse.rst:911 msgid "" "If the ``default`` value is a string, the parser parses the value as if it " "were a command-line argument. In particular, the parser applies any type_ " "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 ::" #: ../Doc/library/argparse.rst:922 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 ::" #: ../Doc/library/argparse.rst:933 msgid "" "Providing ``default=argparse.SUPPRESS`` causes no attribute to be added if " "the command-line argument was not present.::" msgstr "" #: ../Doc/library/argparse.rst:945 msgid "type" msgstr "type" #: ../Doc/library/argparse.rst:947 msgid "" "By default, :class:`ArgumentParser` objects read command-line arguments in " "as simple strings. However, quite often the command-line string should " "instead be interpreted as another type, like a :class:`float` or :class:" "`int`. The ``type`` keyword argument of :meth:`~ArgumentParser." "add_argument` allows any necessary type-checking and type conversions to be " "performed. Common built-in types and functions can be used directly as the " "value of the ``type`` argument::" msgstr "" #: ../Doc/library/argparse.rst:960 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." #: ../Doc/library/argparse.rst:963 msgid "" "To ease the use of various types of files, the argparse module provides the " "factory FileType which takes the ``mode=`` and ``bufsize=`` arguments of the " "``file`` object. For example, ``FileType('w')`` can be used to create a " "writable file::" msgstr "" #: ../Doc/library/argparse.rst:973 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 ::" #: ../Doc/library/argparse.rst:992 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 ::" #: ../Doc/library/argparse.rst:1003 msgid "See the choices_ section for more details." msgstr "Voir la section choices_ pour plus de détails." #: ../Doc/library/argparse.rst:1007 msgid "choices" msgstr "choices" #: ../Doc/library/argparse.rst:1009 msgid "" "Some command-line arguments should be selected from a restricted set of " "values. These can be handled by passing a container object as the *choices* " "keyword argument to :meth:`~ArgumentParser.add_argument`. When the command " "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 ::" #: ../Doc/library/argparse.rst:1024 msgid "" "Note that inclusion in the *choices* container is checked after any type_ " "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é ::" #: ../Doc/library/argparse.rst:1036 msgid "" "Any object that supports the ``in`` operator can be passed as the *choices* " "value, so :class:`dict` objects, :class:`set` objects, custom containers, " "etc. are all supported." msgstr "" #: ../Doc/library/argparse.rst:1042 msgid "required" msgstr "required" #: ../Doc/library/argparse.rst:1044 msgid "" "In general, the :mod:`argparse` module assumes that flags like ``-f`` and " "``--bar`` indicate *optional* arguments, which can always be omitted at the " "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` ::" #: ../Doc/library/argparse.rst:1057 msgid "" "As the example shows, if an option is marked as ``required``, :meth:" "`~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." #: ../Doc/library/argparse.rst:1063 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." #: ../Doc/library/argparse.rst:1068 msgid "help" msgstr "help" #: ../Doc/library/argparse.rst:1070 msgid "" "The ``help`` value is a string containing a brief description of the " "argument. When a user requests help (usually by using ``-h`` or ``--help`` " "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 ::" #: ../Doc/library/argparse.rst:1090 msgid "" "The ``help`` strings can include various format specifiers to avoid " "repetition of things like the program name or the argument default_. The " "available specifiers include the program name, ``%(prog)s`` and most keyword " "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. ::" #: ../Doc/library/argparse.rst:1107 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`` ::" #: ../Doc/library/argparse.rst:1120 msgid "metavar" msgstr "metavar" #: ../Doc/library/argparse.rst:1122 msgid "" "When :class:`ArgumentParser` generates help messages, it needs some way to " "refer to each expected argument. By default, ArgumentParser objects use the " "dest_ value as the \"name\" of each object. By default, for positional " "argument actions, the dest_ value is used directly, and for optional " "argument actions, the dest_ value is uppercased. So, a single positional " "argument with ``dest='bar'`` will be referred to as ``bar``. A single " "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 ::" #: ../Doc/library/argparse.rst:1146 msgid "An alternative name can be specified with ``metavar``::" msgstr "Un nom alternatif peut être fourni à ``metavar`` ::" #: ../Doc/library/argparse.rst:1163 msgid "" "Note that ``metavar`` only changes the *displayed* name - the name of the " "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_." #: ../Doc/library/argparse.rst:1167 msgid "" "Different values of ``nargs`` may cause the metavar to be used multiple " "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 ::" #: ../Doc/library/argparse.rst:1184 msgid "dest" msgstr "dest" #: ../Doc/library/argparse.rst:1186 msgid "" "Most :class:`ArgumentParser` actions add some value as an attribute of the " "object returned by :meth:`~ArgumentParser.parse_args`. The name of this " "attribute is determined by the ``dest`` keyword argument of :meth:" "`~ArgumentParser.add_argument`. For positional argument actions, ``dest`` " "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` ::" #: ../Doc/library/argparse.rst:1198 msgid "" "For optional argument actions, the value of ``dest`` is normally inferred " "from the option strings. :class:`ArgumentParser` generates the value of " "``dest`` by taking the first long option string and stripping away the " "initial ``--`` string. If no long option strings were supplied, ``dest`` " "will be derived from the first short option string by stripping the initial " "``-`` character. Any internal ``-`` characters will be converted to ``_`` " "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'options. :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`` est 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 la chaîne est un nom d'attribut valide. Les exemples suivants " "illustrent ce comportement ::" #: ../Doc/library/argparse.rst:1215 msgid "``dest`` allows a custom attribute name to be provided::" msgstr "``dest`` vous permet de fournir un nom d'attribut personnalisé ::" #: ../Doc/library/argparse.rst:1223 msgid "Action classes" msgstr "Classes Action" #: ../Doc/library/argparse.rst:1225 msgid "" "Action classes implement the Action API, a callable which returns a callable " "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`." #: ../Doc/library/argparse.rst:1233 msgid "" "Action objects are used by an ArgumentParser to represent the information " "needed to parse a single argument from one or more strings from the command " "line. The Action class must accept the two positional arguments plus any " "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``." #: ../Doc/library/argparse.rst:1238 msgid "" "Instances of Action (or return value of any callable to the ``action`` " "parameter) should have attributes \"dest\", \"option_strings\", \"default\", " "\"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__``." #: ../Doc/library/argparse.rst:1243 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 :" #: ../Doc/library/argparse.rst:1246 msgid "``parser`` - The ArgumentParser object which contains this action." msgstr "``parser`` – L'objet ``ArgumentParser`` qui contient cette action ;" #: ../Doc/library/argparse.rst:1248 msgid "" "``namespace`` - The :class:`Namespace` object that will be returned by :meth:" "`~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` ;" #: ../Doc/library/argparse.rst:1252 msgid "" "``values`` - The associated command-line arguments, with any type " "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` ;" #: ../Doc/library/argparse.rst:1256 msgid "" "``option_string`` - The option string that was used to invoke this action. " "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." #: ../Doc/library/argparse.rst:1260 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 affecte des attributs sur le ``namespace`` en fonction de " "``dest`` et de ``values``." #: ../Doc/library/argparse.rst:1265 msgid "The parse_args() method" msgstr "La méthode *parse_args()*" #: ../Doc/library/argparse.rst:1269 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." #: ../Doc/library/argparse.rst:1272 msgid "" "Previous calls to :meth:`add_argument` determine exactly what objects are " "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." #: ../Doc/library/argparse.rst:1276 msgid "" "By default, the argument strings are taken from :data:`sys.argv`, and a new " "empty :class:`Namespace` object is created for the attributes." msgstr "" #: ../Doc/library/argparse.rst:1281 msgid "Option value syntax" msgstr "Syntaxe de la valeur des options" #: ../Doc/library/argparse.rst:1283 msgid "" "The :meth:`~ArgumentParser.parse_args` method supports several ways of " "specifying the value of an option (if it takes one). In the simplest case, " "the option and its value are passed as two separate arguments::" msgstr "" "La méthode :meth:`~ArgumentParser.parse_args` offre plusieurs façons " "d'indiquer la valeur d'une option si elle en prend une. Dans le cas le plus " "simple, l'option et sa valeur sont passées en tant que deux arguments " "distincts ::" #: ../Doc/library/argparse.rst:1295 msgid "" "For long options (options with names longer than a single character), the " "option and value can also be passed as a single command-line argument, using " "``=`` to separate them::" msgstr "" "Pour les options longues (les options qui ont un nom plus long qu'un seul " "caractère), l'option et sa valeur peuvent être passées comme un seul " "argument de la ligne de commande en utilisant ``=`` comme séparateur ::" #: ../Doc/library/argparse.rst:1302 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 ::" #: ../Doc/library/argparse.rst:1308 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 ::" #: ../Doc/library/argparse.rst:1320 msgid "Invalid arguments" msgstr "Arguments invalides" #: ../Doc/library/argparse.rst:1322 msgid "" "While parsing the command line, :meth:`~ArgumentParser.parse_args` checks " "for a variety of errors, including ambiguous options, invalid types, invalid " "options, wrong number of positional arguments, etc. When it encounters such " "an error, it exits and prints the error along with a usage message::" msgstr "" "Quand elle fait l'analyse de la ligne de commande, la méthode :meth:" "`~ArgumentParser.parse_args` vérifie plusieurs erreurs possibles : entre " "autres, options ambigües, types invalides, options invalides, nombre " "incorrect d'arguments positionnels, etc. Quand une erreur est rencontrée, " "elle affiche l'erreur accompagnée du message d'aide puis termine " "l'exécution ::" #: ../Doc/library/argparse.rst:1348 msgid "Arguments containing ``-``" msgstr "Arguments contenant ``-``" #: ../Doc/library/argparse.rst:1350 msgid "" "The :meth:`~ArgumentParser.parse_args` method attempts to give errors " "whenever the user has clearly made a mistake, but some situations are " "inherently ambiguous. For example, the command-line argument ``-1`` could " "either be an attempt to specify an option or an attempt to provide a " "positional argument. The :meth:`~ArgumentParser.parse_args` method is " "cautious here: positional arguments may only begin with ``-`` if they look " "like negative numbers and there are no options in the parser that look like " "negative numbers::" msgstr "" "La méthode :meth:`~ArgumentParser.parse_args` tente de signaler une erreur " "quand l'utilisateur s'est clairement trompé. Par contre, certaines " "situations sont intrinsèquement ambigües. Par exemple, l'argument de la " "ligne de commande ``-1`` peut aussi bien être une tentative de spécifier une " "option qu'une tentative de passer un argument positionnel. La méthode :meth:" "`~ArgumentParser.parse_args` est prudente : les arguments positionnels ne " "peuvent commencer par ``-`` que s'ils ont l'apparence d'un nombre négatif et " "que l'analyseur ne contient aucune option qui a l'apparence d'un nombre " "négatif ::" #: ../Doc/library/argparse.rst:1388 msgid "" "If you have positional arguments that must begin with ``-`` and don't look " "like negative numbers, you can insert the pseudo-argument ``'--'`` which " "tells :meth:`~ArgumentParser.parse_args` that everything after that is a " "positional argument::" msgstr "" "Si l'utilisateur a des arguments positionnels qui commencent par ``-`` et " "qui n'ont pas l'apparence d'un nombre négatif, il peut insérer le pseudo-" "argument ``'--'`` qui indique à :meth:`~ArgumentParser.parse_args` de " "traiter tout ce qui suit comme un argument positionnel ::" #: ../Doc/library/argparse.rst:1399 msgid "Argument abbreviations (prefix matching)" msgstr "Arguments abrégés (Part comparaison de leur préfixes)" #: ../Doc/library/argparse.rst:1401 msgid "" "The :meth:`~ArgumentParser.parse_args` method allows long options to be " "abbreviated to a prefix, if the abbreviation is unambiguous (the prefix " "matches a unique option)::" msgstr "" #: ../Doc/library/argparse.rst:1416 msgid "" "An error is produced for arguments that could produce more than one options." msgstr "" #: ../Doc/library/argparse.rst:1420 msgid "Beyond ``sys.argv``" msgstr "Au delà de ``sys.argv``" #: ../Doc/library/argparse.rst:1422 msgid "" "Sometimes it may be useful to have an ArgumentParser parse arguments other " "than those of :data:`sys.argv`. This can be accomplished by passing a list " "of strings to :meth:`~ArgumentParser.parse_args`. This is useful for " "testing at the interactive prompt::" msgstr "" "Il est parfois désirable de demander à un objet ``ArgumentParser`` de faire " "l'analyse d'arguments autres que ceux de :data:`sys.argv`. On peut faire ce " "traitement en passant une liste de chaînes à :meth:`~ArgumentParser." "parse_args`. Cette approche est pratique pour faire des tests depuis " "l'invite de commande ::" #: ../Doc/library/argparse.rst:1441 msgid "The Namespace object" msgstr "L'objet namespace" #: ../Doc/library/argparse.rst:1445 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``." #: ../Doc/library/argparse.rst:1448 msgid "" "This class is deliberately simple, just an :class:`object` subclass with a " "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) ::" #: ../Doc/library/argparse.rst:1458 msgid "" "It may also be useful to have an :class:`ArgumentParser` assign attributes " "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=`` ::" #: ../Doc/library/argparse.rst:1474 msgid "Other utilities" msgstr "Autres outils" #: ../Doc/library/argparse.rst:1477 msgid "Sub-commands" msgstr "Sous commandes" #: ../Doc/library/argparse.rst:1484 msgid "" "Many programs split up their functionality into a number of sub-commands, " "for example, the ``svn`` program can invoke sub-commands like ``svn " "checkout``, ``svn update``, and ``svn commit``. Splitting up functionality " "this way can be a particularly good idea when a program performs several " "different functions which require different kinds of command-line " "arguments. :class:`ArgumentParser` supports the creation of such sub-" "commands with the :meth:`add_subparsers` method. The :meth:`add_subparsers` " "method is normally called with no arguments and returns a special action " "object. This object has a single method, :meth:`~ArgumentParser." "add_parser`, which takes a command name and any :class:`ArgumentParser` " "constructor arguments, and returns an :class:`ArgumentParser` object that " "can be modified as usual." msgstr "" "Certains programmes divisent leurs fonctionnalités entre un nombre de sous-" "commandes. Par exemple : le programme ``svn`` peut être invoqué comme ``svn " "checkout``, ``svn update`` et ``svn commit``. Séparer les fonctionnalités de " "cette façon est judicieux quand le programme effectue plusieurs fonctions " "différentes qui requièrent différents types de lignes de commandes. :class:" "`ArgumentParser` prend en charge la création de ce genre de sous-commandes " "grâce à la méthode :meth:`add_subparsers`. La méthode :meth:`add_subparsers` " "est généralement appelée sans argument et elle renvoie un objet ``Action`` " "spécial. Cet objet possède une seule méthode, :meth:`~ArgumentParser." "add_parser`, qui prend le nom d'une commande et n'importe quels arguments du " "constructeur d':class:`ArgumentParser` ; elle renvoie un objet :class:" "`ArgumentParser` qui peut être modifié normalement." #: ../Doc/library/argparse.rst:1496 msgid "Description of parameters:" msgstr "Description des paramètres" #: ../Doc/library/argparse.rst:1498 msgid "" "title - title for the sub-parser group in help output; by default " "\"subcommands\" if description is provided, otherwise uses title for " "positional arguments" msgstr "" "``title`` – titre du groupe de ce sous-analyseur dans la sortie d'aide ; par " "défaut : ``\"subcommands\"`` si ``description`` est fournie, sinon utilise " "la valeur de ``title`` de la section sur les arguments positionnels ;" #: ../Doc/library/argparse.rst:1502 msgid "" "description - description for the sub-parser group in help output, by " "default ``None``" msgstr "" "``description`` – description du groupe de ce sous-analyseur dans la sortie " "d'aide ; par défaut : ``None`` ;" #: ../Doc/library/argparse.rst:1505 msgid "" "prog - usage information that will be displayed with sub-command help, by " "default the name of the program and any positional arguments before the " "subparser argument" msgstr "" "``prog`` – nom du programme dans le message d'utilisation de l'aide des sous-" "commandes ; par défaut : le nom du programme et les arguments positionnels " "qui arrivent avant l'argument de ce sous-analyseur ;" #: ../Doc/library/argparse.rst:1509 msgid "" "parser_class - class which will be used to create sub-parser instances, by " "default the class of the current parser (e.g. ArgumentParser)" msgstr "" "``parser_class`` – classe utilisée pour créer les instances de sous-" "analyseurs ; par défaut : la classe de l'analyseur courant (par exemple " "``ArgumentParser``) ;" #: ../Doc/library/argparse.rst:1512 msgid "" "action_ - the basic type of action to be taken when this argument is " "encountered at the command line" msgstr "" "action_ – action à entreprendre quand cet argument est reconnu sur la ligne " "de commande ;" #: ../Doc/library/argparse.rst:1515 msgid "" "dest_ - name of the attribute under which sub-command name will be stored; " "by default ``None`` and no value is stored" msgstr "" "dest_ – nom de l'attribut sous lequel la sous-commande est stockée ; par " "défaut : ``None`` et aucune valeur n'est stockée ;" #: ../Doc/library/argparse.rst:1518 msgid "help_ - help for sub-parser group in help output, by default ``None``" msgstr "" "help_ – message d'aide pour le groupe du sous-analyseur dans la sortie " "d'aide ; par défaut : ``None`` ;" #: ../Doc/library/argparse.rst:1520 msgid "" "metavar_ - string presenting available sub-commands in help; by default it " "is ``None`` and presents sub-commands in form {cmd1, cmd2, ..}" msgstr "" "metavar_ – chaîne qui représente les sous-commandes disponibles dans les " "messages d'aide ; par défaut : ``None``, ce qui entraine la génération d'une " "chaîne suivant le format ``'{cmd1, cmd2, …}'``." #: ../Doc/library/argparse.rst:1523 msgid "Some example usage::" msgstr "Quelques exemples d'utilisation : ::" #: ../Doc/library/argparse.rst:1544 msgid "" "Note that the object returned by :meth:`parse_args` will only contain " "attributes for the main parser and the subparser that was selected by the " "command line (and not any other subparsers). So in the example above, when " "the ``a`` command is specified, only the ``foo`` and ``bar`` attributes are " "present, and when the ``b`` command is specified, only the ``foo`` and " "``baz`` attributes are present." msgstr "" "Prenez note que l'objet renvoyé par :meth:`parse_args` ne contient que les " "attributs reconnus par l'analyseur principal et le sous-analyseur " "sélectionné par la ligne de commande. Les autres sous-analyseurs n'ont pas " "d'influence sur l'objet renvoyé. Ainsi dans l'exemple précédent, quand la " "commande ``a`` est spécifiée, seuls les attributs ``foo`` et ``bar`` sont " "présents ; quand la commande ``b`` est spécifiée, seuls les attributs " "``foo`` et ``baz`` sont présents." #: ../Doc/library/argparse.rst:1551 msgid "" "Similarly, when a help message is requested from a subparser, only the help " "for that particular parser will be printed. The help message will not " "include parent parser or sibling parser messages. (A help message for each " "subparser command, however, can be given by supplying the ``help=`` argument " "to :meth:`add_parser` as above.)" msgstr "" "De même, quand le message d'aide est demandé depuis l'un des sous-" "analyseurs, seul le message d'aide de cet analyseur est affiché. Le message " "d'aide n'inclut pas le message de l'analyseur parent ni celui des sous-" "analyseurs au même niveau. Il est toutefois possible de fournir un message " "d'aide pour chacun des sous-analyseurs grâce à l'argument ``help=`` d':meth:" "`add_parser` tel qu'illustré ci-dessus." #: ../Doc/library/argparse.rst:1587 msgid "" "The :meth:`add_subparsers` method also supports ``title`` and " "``description`` keyword arguments. When either is present, the subparser's " "commands will appear in their own group in the help output. For example::" msgstr "" "La méthode :meth:`add_subparsers` accepte les arguments nommés ``title`` et " "``description``. Quand au moins l'un des deux est présent, les commandes du " "sous-analyseur sont affichées dans leur propre groupe dans la sortie d'aide. " "Par exemple ::" #: ../Doc/library/argparse.rst:1609 msgid "" "One particularly effective way of handling sub-commands is to combine the " "use of the :meth:`add_subparsers` method with calls to :meth:`set_defaults` " "so that each subparser knows which Python function it should execute. For " "example::" msgstr "" "Une façon efficace de traiter les sous-commandes est de combiner " "l'utilisation de la méthode :meth:`add_subparsers` avec des appels à :meth:" "`set_defaults` pour que chaque sous-analyseur sache quelle fonction Python " "doit être exécutée. Par exemple ::" #: ../Doc/library/argparse.rst:1646 msgid "" "This way, you can let :meth:`parse_args` do the job of calling the " "appropriate function after argument parsing is complete. Associating " "functions with actions like this is typically the easiest way to handle the " "different actions for each of your subparsers. However, if it is necessary " "to check the name of the subparser that was invoked, the ``dest`` keyword " "argument to the :meth:`add_subparsers` call will work::" msgstr "" "Ainsi, vous pouvez laisser à :meth:`parse_args` la responsabilité de faire " "l'appel à la bonne fonction après avoir analysé les arguments. Associer " "fonctions et actions est en général la façon la plus facile de gérer des " "actions différentes pour chacun de vos sous-analyseurs. Par contre, si vous " "avez besoin de consulter le nom de du sous-analyseur qui a été invoqué, vous " "pouvez utiliser l'argument nommé ``dest`` d':meth:`add_subparsers` ::" #: ../Doc/library/argparse.rst:1664 msgid "FileType objects" msgstr "Objets ``FileType``" #: ../Doc/library/argparse.rst:1668 msgid "" "The :class:`FileType` factory creates objects that can be passed to the type " "argument of :meth:`ArgumentParser.add_argument`. Arguments that have :class:" "`FileType` objects as their type will open command-line arguments as files " "with the requested modes and buffer sizes::" msgstr "" #: ../Doc/library/argparse.rst:1678 msgid "" "FileType objects understand the pseudo-argument ``'-'`` and automatically " "convert this into ``sys.stdin`` for readable :class:`FileType` objects and " "``sys.stdout`` for writable :class:`FileType` objects::" msgstr "" "Les objets ``FileType`` reconnaissent le pseudo-argument ``'-'`` et en font " "automatiquement la conversion vers ``sys.stdin`` pour les objets :class:" "`FileType` ouverts en lecture et vers ``sys.stdout`` pour les objets :class:" "`FileType` ouverts en écriture ::" #: ../Doc/library/argparse.rst:1689 msgid "Argument groups" msgstr "Groupes d'arguments" #: ../Doc/library/argparse.rst:1693 msgid "" "By default, :class:`ArgumentParser` groups command-line arguments into " "\"positional arguments\" and \"optional arguments\" when displaying help " "messages. When there is a better conceptual grouping of arguments than this " "default one, appropriate groups can be created using the :meth:" "`add_argument_group` method::" msgstr "" "Par défaut, :class:`ArgumentParser` sépare les arguments de la ligne de " "commande entre les groupes « arguments positionnels » et « arguments " "optionnels » au moment d'afficher les messages d'aide. S'il existe un " "meilleur regroupement conceptuel des arguments, les groupes adéquats peuvent " "être créés avec la méthode :meth:`add_argument_group` ::" #: ../Doc/library/argparse.rst:1710 msgid "" "The :meth:`add_argument_group` method returns an argument group object which " "has an :meth:`~ArgumentParser.add_argument` method just like a regular :" "class:`ArgumentParser`. When an argument is added to the group, the parser " "treats it just like a normal argument, but displays the argument in a " "separate group for help messages. The :meth:`add_argument_group` method " "accepts *title* and *description* arguments which can be used to customize " "this display::" msgstr "" "La méthode :meth:`add_argument_group` renvoie un objet représentant le " "groupe d'arguments. Cet objet possède une méthode :meth:`~ArgumentParser." "add_argument` semblable à celle d':class:`ArgumentParser`. Quand un argument " "est ajouté au groupe, l'analyseur le traite comme un argument normal, mais " "il affiche le nouvel argument dans un groupe séparé dans les messages " "d'aide. Afin de personnaliser l'affichage, la méthode :meth:" "`add_argument_group` accepte les arguments ``title`` et ``description`` ::" #: ../Doc/library/argparse.rst:1736 msgid "" "Note that any arguments not in your user-defined groups will end up back in " "the usual \"positional arguments\" and \"optional arguments\" sections." msgstr "" "Prenez note que tout argument qui n'est pas dans l'un de vos groupes est " "affiché dans l'une des sections usuelles *positional arguments* et *optional " "arguments*." #: ../Doc/library/argparse.rst:1741 msgid "Mutual exclusion" msgstr "Exclusion mutuelle" #: ../Doc/library/argparse.rst:1745 msgid "" "Create a mutually exclusive group. :mod:`argparse` will make sure that only " "one of the arguments in the mutually exclusive group was present on the " "command line::" msgstr "" "Crée un groupe mutuellement exclusif. Le module :mod:`argparse` vérifie " "qu'au plus un des arguments du groupe mutuellement exclusif est présent sur " "la ligne de commande ::" #: ../Doc/library/argparse.rst:1761 msgid "" "The :meth:`add_mutually_exclusive_group` method also accepts a *required* " "argument, to indicate that at least one of the mutually exclusive arguments " "is required::" msgstr "" "La méthode :meth:`add_mutually_exclusive_group` accepte aussi l'argument " "``required`` pour indiquer qu'au moins un des arguments mutuellement " "exclusifs est nécessaire ::" #: ../Doc/library/argparse.rst:1773 msgid "" "Note that currently mutually exclusive argument groups do not support the " "*title* and *description* arguments of :meth:`~ArgumentParser." "add_argument_group`." msgstr "" "Prenez note que présentement les groupes d'arguments mutuellement exclusifs " "n'acceptent pas les arguments ``title`` et ``description`` d':meth:" "`~ArgumentParser.add_argument_group`." #: ../Doc/library/argparse.rst:1779 msgid "Parser defaults" msgstr "Valeurs par défaut de l'analyseur" #: ../Doc/library/argparse.rst:1783 msgid "" "Most of the time, the attributes of the object returned by :meth:" "`parse_args` will be fully determined by inspecting the command-line " "arguments and the argument actions. :meth:`set_defaults` allows some " "additional attributes that are determined without any inspection of the " "command line to be added::" msgstr "" "Dans la majorité des cas, les attributs de l'objet renvoyé par :meth:" "`parse_args` sont entièrement définis par l'inspection des arguments de la " "ligne de commande et par les actions des arguments. La méthode :meth:" "`set_defaults` permet l'ajout d'attributs additionnels qui sont définis sans " "nécessiter l'inspection de la ligne de commande ::" #: ../Doc/library/argparse.rst:1795 msgid "" "Note that parser-level defaults always override argument-level defaults::" msgstr "" "Prenez note que les valeurs par défaut au niveau de l'analyseur ont " "précédence sur les valeurs par défaut au niveau de l'argument ::" #: ../Doc/library/argparse.rst:1803 msgid "" "Parser-level defaults can be particularly useful when working with multiple " "parsers. See the :meth:`~ArgumentParser.add_subparsers` method for an " "example of this type." msgstr "" "Les valeurs par défaut au niveau de l'analyseur sont particulièrement utiles " "quand on travaille avec plusieurs analyseurs. Voir la méthode :meth:" "`~ArgumentParser.add_subparsers` pour un exemple de cette utilisation." #: ../Doc/library/argparse.rst:1809 msgid "" "Get the default value for a namespace attribute, as set by either :meth:" "`~ArgumentParser.add_argument` or by :meth:`~ArgumentParser.set_defaults`::" msgstr "" "Renvoie la valeur par défaut d'un attribut de l'objet ``Namespace`` tel " "qu'il a été défini soit par :meth:`~ArgumentParser.add_argument` ou par :" "meth:`~ArgumentParser.set_defaults` ::" #: ../Doc/library/argparse.rst:1820 msgid "Printing help" msgstr "Afficher l'aide" #: ../Doc/library/argparse.rst:1822 msgid "" "In most typical applications, :meth:`~ArgumentParser.parse_args` will take " "care of formatting and printing any usage or error messages. However, " "several formatting methods are available:" msgstr "" "Pour la majorité des applications, :meth:`~ArgumentParser.parse_args` se " "charge du formatage et de l'affichage des messages d'erreur et " "d'utilisation. Plusieurs méthodes de formatage sont toutefois disponibles :" #: ../Doc/library/argparse.rst:1828 msgid "" "Print a brief description of how the :class:`ArgumentParser` should be " "invoked on the command line. If *file* is ``None``, :data:`sys.stdout` is " "assumed." msgstr "" "Affiche une brève description sur la façon d'invoquer l':class:" "`ArgumentParser` depuis la ligne de commande. Si ``file`` est ``None``, " "utilise :data:`sys.stdout`." #: ../Doc/library/argparse.rst:1834 msgid "" "Print a help message, including the program usage and information about the " "arguments registered with the :class:`ArgumentParser`. If *file* is " "``None``, :data:`sys.stdout` is assumed." msgstr "" "Affiche un message d'aide qui inclut l'utilisation du programme et " "l'information sur les arguments répertoriés dans l':class:`ArgumentParser`. " "Si ``file`` est ``None``, utilise :data:`sys.stdout`." #: ../Doc/library/argparse.rst:1838 msgid "" "There are also variants of these methods that simply return a string instead " "of printing it:" msgstr "" "Des variantes de ces méthodes sont fournies pour renvoyer la chaîne plutôt " "que de l'afficher :" #: ../Doc/library/argparse.rst:1843 msgid "" "Return a string containing a brief description of how the :class:" "`ArgumentParser` should be invoked on the command line." msgstr "" "Renvoie une chaîne contenant une brève description sur la façon d'invoquer " "l':class:`ArgumentParser` depuis la ligne de commande." #: ../Doc/library/argparse.rst:1848 msgid "" "Return a string containing a help message, including the program usage and " "information about the arguments registered with the :class:`ArgumentParser`." msgstr "" "Renvoie une chaîne représentant un message d'aide qui inclut des " "informations sur l'utilisation du programme et sur les arguments définis " "dans l':class:`ArgumentParser`." #: ../Doc/library/argparse.rst:1853 msgid "Partial parsing" msgstr "*Parsing* partiel" #: ../Doc/library/argparse.rst:1857 msgid "" "Sometimes a script may only parse a few of the command-line arguments, " "passing the remaining arguments on to another script or program. In these " "cases, the :meth:`~ArgumentParser.parse_known_args` method can be useful. " "It works much like :meth:`~ArgumentParser.parse_args` except that it does " "not produce an error when extra arguments are present. Instead, it returns " "a two item tuple containing the populated namespace and the list of " "remaining argument strings." msgstr "" "Parfois, un script n'analyse que de quelques-uns des arguments de la ligne " "de commande avant de passer les arguments non-traités à un autre script ou " "un autre programme. La méthode :meth:`~ArgumentParser.parse_known_args` est " "utile dans ces cas. Elle fonctionne similairement à :meth:`~ArgumentParser." "parse_args`, mais elle ne lève pas d'erreur quand des arguments non-reconnus " "sont présents. Au lieu, elle renvoie une paire de valeurs : l'objet " "``Namespace`` rempli et la liste des arguments non-traités." #: ../Doc/library/argparse.rst:1873 msgid "" ":ref:`Prefix matching ` rules apply to :meth:" "`parse_known_args`. The parser may consume an option even if it's just a " "prefix of one of its known options, instead of leaving it in the remaining " "arguments list." msgstr "" "Les règles d':ref:`acceptation des abréviations ` sont " "applicables à :meth:`parse_known_args`. L'analyseur peut ainsi capturer une " "option même si elle n'est que le préfixe d'une option reconnue plutôt que de " "la laisser dans la liste des arguments non-traités." #: ../Doc/library/argparse.rst:1880 msgid "Customizing file parsing" msgstr "Personnaliser le *parsing* de fichiers" #: ../Doc/library/argparse.rst:1884 msgid "" "Arguments that are read from a file (see the *fromfile_prefix_chars* keyword " "argument to the :class:`ArgumentParser` constructor) are read one argument " "per line. :meth:`convert_arg_line_to_args` can be overridden for fancier " "reading." msgstr "" "Les arguments qui proviennent d'un fichier sont lus un par ligne. La " "méthode :meth:`convert_arg_line_to_args` peut être surchargée pour accomplir " "un traitement plus élaboré. Voir aussi l'argument nommé " "``fromfile_prefix_chars`` du constructeur d':class:`ArgumentParser`." #: ../Doc/library/argparse.rst:1889 msgid "" "This method takes a single argument *arg_line* which is a string read from " "the argument file. It returns a list of arguments parsed from this string. " "The method is called once per line read from the argument file, in order." msgstr "" "La méthode ``convert_arg_line_to_args`` accepte un seul argument, " "``arg_line``, qui est une chaîne lue dans le fichier d'arguments. Elle " "renvoie une liste d'arguments analysés dans cette chaîne. La méthode est " "appelée une fois pour chaque ligne lue du fichier d'arguments. L'ordre est " "préservé." #: ../Doc/library/argparse.rst:1893 msgid "" "A useful override of this method is one that treats each space-separated " "word as an argument::" msgstr "" #: ../Doc/library/argparse.rst:1901 msgid "Exiting methods" msgstr "Méthodes d'interruptions" #: ../Doc/library/argparse.rst:1905 msgid "" "This method terminates the program, exiting with the specified *status* and, " "if given, it prints a *message* before that." msgstr "" #: ../Doc/library/argparse.rst:1910 msgid "" "This method prints a usage message including the *message* to the standard " "error and terminates the program with a status code of 2." msgstr "" "Cette méthode affiche un message d'utilisation qui inclut la chaîne " "``message`` sur la sortie d'erreur standard puis termine l'exécution avec le " "code de fin d'exécution 2." #: ../Doc/library/argparse.rst:1917 msgid "Upgrading optparse code" msgstr "Mettre à jour du code ``optparse``" #: ../Doc/library/argparse.rst:1919 msgid "" "Originally, the :mod:`argparse` module had attempted to maintain " "compatibility with :mod:`optparse`. However, :mod:`optparse` was difficult " "to extend transparently, particularly with the changes required to support " "the new ``nargs=`` specifiers and better usage messages. When most " "everything in :mod:`optparse` had either been copy-pasted over or monkey-" "patched, it no longer seemed practical to try to maintain the backwards " "compatibility." msgstr "" "Initialement, le module :mod:`argparse` tentait de rester compatible avec :" "mod:`optparse`. Hélas, il était difficile de faire des améliorations à :mod:" "`optparse` de façon transparente, en particulier pour les changements requis " "pour gérer les nouveaux spécificateurs de ``nargs=`` et les messages " "d'utilisation améliorés. Après avoir porté ou surchargé tout le code d':mod:" "`optparse`, la rétro-compatibilité pouvait difficilement être conservée." #: ../Doc/library/argparse.rst:1926 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 :" #: ../Doc/library/argparse.rst:1929 msgid "Handling positional arguments." msgstr "Gérer les arguments positionnels." #: ../Doc/library/argparse.rst:1930 msgid "Supporting sub-commands." msgstr "Gérer les sous commandes." #: ../Doc/library/argparse.rst:1931 msgid "Allowing alternative option prefixes like ``+`` and ``/``." msgstr "" "Permet d'utiliser les alternatives ``+`` ou ``/`` comme préfixes d'option ;" #: ../Doc/library/argparse.rst:1932 msgid "Handling zero-or-more and one-or-more style arguments." msgstr "Prend en charge la répétition de valeurs (zéro ou plus, un ou plus) ;" #: ../Doc/library/argparse.rst:1933 msgid "Producing more informative usage messages." msgstr "Fournir des message d'aide plus complets." #: ../Doc/library/argparse.rst:1934 msgid "Providing a much simpler interface for custom ``type`` and ``action``." msgstr "" "Fournit une interface plus simple pour les types et les actions " "personnalisés." #: ../Doc/library/argparse.rst:1936 msgid "A partial upgrade path from :mod:`optparse` to :mod:`argparse`:" msgstr "Le portage partiel d':mod:`optparse` à :mod:`argparse` :" #: ../Doc/library/argparse.rst:1938 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` ;" #: ../Doc/library/argparse.rst:1941 msgid "" "Replace ``(options, args) = parser.parse_args()`` with ``args = parser." "parse_args()`` and add additional :meth:`ArgumentParser.add_argument` calls " "for the positional arguments. Keep in mind that what was previously called " "``options``, now in :mod:`argparse` context is called ``args``." msgstr "" #: ../Doc/library/argparse.rst:1946 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`` ;" #: ../Doc/library/argparse.rst:1949 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) ;" #: ../Doc/library/argparse.rst:1952 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` ;" #: ../Doc/library/argparse.rst:1956 msgid "" "Replace strings with implicit arguments such as ``%default`` or ``%prog`` " "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``) ;" #: ../Doc/library/argparse.rst:1960 msgid "" "Replace the OptionParser constructor ``version`` argument with a call to " "``parser.add_argument('--version', action='version', version='')``." msgstr "" "Remplacer l'argument ``version`` du constructeur d'``OptionParser`` par un " "appel à ``parser.add_argument('--version', action='version', version='')``."