forked from AFPy/python-docs-fr
2657 lines
116 KiB
Plaintext
2657 lines
116 KiB
Plaintext
# Copyright (C) 2001-2018, Python Software Foundation
|
||
# For licence information, see README file.
|
||
#
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 3\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2021-01-27 19:26+0100\n"
|
||
"PO-Revision-Date: 2021-02-09 11:07-0700\n"
|
||
"Last-Translator: Yannick Gingras <ygingras@ygingras.net>\n"
|
||
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
||
"Language: fr\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
"X-Generator: Poedit 2.4.1\n"
|
||
|
||
#: 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"
|
||
|
||
#: library/argparse.rst:12
|
||
msgid "**Source code:** :source:`Lib/argparse.py`"
|
||
msgstr "**Code source:** :source:`Lib/argparse.py`"
|
||
|
||
#: library/argparse.rst:None
|
||
msgid "Tutorial"
|
||
msgstr "Tutoriel"
|
||
|
||
#: library/argparse.rst:18
|
||
msgid ""
|
||
"This page contains the API reference information. For a more gentle "
|
||
"introduction to Python command-line parsing, have a look at the :ref:"
|
||
"`argparse tutorial <argparse-tutorial>`."
|
||
msgstr ""
|
||
"Cette page est la référence de l'API. Pour une introduction plus en douceur "
|
||
"à l'analyse des arguments de la ligne de commande, regardez :ref:`le "
|
||
"tutoriel argparse <argparse-tutorial>`."
|
||
|
||
#: library/argparse.rst:22
|
||
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."
|
||
|
||
#: library/argparse.rst:30
|
||
msgid "Example"
|
||
msgstr "Exemple"
|
||
|
||
#: library/argparse.rst:32
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:47
|
||
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 :"
|
||
|
||
#: library/argparse.rst:64
|
||
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 :"
|
||
|
||
#: library/argparse.rst:75
|
||
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 :"
|
||
|
||
#: library/argparse.rst:83
|
||
msgid "The following sections walk you through this example."
|
||
msgstr "Les sections suivantes vous guident au travers de cet exemple."
|
||
|
||
#: library/argparse.rst:87
|
||
msgid "Creating a parser"
|
||
msgstr "Créer un analyseur (*parser* en anglais)"
|
||
|
||
#: library/argparse.rst:89
|
||
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` ::"
|
||
|
||
#: library/argparse.rst:94
|
||
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."
|
||
|
||
#: library/argparse.rst:99
|
||
msgid "Adding arguments"
|
||
msgstr "Ajouter des arguments"
|
||
|
||
#: library/argparse.rst:101
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:113
|
||
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."
|
||
|
||
#: library/argparse.rst:121
|
||
msgid "Parsing arguments"
|
||
msgstr "Analyse des arguments"
|
||
|
||
#: library/argparse.rst:123
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:132
|
||
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`."
|
||
|
||
#: library/argparse.rst:138
|
||
msgid "ArgumentParser objects"
|
||
msgstr "Objets ``ArgumentParser``"
|
||
|
||
#: library/argparse.rst:147
|
||
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 :"
|
||
|
||
#: library/argparse.rst:151
|
||
msgid "prog_ - The name of the program (default: ``sys.argv[0]``)"
|
||
msgstr "prog_ – Nom du programme (par défaut : ``sys.argv[0]``) ;"
|
||
|
||
#: library/argparse.rst:153
|
||
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) ;"
|
||
|
||
#: library/argparse.rst:156
|
||
msgid "description_ - Text to display before the argument help (default: none)"
|
||
msgstr ""
|
||
"description_ – Texte à afficher avant l'aide des arguments (par défaut : "
|
||
"vide) ;"
|
||
|
||
#: library/argparse.rst:158
|
||
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) ;"
|
||
|
||
#: library/argparse.rst:160
|
||
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 ;"
|
||
|
||
#: library/argparse.rst:163
|
||
msgid "formatter_class_ - A class for customizing the help output"
|
||
msgstr ""
|
||
"formatter_class_ – Classe pour personnaliser la sortie du message d'aide ;"
|
||
|
||
#: library/argparse.rst:165
|
||
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 : ``'-'``) ;"
|
||
|
||
#: library/argparse.rst:168
|
||
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``) ;"
|
||
|
||
#: library/argparse.rst:171
|
||
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``) ;"
|
||
|
||
#: library/argparse.rst:174
|
||
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) ;"
|
||
|
||
#: library/argparse.rst:177
|
||
msgid ""
|
||
"add_help_ - Add a ``-h/--help`` option to the parser (default: ``True``)"
|
||
msgstr ""
|
||
"add_help_ – Ajoute une option d'aide ``-h/--help`` à l'analyseur (par "
|
||
"défaut : ``True``) ;"
|
||
|
||
#: library/argparse.rst:179
|
||
msgid ""
|
||
"allow_abbrev_ - Allows long options to be abbreviated if the abbreviation is "
|
||
"unambiguous. (default: ``True``)"
|
||
msgstr ""
|
||
"allow_abbrev_ – Permet l'acceptation d'abréviations non-ambigües pour les "
|
||
"options longues (par défaut : ``True``) ;"
|
||
|
||
#: library/argparse.rst:182
|
||
msgid ""
|
||
"exit_on_error_ - Determines whether or not ArgumentParser exits with error "
|
||
"info when an error occurs. (default: ``True``)"
|
||
msgstr ""
|
||
"exit_on_error_ – Détermine si l'objet ``ArgumentParser`` termine l'exécution "
|
||
"avec un message d'erreur quand une erreur est rencontrée (par défaut : "
|
||
"``True``)."
|
||
|
||
#: library/argparse.rst:185
|
||
msgid "*allow_abbrev* parameter was added."
|
||
msgstr "Le paramètre *allow_abbrev* est ajouté."
|
||
|
||
#: library/argparse.rst:188
|
||
msgid ""
|
||
"In previous versions, *allow_abbrev* also disabled grouping of short flags "
|
||
"such as ``-vv`` to mean ``-v -v``."
|
||
msgstr ""
|
||
"Dans les versions précédentes, *allow_abbrev* désactivait aussi le "
|
||
"regroupement de plusieurs options courtes telles que ``-vv`` pour signifier "
|
||
"``-v -v``."
|
||
|
||
#: library/argparse.rst:192
|
||
msgid "*exit_on_error* parameter was added."
|
||
msgstr "Le paramètre *exit_on_error* est ajouté."
|
||
|
||
#: library/argparse.rst:715
|
||
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."
|
||
|
||
#: library/argparse.rst:199
|
||
msgid "prog"
|
||
msgstr "Le paramètre *prog*"
|
||
|
||
#: library/argparse.rst:201
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:212
|
||
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é) :"
|
||
|
||
#: library/argparse.rst:231
|
||
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` ::"
|
||
|
||
#: library/argparse.rst:241
|
||
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``."
|
||
|
||
#: library/argparse.rst:258
|
||
msgid "usage"
|
||
msgstr "Le paramètre *usage*"
|
||
|
||
#: library/argparse.rst:260
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:276
|
||
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=`` ::"
|
||
|
||
#: library/argparse.rst:291
|
||
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."
|
||
|
||
#: library/argparse.rst:296
|
||
msgid "description"
|
||
msgstr "Le paramètre *description*"
|
||
|
||
#: library/argparse.rst:298
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:313
|
||
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_."
|
||
|
||
#: library/argparse.rst:318
|
||
msgid "epilog"
|
||
msgstr "Le paramètre *epilog*"
|
||
|
||
#: library/argparse.rst:320
|
||
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` ::"
|
||
|
||
#: library/argparse.rst:337
|
||
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`."
|
||
|
||
#: library/argparse.rst:343
|
||
msgid "parents"
|
||
msgstr "Le paramètre *parents*"
|
||
|
||
#: library/argparse.rst:345
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:365
|
||
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."
|
||
|
||
#: library/argparse.rst:370
|
||
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."
|
||
|
||
#: library/argparse.rst:376
|
||
msgid "formatter_class"
|
||
msgstr "Le paramètre *formatter_class*"
|
||
|
||
#: library/argparse.rst:378
|
||
msgid ""
|
||
":class:`ArgumentParser` objects allow the help formatting to be customized "
|
||
"by specifying an alternate formatting class. Currently, there are four such "
|
||
"classes:"
|
||
msgstr ""
|
||
"Les objets :class:`ArgumentParser` permettent la personnalisation de la mise "
|
||
"en page des messages d'aide en spécifiant une classe de formatage "
|
||
"alternative. Il y a actuellement quatre classes de formatage :"
|
||
|
||
#: library/argparse.rst:387
|
||
msgid ""
|
||
":class:`RawDescriptionHelpFormatter` and :class:`RawTextHelpFormatter` give "
|
||
"more control over how textual descriptions are displayed. By default, :class:"
|
||
"`ArgumentParser` objects line-wrap the description_ and epilog_ texts in "
|
||
"command-line help messages::"
|
||
msgstr ""
|
||
":class:`RawDescriptionHelpFormatter` et :class:`RawTextHelpFormatter` vous "
|
||
"donnent plus de contrôle sur comment les descriptions textuelles sont "
|
||
"affichées. Par défaut, les contenus de description_ et epilog_ des objets :"
|
||
"class:`ArgumentParser` font l'objet du retour à la ligne automatique dans "
|
||
"les messages d'aide ::"
|
||
|
||
#: library/argparse.rst:412
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:438
|
||
msgid ""
|
||
":class:`RawTextHelpFormatter` maintains whitespace for all sorts of help "
|
||
"text, including argument descriptions. However, multiple new lines are "
|
||
"replaced with one. If you wish to preserve multiple blank lines, add spaces "
|
||
"between the newlines."
|
||
msgstr ""
|
||
":class:`RawTextHelpFormatter` conserve les espaces pour toutes les "
|
||
"catégories de textes d'aide, y compris les descriptions des arguments. Notez "
|
||
"bien que plusieurs retours à la ligne consécutifs sont remplacés par un "
|
||
"seul. Si vous voulez garder plusieurs sauts de ligne, ajoutez des espaces "
|
||
"entre les caractères de changement de ligne."
|
||
|
||
#: library/argparse.rst:443
|
||
msgid ""
|
||
":class:`ArgumentDefaultsHelpFormatter` automatically adds information about "
|
||
"default values to each of the argument help messages::"
|
||
msgstr ""
|
||
":class:`ArgumentDefaultsHelpFormatter` ajoute automatiquement l'information "
|
||
"sur les valeurs par défaut aux messages d'aide de tous les arguments ::"
|
||
|
||
#: library/argparse.rst:461
|
||
msgid ""
|
||
":class:`MetavarTypeHelpFormatter` uses the name of the type_ argument for "
|
||
"each argument as the display name for its values (rather than using the "
|
||
"dest_ as the regular formatter does)::"
|
||
msgstr ""
|
||
":class:`MetavarTypeHelpFormatter` utilise le nom du type_ de l'argument pour "
|
||
"chacun des arguments comme nom d'affichage pour leurs valeurs (contrairement "
|
||
"au formateur standard qui utilise dest_) ::"
|
||
|
||
#: library/argparse.rst:482
|
||
msgid "prefix_chars"
|
||
msgstr "Le paramètre *prefix_chars*"
|
||
|
||
#: library/argparse.rst:484
|
||
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`` ::"
|
||
|
||
#: library/argparse.rst:496
|
||
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``."
|
||
|
||
#: library/argparse.rst:502
|
||
msgid "fromfile_prefix_chars"
|
||
msgstr "Le paramètre *fromfile_prefix_chars*"
|
||
|
||
#: library/argparse.rst:504
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:518
|
||
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']``."
|
||
|
||
#: library/argparse.rst:524
|
||
msgid ""
|
||
"The ``fromfile_prefix_chars=`` argument defaults to ``None``, meaning that "
|
||
"arguments will never be treated as file references."
|
||
msgstr ""
|
||
"Par défaut, l'argument ``fromfile_prefix_chars=`` est ``None``, ce qui "
|
||
"signifie que les arguments ne seront pas traités en tant que références à "
|
||
"des fichiers."
|
||
|
||
#: library/argparse.rst:529
|
||
msgid "argument_default"
|
||
msgstr "Le paramètre *argument_default*"
|
||
|
||
#: library/argparse.rst:531
|
||
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`` ::"
|
||
|
||
#: library/argparse.rst:551
|
||
msgid "allow_abbrev"
|
||
msgstr "Le paramètre *allow_abbrev*"
|
||
|
||
#: library/argparse.rst:553
|
||
msgid ""
|
||
"Normally, when you pass an argument list to the :meth:`~ArgumentParser."
|
||
"parse_args` method of an :class:`ArgumentParser`, it :ref:`recognizes "
|
||
"abbreviations <prefix-matching>` of long options."
|
||
msgstr ""
|
||
"En temps normal, lorsque vous passez une liste d'arguments à la méthode :"
|
||
"meth:`~ArgumentParser.parse_args` d':class:`ArgumentParser` :ref:`elle "
|
||
"accepte les abréviations <prefix-matching>` des options longues."
|
||
|
||
#: library/argparse.rst:557
|
||
msgid "This feature can be disabled by setting ``allow_abbrev`` to ``False``::"
|
||
msgstr ""
|
||
"Cette fonctionnalité peut être désactivée en passant ``False`` à "
|
||
"``allow_abbrev`` ::"
|
||
|
||
#: library/argparse.rst:570
|
||
msgid "conflict_handler"
|
||
msgstr "Le paramètre *conflict_handler*"
|
||
|
||
#: library/argparse.rst:572
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:584
|
||
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` ::"
|
||
|
||
#: library/argparse.rst:600
|
||
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."
|
||
|
||
#: library/argparse.rst:607
|
||
msgid "add_help"
|
||
msgstr "Le paramètre *add_help*"
|
||
|
||
#: library/argparse.rst:609
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:618
|
||
msgid ""
|
||
"If ``-h`` or ``--help`` is supplied at the command line, the ArgumentParser "
|
||
"help will be printed:"
|
||
msgstr ""
|
||
"Si ``-h`` ou ``--help`` est passé sur la ligne de commande, le message "
|
||
"d'aide de l'``ArgumentParser`` sera affiché :"
|
||
|
||
#: library/argparse.rst:630
|
||
msgid ""
|
||
"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` ::"
|
||
|
||
#: library/argparse.rst:642
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:657
|
||
msgid "exit_on_error"
|
||
msgstr "Le paramètre *exit_on_error*"
|
||
|
||
#: library/argparse.rst:659
|
||
msgid ""
|
||
"Normally, when you pass an invalid argument list to the :meth:"
|
||
"`~ArgumentParser.parse_args` method of an :class:`ArgumentParser`, it will "
|
||
"exit with error info."
|
||
msgstr ""
|
||
"En général, quand vous passez une liste d'arguments dont au moins un est "
|
||
"invalide à la méthode :meth:`~ArgumentParser.parse_args` d'une instance d':"
|
||
"class:`ArgumentParser`, l'exécution se termine avec un message d'erreur."
|
||
|
||
#: library/argparse.rst:662
|
||
msgid ""
|
||
"If the user would like catch errors manually, the feature can be enable by "
|
||
"setting ``exit_on_error`` to ``False``::"
|
||
msgstr ""
|
||
"Si vous souhaitez intercepter les erreurs manuellement, la fonctionnalité "
|
||
"peut être activée en assignant ``False`` à ``exit_on_error`` ::"
|
||
|
||
#: library/argparse.rst:679
|
||
msgid "The add_argument() method"
|
||
msgstr "La méthode *add_argument()*"
|
||
|
||
#: library/argparse.rst:685
|
||
msgid ""
|
||
"Define how a single command-line argument should be parsed. Each parameter "
|
||
"has its own more detailed description below, but in short they are:"
|
||
msgstr ""
|
||
"Définie comment une option de ligne de commande doit être analysée. Chacun "
|
||
"des paramètres est décrit plus en détails ci-bas, mais en résumé ils sont :"
|
||
|
||
#: library/argparse.rst:688
|
||
msgid ""
|
||
"`name or flags`_ - Either a name or a list of option strings, e.g. ``foo`` "
|
||
"or ``-f, --foo``."
|
||
msgstr ""
|
||
"`name_or_flags`_ – Nom ou liste de chaînes d'options. Par exemple : ``foo`` "
|
||
"ou ``-f, --foo`` ;"
|
||
|
||
#: library/argparse.rst:691
|
||
msgid ""
|
||
"action_ - The basic type of action to be taken when this argument is "
|
||
"encountered at the command line."
|
||
msgstr ""
|
||
"action_ – Type élémentaire de l'action à entreprendre quand cet argument est "
|
||
"reconnu sur la ligne de commande ;"
|
||
|
||
#: library/argparse.rst:694
|
||
msgid "nargs_ - The number of command-line arguments that should be consumed."
|
||
msgstr "nargs_ – Nombre d'arguments de la ligne de commande à capturer ;"
|
||
|
||
#: library/argparse.rst:696
|
||
msgid ""
|
||
"const_ - A constant value required by some action_ and nargs_ selections."
|
||
msgstr ""
|
||
"const_ – Valeur constante requise par certains choix d'action_ et de nargs_ ;"
|
||
|
||
#: library/argparse.rst:698
|
||
msgid ""
|
||
"default_ - The value produced if the argument is absent from the command "
|
||
"line and if it is absent from the namespace object."
|
||
msgstr ""
|
||
"default_ – Valeur produite si l'argument est absent de la ligne de "
|
||
"commande et absent de l'objet ``namespace`` ;"
|
||
|
||
#: library/argparse.rst:701
|
||
msgid ""
|
||
"type_ - The type to which the command-line argument should be converted."
|
||
msgstr ""
|
||
"type_ – Type vers lequel l'argument sur la ligne de commande doit être "
|
||
"converti ;"
|
||
|
||
#: library/argparse.rst:703
|
||
msgid "choices_ - A container of the allowable values for the argument."
|
||
msgstr ""
|
||
"choices_ – Conteneur qui contient toutes les valeurs permises pour cet "
|
||
"argument ;"
|
||
|
||
#: library/argparse.rst:705
|
||
msgid ""
|
||
"required_ - Whether or not the command-line option may be omitted (optionals "
|
||
"only)."
|
||
msgstr ""
|
||
"required_ – ``True`` si l'option sur la ligne de commande est obligatoire "
|
||
"(ne s'applique qu'aux arguments optionnels) ;"
|
||
|
||
#: library/argparse.rst:708
|
||
msgid "help_ - A brief description of what the argument does."
|
||
msgstr "help_ – Brève description de ce que fait l'argument ;"
|
||
|
||
#: library/argparse.rst:710
|
||
msgid "metavar_ - A name for the argument in usage messages."
|
||
msgstr "metavar_ – Nom de l'argument dans les messages d'utilisations ;"
|
||
|
||
#: library/argparse.rst:712
|
||
msgid ""
|
||
"dest_ - The name of the attribute to be added to the object returned by :"
|
||
"meth:`parse_args`."
|
||
msgstr ""
|
||
"dest_ – Nom de l'attribut qui sera ajouté à l'objet retourné par :meth:"
|
||
"`parse_args`."
|
||
|
||
#: library/argparse.rst:719
|
||
msgid "name or flags"
|
||
msgstr "Le paramètre *name_or_flags*"
|
||
|
||
#: library/argparse.rst:721
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:730
|
||
msgid "while a positional argument could be created like::"
|
||
msgstr "alors qu'un argument positionnel est créé comme suit ::"
|
||
|
||
#: library/argparse.rst:734
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:751
|
||
msgid "action"
|
||
msgstr "Le paramètre *action*"
|
||
|
||
#: library/argparse.rst:753
|
||
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 :"
|
||
|
||
#: library/argparse.rst:759
|
||
msgid ""
|
||
"``'store'`` - This just stores the argument's value. This is the default "
|
||
"action. For example::"
|
||
msgstr ""
|
||
"``'store'`` – Stocke la valeur de l'argument sans autre traitement. Ceci est "
|
||
"l'action par défaut. Par exemple ::"
|
||
|
||
#: library/argparse.rst:767
|
||
msgid ""
|
||
"``'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 ::"
|
||
|
||
#: library/argparse.rst:776
|
||
msgid ""
|
||
"``'store_true'`` and ``'store_false'`` - These are special cases of "
|
||
"``'store_const'`` used for storing the values ``True`` and ``False`` "
|
||
"respectively. In addition, they create default values of ``False`` and "
|
||
"``True`` respectively. For example::"
|
||
msgstr ""
|
||
"``'store_true'`` et ``'store_false'`` – Ces actions sont des cas "
|
||
"particuliers de ``'store_const'`` pour lesquelles la valeur stockée est "
|
||
"``True`` et ``False``, respectivement. Aussi, ces actions ont comme valeur "
|
||
"par défaut ``False`` et ``True``, respectivement. Par exemple ::"
|
||
|
||
#: library/argparse.rst:788
|
||
msgid ""
|
||
"``'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 ::"
|
||
|
||
#: library/argparse.rst:797
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:809
|
||
msgid ""
|
||
"``'count'`` - This counts the number of times a keyword argument occurs. For "
|
||
"example, this is useful for increasing verbosity levels::"
|
||
msgstr ""
|
||
"``'count'`` – Compte le nombre d'occurrences de l'argument nommé. Ceci est "
|
||
"pratique, par exemple, pour augmenter le niveau de verbosité ::"
|
||
|
||
#: library/argparse.rst:817
|
||
msgid "Note, the *default* will be ``None`` unless explicitly set to *0*."
|
||
msgstr ""
|
||
"Prenez note que la valeur de *default* sera ``None`` à moins qu'elle soit "
|
||
"explicitement définie à ``0``."
|
||
|
||
#: library/argparse.rst:819
|
||
msgid ""
|
||
"``'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."
|
||
|
||
#: library/argparse.rst:824
|
||
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` ::"
|
||
|
||
#: library/argparse.rst:834
|
||
msgid ""
|
||
"``'extend'`` - This stores a list, and extends each argument value to the "
|
||
"list. Example usage::"
|
||
msgstr ""
|
||
"``'extend'`` – Stock une liste et ajoute à la liste chacune des valeurs de "
|
||
"l'argument reçues. Voici un exemple de son utilisation ::"
|
||
|
||
#: library/argparse.rst:845
|
||
msgid ""
|
||
"You may also specify an arbitrary action by passing an Action subclass or "
|
||
"other object that implements the same interface. The "
|
||
"``BooleanOptionalAction`` is available in ``argparse`` and adds support for "
|
||
"boolean actions such as ``--foo`` and ``--no-foo``::"
|
||
msgstr ""
|
||
"Vous pouvez aussi spécifier une action arbitraire en passant une sous-classe "
|
||
"d'``Action`` ou un objet qui implémente la même interface. La classe "
|
||
"``BooleanOptionalAction`` est disponible dans ``argparse`` et elle ajoute la "
|
||
"gestion des options booléennes telles que ``--foo`` et ``--no-foo`` ::"
|
||
|
||
#: library/argparse.rst:856
|
||
msgid ""
|
||
"The recommended way to create a custom action is to extend :class:`Action`, "
|
||
"overriding the ``__call__`` method and optionally the ``__init__`` and "
|
||
"``format_usage`` methods."
|
||
msgstr ""
|
||
"La façon recommandée pour créer une action personnalisée est d'hériter d':"
|
||
"class:`Action` en surchargeant la méthode ``__call__``. Vous avez également "
|
||
"l'option de surcharger les méthodes ``__init__`` et ``format_usage``."
|
||
|
||
#: library/argparse.rst:860
|
||
msgid "An example of a custom action::"
|
||
msgstr "Un exemple d'action personnalisée ::"
|
||
|
||
#: library/argparse.rst:880
|
||
msgid "For more details, see :class:`Action`."
|
||
msgstr "Pour plus d'information, voir :class:`Action`."
|
||
|
||
#: library/argparse.rst:883
|
||
msgid "nargs"
|
||
msgstr "Le paramètre *nargs*"
|
||
|
||
#: library/argparse.rst:885
|
||
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 :"
|
||
|
||
#: library/argparse.rst:890
|
||
msgid ""
|
||
"``N`` (an integer). ``N`` arguments from the command line will be gathered "
|
||
"together into a list. For example::"
|
||
msgstr ""
|
||
"``N`` (un entier). ``N`` arguments de la ligne de commande seront capturés "
|
||
"ensemble et stockés dans une liste. Par exemple ::"
|
||
|
||
#: library/argparse.rst:899
|
||
msgid ""
|
||
"Note that ``nargs=1`` produces a list of one item. This is different from "
|
||
"the default, in which the item is produced by itself."
|
||
msgstr ""
|
||
"Prenez note que ``nargs=1`` produit une liste avec un seul élément. Ceci est "
|
||
"différent du comportement par défaut qui produit l'élément directement "
|
||
"(comme un scalaire)."
|
||
|
||
#: library/argparse.rst:904
|
||
msgid ""
|
||
"``'?'``. 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 ::"
|
||
|
||
#: library/argparse.rst:921
|
||
msgid ""
|
||
"One of the more common uses of ``nargs='?'`` is to allow optional input and "
|
||
"output files::"
|
||
msgstr ""
|
||
"``nargs='?'`` est fréquemment utilisé pour accepter des fichiers d'entrée et "
|
||
"de sortie optionnels ::"
|
||
|
||
#: library/argparse.rst:938
|
||
msgid ""
|
||
"``'*'``. 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 ::"
|
||
|
||
#: library/argparse.rst:952
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:964
|
||
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."
|
||
|
||
#: library/argparse.rst:970
|
||
msgid "const"
|
||
msgstr "Le paramètre *const*"
|
||
|
||
#: library/argparse.rst:972
|
||
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 :"
|
||
|
||
#: library/argparse.rst:976
|
||
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 ;"
|
||
|
||
# Nous sommes dans une énumération après un :, donc pas de majuscule et le paragraphe doit se terminer par ;.
|
||
#: library/argparse.rst:981
|
||
msgid ""
|
||
"When :meth:`~ArgumentParser.add_argument` is called with option strings "
|
||
"(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."
|
||
|
||
#: library/argparse.rst:988
|
||
msgid ""
|
||
"With the ``'store_const'`` and ``'append_const'`` actions, the ``const`` "
|
||
"keyword argument must be given. For other actions, it defaults to ``None``."
|
||
msgstr ""
|
||
"Pour les actions ``'store_const'`` et ``'append_const'``, l'argument nommé "
|
||
"``const`` doit être spécifié. Pour toutes les autres actions, il est "
|
||
"optionnel et sa valeur par défaut est ``None``."
|
||
|
||
#: library/argparse.rst:993
|
||
msgid "default"
|
||
msgstr "Le paramètre *default*"
|
||
|
||
#: library/argparse.rst:995
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1009
|
||
msgid ""
|
||
"If the target namespace already has an attribute set, the action *default* "
|
||
"will not over write it::"
|
||
msgstr ""
|
||
"Si l'objet ``namespace`` cible a déjà un attribut assigné, l'action "
|
||
"*default* ne l'écrase pas ::"
|
||
|
||
#: library/argparse.rst:1017
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1028
|
||
msgid ""
|
||
"For positional arguments with nargs_ equal to ``?`` or ``*``, the "
|
||
"``default`` value is used when no command-line argument was present::"
|
||
msgstr ""
|
||
"Pour les arguments positionnels pour lesquels nargs_ est ``?`` ou ``*``, la "
|
||
"valeur de ``default`` est utilisée quand l'argument est absent de la ligne "
|
||
"de commande ::"
|
||
|
||
#: library/argparse.rst:1039
|
||
msgid ""
|
||
"Providing ``default=argparse.SUPPRESS`` causes no attribute to be added if "
|
||
"the command-line argument was not present::"
|
||
msgstr ""
|
||
"Si vous passez ``default=argparse.SUPPRESS``, aucun attribut ne sera ajouté "
|
||
"à l'objet ``Namespace`` quand l'argument est absent de la ligne de "
|
||
"commande ::"
|
||
|
||
#: library/argparse.rst:1051
|
||
msgid "type"
|
||
msgstr "Le paramètre *type*"
|
||
|
||
#: library/argparse.rst:1053
|
||
msgid ""
|
||
"By default, the parser reads command-line arguments in as simple strings. "
|
||
"However, quite often the command-line string should instead be interpreted "
|
||
"as another type, such as a :class:`float` or :class:`int`. The ``type`` "
|
||
"keyword for :meth:`~ArgumentParser.add_argument` allows any necessary type-"
|
||
"checking and type conversions to be performed."
|
||
msgstr ""
|
||
"Par défaut, l'analyseur capture les arguments de la ligne de commande comme "
|
||
"des chaînes. Très souvent par contre, on désire interpréter les chaînes de "
|
||
"la ligne de commande comme un autre type, tel que :class:`float` ou :class:"
|
||
"`int`. L'argument nommé ``type`` d':meth:`~ArgumentParser.add_argument` nous "
|
||
"permet de faire les vérifications et les conversions de type nécessaires."
|
||
|
||
#: library/argparse.rst:1059
|
||
msgid ""
|
||
"If the type_ keyword is used with the default_ keyword, the type converter "
|
||
"is only applied if the default is a string."
|
||
msgstr ""
|
||
"Si l'argument nommé type_ est utilisé en conjonction avec l'argument nommé "
|
||
"keyword_, le convertisseur de type n'est appliqué que si la valeur par "
|
||
"défaut est une chaîne."
|
||
|
||
#: library/argparse.rst:1062
|
||
msgid ""
|
||
"The argument to ``type`` can be any callable that accepts a single string. "
|
||
"If the function raises :exc:`ArgumentTypeError`, :exc:`TypeError`, or :exc:"
|
||
"`ValueError`, the exception is caught and a nicely formatted error message "
|
||
"is displayed. No other exception types are handled."
|
||
msgstr ""
|
||
"La valeur de l'argument ``type`` peut être n'importe quel appelable qui "
|
||
"accepte une seule chaîne. Si la fonction lance :exc:`ArgumentTypeError`, :"
|
||
"exc:`TypeError` ou :exc:`ValueError`, l'exception est traitée et un message "
|
||
"d'erreur agréablement formaté est affiché. Aucun autre type d'exception "
|
||
"n'est géré."
|
||
|
||
#: library/argparse.rst:1067
|
||
msgid "Common built-in types and functions can be used as type converters:"
|
||
msgstr ""
|
||
"Les types et les fonctions natives peuvent être utilisés comme "
|
||
"convertisseurs de types :"
|
||
|
||
#: library/argparse.rst:1083
|
||
msgid "User defined functions can be used as well:"
|
||
msgstr "Les fonctions définies par l'usager peuvent aussi être utilisées :"
|
||
|
||
#: library/argparse.rst:1095
|
||
msgid ""
|
||
"The :func:`bool` function is not recommended as a type converter. All it "
|
||
"does is convert empty strings to ``False`` and non-empty strings to "
|
||
"``True``. This is usually not what is desired."
|
||
msgstr ""
|
||
"La fonction :func:`bool` est déconseillée comme convertisseur de type. Son "
|
||
"comportement se limite à convertir les chaînes vides à ``False`` et les "
|
||
"chaînes non-vides à ``True``. Ce n'est généralement pas le résultat désiré."
|
||
|
||
#: library/argparse.rst:1099
|
||
msgid ""
|
||
"In general, the ``type`` keyword is a convenience that should only be used "
|
||
"for simple conversions that can only raise one of the three supported "
|
||
"exceptions. Anything with more interesting error-handling or resource "
|
||
"management should be done downstream after the arguments are parsed."
|
||
msgstr ""
|
||
"En général, l'argument nommé ``type`` est un raccourci qui ne devrait être "
|
||
"utilisé que pour les conversions simples qui ne peuvent lever qu'une des "
|
||
"trois exceptions gérées. Les conversions qui demandent un traitement "
|
||
"d'erreurs plus intéressant ou une gestion de ressources devraient être "
|
||
"effectuées plus tard dans l’exécution suite à l'analyse des arguments."
|
||
|
||
#: library/argparse.rst:1104
|
||
msgid ""
|
||
"For example, JSON or YAML conversions have complex error cases that require "
|
||
"better reporting than can be given by the ``type`` keyword. An :exc:`~json."
|
||
"JSONDecodeError` would not be well formatted and a :exc:`FileNotFound` "
|
||
"exception would not be handled at all."
|
||
msgstr ""
|
||
"Par exemple, les conversions de documents *JSON* ou *YAML* ont des cas "
|
||
"d'erreurs complexes qui requièrent un meilleur signalement que ce qui est "
|
||
"fourni par l'argument nommé ``type``. Une exception :exc:`~json."
|
||
"JSONDecodeError` ne serait pas adéquatement formatée et une exception :exc:"
|
||
"`FileNotFound` ne serait pas du tout traitée."
|
||
|
||
#: library/argparse.rst:1109
|
||
msgid ""
|
||
"Even :class:`~argparse.FileType` has its limitations for use with the "
|
||
"``type`` keyword. If one argument uses *FileType* and then a subsequent "
|
||
"argument fails, an error is reported but the file is not automatically "
|
||
"closed. In this case, it would be better to wait until after the parser has "
|
||
"run and then use the :keyword:`with`-statement to manage the files."
|
||
msgstr ""
|
||
"Même la classe :class:`~argparse.FileType` a ses limitations quand elle est "
|
||
"utilisée pour l'argument nommé ``type``. Si un argument utilise *FileType* "
|
||
"et qu'un argument ultérieur échoue, une erreur est annoncée mais le fichier "
|
||
"n'est pas automatiquement fermé. Dans ce cas, il serait mieux d'attendre la "
|
||
"fin de l'exécution de l'analyseur puis de gérer les fichiers à l'aide d'un "
|
||
"bloc :keyword:`with`."
|
||
|
||
#: library/argparse.rst:1115
|
||
msgid ""
|
||
"For type checkers that simply check against a fixed set of values, consider "
|
||
"using the choices_ keyword instead."
|
||
msgstr ""
|
||
"Pour les vérificateurs de types qui ne font que tester l'appartenance à un "
|
||
"ensemble de valeurs, pensez plutôt à utiliser l'argument nommé choices_."
|
||
|
||
#: library/argparse.rst:1120
|
||
msgid "choices"
|
||
msgstr "Le paramètre *choices*"
|
||
|
||
#: library/argparse.rst:1122
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1137
|
||
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é ::"
|
||
|
||
#: library/argparse.rst:1149
|
||
msgid ""
|
||
"Any container can be passed as the *choices* value, so :class:`list` "
|
||
"objects, :class:`set` objects, and custom containers are all supported."
|
||
msgstr ""
|
||
"N'importe quel conteneur peut être fourni pour la valeur de *choices*, donc "
|
||
"les objets :class:`list`, les objets :class:`set` et les conteneurs "
|
||
"personnalisés sont tous acceptés."
|
||
|
||
#: library/argparse.rst:1152
|
||
msgid ""
|
||
"Use of :class:`enum.Enum` is not recommended because it is difficult to "
|
||
"control its appearance in usage, help, and error messages."
|
||
msgstr ""
|
||
"L'utilisation d':class:`enum.Enum` est déconseillée, car il est difficile de "
|
||
"contrôler son apparence dans les messages d'usage, d'aide et d'erreur."
|
||
|
||
#: library/argparse.rst:1155
|
||
msgid ""
|
||
"Formatted choices overrides the default *metavar* which is normally derived "
|
||
"from *dest*. This is usually what you want because the user never sees the "
|
||
"*dest* parameter. If this display isn't desirable (perhaps because there "
|
||
"are many choices), just specify an explicit metavar_."
|
||
msgstr ""
|
||
"Les choix formatés écrasent la valeur par défaut de *metavar* qui est "
|
||
"normalement dérivée de *dest*. C'est en général le comportement recherché "
|
||
"car l'usager ne voit jamais le paramètre *dest*. Si cet affichage n'est pas "
|
||
"souhaité (comme lorsque les choix sont nombreux) spécifiez simplement "
|
||
"metavar_ de façon explicite."
|
||
|
||
#: library/argparse.rst:1162
|
||
msgid "required"
|
||
msgstr "Le paramètre *required*"
|
||
|
||
#: library/argparse.rst:1164
|
||
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` ::"
|
||
|
||
#: library/argparse.rst:1177
|
||
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."
|
||
|
||
#: library/argparse.rst:1183
|
||
msgid ""
|
||
"Required options are generally considered bad form because users expect "
|
||
"*options* to be *optional*, and thus they should be avoided when possible."
|
||
msgstr ""
|
||
"En général, les options obligatoires manifestent un style boiteux, car les "
|
||
"utilisateurs s'attendent que les *options* soient *optionnelles*. Elles "
|
||
"devraient donc être évitées si possible."
|
||
|
||
#: library/argparse.rst:1188
|
||
msgid "help"
|
||
msgstr "Le paramètre *help*"
|
||
|
||
#: library/argparse.rst:1190
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1210
|
||
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. ::"
|
||
|
||
#: library/argparse.rst:1227
|
||
msgid ""
|
||
"As the help string supports %-formatting, if you want a literal ``%`` to "
|
||
"appear in the help string, you must escape it as ``%%``."
|
||
msgstr ""
|
||
"Comme la chaîne d'aide utilise le caractère ``%`` pour le formatage, si vous "
|
||
"désirez afficher un ``%`` littéral dans la chaîne d'aide, vous devez en "
|
||
"faire l’échappement avec ``%%``."
|
||
|
||
#: library/argparse.rst:1230
|
||
msgid ""
|
||
":mod:`argparse` supports silencing the help entry for certain options, by "
|
||
"setting the ``help`` value to ``argparse.SUPPRESS``::"
|
||
msgstr ""
|
||
":mod:`argparse` peut supprimer la rubrique d'aide de certaines options. Pour "
|
||
"ce faire, passez ``argparse.SUPPRESS`` à ``help`` ::"
|
||
|
||
#: library/argparse.rst:1243
|
||
msgid "metavar"
|
||
msgstr "Le paramètre *metavar*"
|
||
|
||
#: library/argparse.rst:1245
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1269
|
||
msgid "An alternative name can be specified with ``metavar``::"
|
||
msgstr "Un nom alternatif peut être fourni à ``metavar`` ::"
|
||
|
||
#: library/argparse.rst:1286
|
||
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_."
|
||
|
||
#: library/argparse.rst:1290
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1307
|
||
msgid "dest"
|
||
msgstr "Le paramètre *dest*"
|
||
|
||
#: library/argparse.rst:1309
|
||
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` ::"
|
||
|
||
#: library/argparse.rst:1321
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1338
|
||
msgid "``dest`` allows a custom attribute name to be provided::"
|
||
msgstr "``dest`` vous permet de fournir un nom d'attribut personnalisé ::"
|
||
|
||
#: library/argparse.rst:1346
|
||
msgid "Action classes"
|
||
msgstr "Classes Action"
|
||
|
||
#: library/argparse.rst:1348
|
||
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`."
|
||
|
||
#: library/argparse.rst:1357
|
||
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``."
|
||
|
||
#: library/argparse.rst:1363
|
||
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__``."
|
||
|
||
#: library/argparse.rst:1368
|
||
msgid ""
|
||
"Action instances should be callable, so subclasses must override the "
|
||
"``__call__`` method, which should accept four parameters:"
|
||
msgstr ""
|
||
"Les instances d'``Action`` doivent être appelables et donc les sous-classes "
|
||
"doivent surcharger la méthode ``__call__``. Cette méthode doit accepter "
|
||
"quatre paramètres :"
|
||
|
||
#: library/argparse.rst:1371
|
||
msgid "``parser`` - The ArgumentParser object which contains this action."
|
||
msgstr "``parser`` – L'objet ``ArgumentParser`` qui contient cette action ;"
|
||
|
||
#: library/argparse.rst:1373
|
||
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` ;"
|
||
|
||
#: library/argparse.rst:1377
|
||
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` ;"
|
||
|
||
#: library/argparse.rst:1381
|
||
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."
|
||
|
||
#: library/argparse.rst:1385
|
||
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``."
|
||
|
||
#: library/argparse.rst:1388
|
||
msgid ""
|
||
"Action subclasses can define a ``format_usage`` method that takes no "
|
||
"argument and return a string which will be used when printing the usage of "
|
||
"the program. If such method is not provided, a sensible default will be used."
|
||
msgstr ""
|
||
"Les classes dérivées d'``Action`` peuvent définir une méthode "
|
||
"``format_usage`` qui ne prends aucun argument et qui renvoie une chaîne qui "
|
||
"sera utilisée lors de l'affichage du message d'utilisation du programme. Si "
|
||
"cette méthode n'est pas fournie, une valeur raisonnable sera utilisée par "
|
||
"défaut."
|
||
|
||
#: library/argparse.rst:1393
|
||
msgid "The parse_args() method"
|
||
msgstr "La méthode *parse_args()*"
|
||
|
||
#: library/argparse.rst:1397
|
||
msgid ""
|
||
"Convert argument strings to objects and assign them as attributes of the "
|
||
"namespace. Return the populated namespace."
|
||
msgstr ""
|
||
"Convertie les chaînes d'arguments en objets et les assigne comme attributs "
|
||
"de l'objet ``namespace``. Retourne l'objet ``namespace`` rempli."
|
||
|
||
#: library/argparse.rst:1400
|
||
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."
|
||
|
||
#: library/argparse.rst:1404
|
||
msgid ""
|
||
"args_ - List of strings to parse. The default is taken from :data:`sys."
|
||
"argv`."
|
||
msgstr ""
|
||
"args_ – Liste de chaînes à analyser. La valeur par défaut est récupérée "
|
||
"dans : :data:`sys.argv`."
|
||
|
||
#: library/argparse.rst:1407
|
||
msgid ""
|
||
"namespace_ - An object to take the attributes. The default is a new empty :"
|
||
"class:`Namespace` object."
|
||
msgstr ""
|
||
"namespace_ – Un objet pour recevoir les attributs. Par défaut : une nouvelle "
|
||
"instance (vide) de :class:`Namespace`."
|
||
|
||
#: library/argparse.rst:1412
|
||
msgid "Option value syntax"
|
||
msgstr "Syntaxe de la valeur des options"
|
||
|
||
#: library/argparse.rst:1414
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1426
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1433
|
||
msgid ""
|
||
"For short options (options only one character long), the option and its "
|
||
"value can be concatenated::"
|
||
msgstr ""
|
||
"Pour les options courtes (les options qui utilisent un seul caractère), "
|
||
"l'option et sa valeur peuvent être concaténées ::"
|
||
|
||
#: library/argparse.rst:1439
|
||
msgid ""
|
||
"Several short options can be joined together, using only a single ``-`` "
|
||
"prefix, as long as only the last option (or none of them) requires a value::"
|
||
msgstr ""
|
||
"Plusieurs options courtes peuvent être groupées ensemble après un seul "
|
||
"préfixe ``-`` pour autant que seule la dernière (ou aucune) nécessite une "
|
||
"valeur ::"
|
||
|
||
#: library/argparse.rst:1451
|
||
msgid "Invalid arguments"
|
||
msgstr "Arguments invalides"
|
||
|
||
#: library/argparse.rst:1453
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1479
|
||
msgid "Arguments containing ``-``"
|
||
msgstr "Arguments contenant ``-``"
|
||
|
||
#: library/argparse.rst:1481
|
||
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 argument 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 ::"
|
||
|
||
#: library/argparse.rst:1519
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1530
|
||
msgid "Argument abbreviations (prefix matching)"
|
||
msgstr "Arguments abrégés (Par comparaison de leurs préfixes)"
|
||
|
||
#: library/argparse.rst:1532
|
||
msgid ""
|
||
"The :meth:`~ArgumentParser.parse_args` method :ref:`by default "
|
||
"<allow_abbrev>` allows long options to be abbreviated to a prefix, if the "
|
||
"abbreviation is unambiguous (the prefix matches a unique option)::"
|
||
msgstr ""
|
||
"Par défaut, la méthode :meth:`~ArgumentParser.parse_args` accepte que les "
|
||
"options longues soient :ref:`abrégées <allow_abbrev>` par un préfixe pour "
|
||
"autant que l’abréviation soit non-ambigüe, c'est-à-dire qu'elle ne "
|
||
"corresponde qu'à une seule option ::"
|
||
|
||
#: library/argparse.rst:1547
|
||
msgid ""
|
||
"An error is produced for arguments that could produce more than one options. "
|
||
"This feature can be disabled by setting :ref:`allow_abbrev` to ``False``."
|
||
msgstr ""
|
||
"Une erreur est générée pour les arguments qui peuvent produire plus d'une "
|
||
"option. Ce comportement peut être désactivé en passant ``False`` à :ref:"
|
||
"`allow_abbrev`."
|
||
|
||
#: library/argparse.rst:1553
|
||
msgid "Beyond ``sys.argv``"
|
||
msgstr "Au-delà de ``sys.argv``"
|
||
|
||
#: library/argparse.rst:1555
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1575
|
||
msgid "The Namespace object"
|
||
msgstr "L'objet ``Namespace``"
|
||
|
||
#: library/argparse.rst:1579
|
||
msgid ""
|
||
"Simple class used by default by :meth:`~ArgumentParser.parse_args` to create "
|
||
"an object holding attributes and return it."
|
||
msgstr ""
|
||
"Classe rudimentaire qui est utilisé par défaut par :meth:`~ArgumentParser."
|
||
"parse_args` pour créer un objet qui stock les attributs. Cet objet est "
|
||
"renvoyé par ``ArgumentParser.parse_args``."
|
||
|
||
#: library/argparse.rst:1582
|
||
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) ::"
|
||
|
||
#: library/argparse.rst:1592
|
||
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=`` ::"
|
||
|
||
#: library/argparse.rst:1608
|
||
msgid "Other utilities"
|
||
msgstr "Autres outils"
|
||
|
||
#: library/argparse.rst:1611
|
||
msgid "Sub-commands"
|
||
msgstr "Sous commandes"
|
||
|
||
#: library/argparse.rst:1618
|
||
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."
|
||
|
||
#: library/argparse.rst:1630
|
||
msgid "Description of parameters:"
|
||
msgstr "Description des paramètres :"
|
||
|
||
#: library/argparse.rst:1632
|
||
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 ;"
|
||
|
||
#: library/argparse.rst:1636
|
||
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`` ;"
|
||
|
||
# I think the English version is very misleading here. Even for subcommands, ``prog`` is only a tiny prefix of the auto generater usage string.
|
||
#: library/argparse.rst:1639
|
||
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 ;"
|
||
|
||
#: library/argparse.rst:1643
|
||
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``) ;"
|
||
|
||
#: library/argparse.rst:1646
|
||
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 ;"
|
||
|
||
#: library/argparse.rst:1649
|
||
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 ;"
|
||
|
||
#: library/argparse.rst:1652
|
||
msgid ""
|
||
"required_ - Whether or not a subcommand must be provided, by default "
|
||
"``False`` (added in 3.7)"
|
||
msgstr ""
|
||
"required_ – ``True`` si la sous-commande est obligatoire ; par défaut : "
|
||
"``False`` (ajouté dans 3.7) ;"
|
||
|
||
#: library/argparse.rst:1655
|
||
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`` ;"
|
||
|
||
#: library/argparse.rst:1657
|
||
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, …}'``."
|
||
|
||
#: library/argparse.rst:1660
|
||
msgid "Some example usage::"
|
||
msgstr "Quelques exemples d'utilisation ::"
|
||
|
||
#: library/argparse.rst:1681
|
||
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."
|
||
|
||
#: library/argparse.rst:1688
|
||
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."
|
||
|
||
#: library/argparse.rst:1724
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1745
|
||
msgid ""
|
||
"Furthermore, ``add_parser`` supports an additional ``aliases`` argument, "
|
||
"which allows multiple strings to refer to the same subparser. This example, "
|
||
"like ``svn``, aliases ``co`` as a shorthand for ``checkout``::"
|
||
msgstr ""
|
||
"De plus, ``add_parser`` accepte l'argument additionnel ``aliases`` qui "
|
||
"permet à plusieurs chaînes de faire référence au même sous-analyseur. "
|
||
"L'exemple suivant, à la manière de ``svn``, utilise ``co`` comme une "
|
||
"abréviation de ``checkout`` ::"
|
||
|
||
#: library/argparse.rst:1756
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1793
|
||
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` ::"
|
||
|
||
#: library/argparse.rst:1809
|
||
msgid "New *required* keyword argument."
|
||
msgstr "Introduction des arguments nommés obligatoires."
|
||
|
||
#: library/argparse.rst:1814
|
||
msgid "FileType objects"
|
||
msgstr "Objets ``FileType``"
|
||
|
||
#: library/argparse.rst:1818
|
||
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, buffer sizes, encodings and error handling (see "
|
||
"the :func:`open` function for more details)::"
|
||
msgstr ""
|
||
"Le type fabrique :class:`FileType` crée des objets qui peuvent être passés à "
|
||
"l'argument ``type`` d':meth:`ArgumentParser.add_argument`. Les arguments qui "
|
||
"ont comme ``type`` un objet :class:`FileType` ouvrent les arguments de la "
|
||
"ligne de commande en tant que fichiers avec les options spécifiées : mode, "
|
||
"taille du tampon, encodage et gestion des erreurs (voir la fonction :func:"
|
||
"`open` pour plus de détails) ::"
|
||
|
||
#: library/argparse.rst:1830
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1839
|
||
msgid "The *encodings* and *errors* keyword arguments."
|
||
msgstr "Les arguments nommés ``encodings`` et ``errors``."
|
||
|
||
#: library/argparse.rst:1844
|
||
msgid "Argument groups"
|
||
msgstr "Groupes d'arguments"
|
||
|
||
#: library/argparse.rst:1848
|
||
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` ::"
|
||
|
||
#: library/argparse.rst:1865
|
||
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`` ::"
|
||
|
||
#: library/argparse.rst:1891
|
||
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*."
|
||
|
||
#: library/argparse.rst:1896
|
||
msgid "Mutual exclusion"
|
||
msgstr "Exclusion mutuelle"
|
||
|
||
#: library/argparse.rst:1900
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1916
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1928
|
||
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`."
|
||
|
||
#: library/argparse.rst:1934
|
||
msgid "Parser defaults"
|
||
msgstr "Valeurs par défaut de l'analyseur"
|
||
|
||
#: library/argparse.rst:1938
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1950
|
||
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 ::"
|
||
|
||
#: library/argparse.rst:1958
|
||
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."
|
||
|
||
#: library/argparse.rst:1964
|
||
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` ::"
|
||
|
||
#: library/argparse.rst:1975
|
||
msgid "Printing help"
|
||
msgstr "Afficher l'aide"
|
||
|
||
#: library/argparse.rst:1977
|
||
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 :"
|
||
|
||
#: library/argparse.rst:1983
|
||
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`."
|
||
|
||
#: library/argparse.rst:1989
|
||
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`."
|
||
|
||
#: library/argparse.rst:1993
|
||
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 :"
|
||
|
||
#: library/argparse.rst:1998
|
||
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."
|
||
|
||
#: library/argparse.rst:2003
|
||
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`."
|
||
|
||
#: library/argparse.rst:2008
|
||
msgid "Partial parsing"
|
||
msgstr "Analyse partielle"
|
||
|
||
#: library/argparse.rst:2012
|
||
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."
|
||
|
||
#: library/argparse.rst:2028
|
||
msgid ""
|
||
":ref:`Prefix matching <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 <prefix-matching>` 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."
|
||
|
||
#: library/argparse.rst:2035
|
||
msgid "Customizing file parsing"
|
||
msgstr "Personnaliser le *parsing* de fichiers"
|
||
|
||
#: library/argparse.rst:2039
|
||
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`."
|
||
|
||
#: library/argparse.rst:2044
|
||
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é."
|
||
|
||
#: library/argparse.rst:2048
|
||
msgid ""
|
||
"A useful override of this method is one that treats each space-separated "
|
||
"word as an argument. The following example demonstrates how to do this::"
|
||
msgstr ""
|
||
"Une surcharge utile de cette méthode est de permettre à chaque mot délimité "
|
||
"par des espaces d'être traité comme un argument. L'exemple suivant illustre "
|
||
"comment réaliser ceci ::"
|
||
|
||
#: library/argparse.rst:2057
|
||
msgid "Exiting methods"
|
||
msgstr "Méthodes d'interruptions"
|
||
|
||
#: library/argparse.rst:2061
|
||
msgid ""
|
||
"This method terminates the program, exiting with the specified *status* and, "
|
||
"if given, it prints a *message* before that. The user can override this "
|
||
"method to handle these steps differently::"
|
||
msgstr ""
|
||
"Cette méthode interrompt l'exécution du programme et renvoie ``status`` "
|
||
"comme valeur de retour du processus. Si ``message`` est fourni, la chaîne "
|
||
"est affichée avant la fin de l'exécution. Vous pouvez surcharger cette "
|
||
"méthode pour traiter ces étapes différemment ::"
|
||
|
||
#: library/argparse.rst:2073
|
||
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."
|
||
|
||
#: library/argparse.rst:2078
|
||
msgid "Intermixed parsing"
|
||
msgstr "Analyse entremêlée"
|
||
|
||
#: library/argparse.rst:2083
|
||
msgid ""
|
||
"A number of Unix commands allow the user to intermix optional arguments with "
|
||
"positional arguments. The :meth:`~ArgumentParser.parse_intermixed_args` "
|
||
"and :meth:`~ArgumentParser.parse_known_intermixed_args` methods support this "
|
||
"parsing style."
|
||
msgstr ""
|
||
"De nombreuses commandes Unix permettent à l'utilisateur d'entremêler les "
|
||
"arguments optionnels et les arguments positionnels. Les méthodes :meth:"
|
||
"`~ArgumentParser.parse_intermixed_args` et :meth:`~ArgumentParser."
|
||
"parse_known_intermixed_args` permettent ce style d'analyse."
|
||
|
||
#: library/argparse.rst:2088
|
||
msgid ""
|
||
"These parsers do not support all the argparse features, and will raise "
|
||
"exceptions if unsupported features are used. In particular, subparsers, "
|
||
"``argparse.REMAINDER``, and mutually exclusive groups that include both "
|
||
"optionals and positionals are not supported."
|
||
msgstr ""
|
||
"Ces analyseurs n'offrent pas toutes les fonctionnalités d'``argparse`` et "
|
||
"ils lèvent une exception si une fonctionnalité non prise en charge est "
|
||
"utilisée. En particulier, les sous-analyseurs, ``argparse.REMAINDER`` et les "
|
||
"groupes mutuellement exclusifs qui contiennent à la fois des arguments "
|
||
"optionnels et des arguments positionnels ne sont pas pris en charge."
|
||
|
||
#: library/argparse.rst:2093
|
||
msgid ""
|
||
"The following example shows the difference between :meth:`~ArgumentParser."
|
||
"parse_known_args` and :meth:`~ArgumentParser.parse_intermixed_args`: the "
|
||
"former returns ``['2', '3']`` as unparsed arguments, while the latter "
|
||
"collects all the positionals into ``rest``. ::"
|
||
msgstr ""
|
||
"L'exemple suivant illustre la différence entre :meth:`~ArgumentParser."
|
||
"parse_known_args` et :meth:`~ArgumentParser.parse_intermixed_args` : le "
|
||
"premier renvoie ``['2', '3']`` comme arguments non-traités alors que le "
|
||
"second capture tous les arguments positionnels dans ``rest`` ::"
|
||
|
||
#: library/argparse.rst:2108
|
||
msgid ""
|
||
":meth:`~ArgumentParser.parse_known_intermixed_args` returns a two item tuple "
|
||
"containing the populated namespace and the list of remaining argument "
|
||
"strings. :meth:`~ArgumentParser.parse_intermixed_args` raises an error if "
|
||
"there are any remaining unparsed argument strings."
|
||
msgstr ""
|
||
":meth:`~ArgumentParser.parse_known_intermixed_args` renvoie une paire de "
|
||
"valeurs : l'objet ``Namespace`` rempli et une liste de chaînes d'arguments "
|
||
"non-traités. :meth:`~ArgumentParser.parse_intermixed_args` lève une erreur "
|
||
"s'il reste des chaînes d'arguments non-traités."
|
||
|
||
#: library/argparse.rst:2118
|
||
msgid "Upgrading optparse code"
|
||
msgstr "Mettre à jour du code ``optparse``"
|
||
|
||
# Surchargé n'est pas une traduction exact de monkey-patch, mais c'est probablement permission içi puisqu'on parle du context historique général plutôt que de détails d'implantation.
|
||
#: library/argparse.rst:2120
|
||
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."
|
||
|
||
#: library/argparse.rst:2127
|
||
msgid ""
|
||
"The :mod:`argparse` module improves on the standard library :mod:`optparse` "
|
||
"module in a number of ways including:"
|
||
msgstr ""
|
||
"Le module :mod:`argparse` fournit plusieurs améliorations par rapport au "
|
||
"module :mod:`optparse` de la bibliothèque standard :"
|
||
|
||
#: library/argparse.rst:2130
|
||
msgid "Handling positional arguments."
|
||
msgstr "Gère les arguments positionnels ;"
|
||
|
||
#: library/argparse.rst:2131
|
||
msgid "Supporting sub-commands."
|
||
msgstr "Prise en charge des sous commandes ;"
|
||
|
||
#: library/argparse.rst:2132
|
||
msgid "Allowing alternative option prefixes like ``+`` and ``/``."
|
||
msgstr ""
|
||
"Permet d'utiliser les alternatives ``+`` ou ``/`` comme préfixes d'option ;"
|
||
|
||
#: library/argparse.rst:2133
|
||
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) ;"
|
||
|
||
#: library/argparse.rst:2134
|
||
msgid "Producing more informative usage messages."
|
||
msgstr "Fournit des messages d'aide plus complets ;"
|
||
|
||
#: library/argparse.rst:2135
|
||
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."
|
||
|
||
#: library/argparse.rst:2137
|
||
msgid "A partial upgrade path from :mod:`optparse` to :mod:`argparse`:"
|
||
msgstr "Le portage partiel d':mod:`optparse` à :mod:`argparse` :"
|
||
|
||
#: library/argparse.rst:2139
|
||
msgid ""
|
||
"Replace all :meth:`optparse.OptionParser.add_option` calls with :meth:"
|
||
"`ArgumentParser.add_argument` calls."
|
||
msgstr ""
|
||
"Remplacer tous les appels à :meth:`optparse.OptionParser.add_option` par des "
|
||
"appels à :meth:`ArgumentParser.add_argument` ;"
|
||
|
||
#: library/argparse.rst:2142
|
||
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 the :mod:`argparse` context is called ``args``."
|
||
msgstr ""
|
||
"Remplacer ``(options, args) = parser.parse_args()`` par ``args = parser."
|
||
"parse_args()`` et ajouter des appels à :meth:`ArgumentParser.add_argument` "
|
||
"pour les arguments positionnels. Prenez note que les valeurs précédemment "
|
||
"appelées ``options`` sont appelées ``args`` dans le contexte d':mod:"
|
||
"`argparse` ;"
|
||
|
||
#: library/argparse.rst:2147
|
||
msgid ""
|
||
"Replace :meth:`optparse.OptionParser.disable_interspersed_args` by using :"
|
||
"meth:`~ArgumentParser.parse_intermixed_args` instead of :meth:"
|
||
"`~ArgumentParser.parse_args`."
|
||
msgstr ""
|
||
"Remplacer :meth:`optparse.OptionParser.disable_interspersed_args` en "
|
||
"appelant :meth:`~ArgumentParser.parse_intermixed_args` plutôt que :meth:"
|
||
"`~ArgumentParser.parse_args` ;"
|
||
|
||
#: library/argparse.rst:2151
|
||
msgid ""
|
||
"Replace callback actions and the ``callback_*`` keyword arguments with "
|
||
"``type`` or ``action`` arguments."
|
||
msgstr ""
|
||
"Remplacer les actions de rappel (*callback actions* en anglais) et les "
|
||
"arguments nommés ``callback_*`` par des arguments ``type`` et ``actions`` ;"
|
||
|
||
#: library/argparse.rst:2154
|
||
msgid ""
|
||
"Replace string names for ``type`` keyword arguments with the corresponding "
|
||
"type objects (e.g. int, float, complex, etc)."
|
||
msgstr ""
|
||
"Remplacer les chaînes représentant le nom des types pour l'argument nommé "
|
||
"``type`` par les objets types correspondants (par exemple : ``int``, "
|
||
"``float``, ``complex``, etc) ;"
|
||
|
||
#: library/argparse.rst:2157
|
||
msgid ""
|
||
"Replace :class:`optparse.Values` with :class:`Namespace` and :exc:`optparse."
|
||
"OptionError` and :exc:`optparse.OptionValueError` with :exc:`ArgumentError`."
|
||
msgstr ""
|
||
"Remplacer :class:`optparse.Values` par :class:`Namespace` ; et :exc:"
|
||
"`optparse.OptionError` et :exc:`optparse.OptionValueError` par :exc:"
|
||
"`ArgumentError` ;"
|
||
|
||
#: library/argparse.rst:2161
|
||
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``) ;"
|
||
|
||
#: library/argparse.rst:2165
|
||
msgid ""
|
||
"Replace the OptionParser constructor ``version`` argument with a call to "
|
||
"``parser.add_argument('--version', action='version', version='<the "
|
||
"version>')``."
|
||
msgstr ""
|
||
"Remplacer l'argument ``version`` du constructeur d'``OptionParser`` par un "
|
||
"appel à ``parser.add_argument('--version', action='version', version='<la "
|
||
"version>')``."
|
||
|
||
#~ 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."
|
||
|
||
#~ msgid ""
|
||
#~ "To ease the use of various types of files, the argparse module provides "
|
||
#~ "the factory FileType which takes the ``mode=``, ``bufsize=``, "
|
||
#~ "``encoding=`` and ``errors=`` arguments of the :func:`open` function. "
|
||
#~ "For example, ``FileType('w')`` can be used to create a writable file::"
|
||
#~ msgstr ""
|
||
#~ "Pour faciliter l'utilisation de types de fichiers variés, le module "
|
||
#~ "``argparse`` fournit le type fabrique ``FileType`` qui accepte les "
|
||
#~ "arguments ``mode=``, ``bufsize=``, ``encoding=`` et ``errors=`` de la "
|
||
#~ "fonction :func:`open`. Par exemple, ``FileType('w')`` peut être utilisé "
|
||
#~ "pour créer un fichier en mode écriture ::"
|
||
|
||
#~ 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 ::"
|
||
|
||
#~ 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 ::"
|
||
|
||
#~ msgid "See the choices_ section for more details."
|
||
#~ msgstr "Voir la rubrique de choices_ pour plus de détails."
|