# 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: 2020-10-01 16:00+0200\n" "PO-Revision-Date: 2020-09-11 12:04-0700\n" "Last-Translator: Yannick Gingras \n" "Language-Team: FRENCH \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.3\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 `." 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 `." #: 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_ – Le 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_ – La 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 ` 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 ` 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`_ – un nom ou une liste de chaînes d'options. Par exemple : " "``foo`` ou ``-f, --foo``." #: library/argparse.rst:691 msgid "" "action_ - The basic type of action to be taken when this argument is " "encountered at the command line." msgstr "" "action_ – Type élémentaire de l'action à entreprendre quand cet argument est " "reconnu sur la ligne de commande." #: library/argparse.rst:694 msgid "nargs_ - The number of command-line arguments that should be consumed." msgstr "nargs_ – Nombre d'arguments de la ligne de commande à capturer." #: library/argparse.rst:696 msgid "" "const_ - A constant value required by some action_ and nargs_ selections." msgstr "" "const_ – Valeur constante requise par certains choix d'action_ et de nargs_." #: library/argparse.rst:698 msgid "" "default_ - The value produced if the argument is absent from the command " "line." msgstr "" "default_ – Valeur produite si l'argument est absent de la ligne de commande." #: library/argparse.rst:701 msgid "" "type_ - The type to which the command-line argument should be converted." msgstr "" "type_ – Type vers lequel l'argument sur la ligne de commande doit être " "converti." #: library/argparse.rst:703 msgid "choices_ - A container of the allowable values for the argument." msgstr "" "choices_ – Conteneur qui contient toutes les valeurs permises pour cet " "argument." #: library/argparse.rst:705 msgid "" "required_ - Whether or not the command-line option may be omitted (optionals " "only)." msgstr "" "required_ – ``True`` si l'option sur la ligne de commande est obligatoire " "(ne s'applique qu'aux arguments optionnels)." #: library/argparse.rst:708 msgid "help_ - A brief description of what the argument does." msgstr "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 ``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:1020 msgid "" "For positional arguments with nargs_ equal to ``?`` or ``*``, the " "``default`` value is used when no command-line argument was present::" msgstr "" "Pour les arguments positionnels pour lesquels nargs_ est ``?`` ou ``*``, la " "valeur de ``default`` est utilisée quand l'argument est absent de la ligne " "de commande ::" #: library/argparse.rst:1031 msgid "" "Providing ``default=argparse.SUPPRESS`` causes no attribute to be added if " "the command-line argument was not present::" msgstr "" "Si vous passez ``default=argparse.SUPPRESS``, aucun attribut ne sera ajouté " "à l'objet ``Namespace`` quand l'argument est absent de la ligne de " "commande ::" #: library/argparse.rst:1043 msgid "type" msgstr "Le paramètre *type*" #: library/argparse.rst:1045 msgid "" "By default, :class:`ArgumentParser` objects read command-line arguments in " "as simple strings. However, quite often the command-line string should " "instead be interpreted as another type, like a :class:`float` or :class:" "`int`. The ``type`` keyword argument of :meth:`~ArgumentParser." "add_argument` allows any necessary type-checking and type conversions to be " "performed. Common built-in types and functions can be used directly as the " "value of the ``type`` argument::" msgstr "" "Par défaut, les objets :class:`ArgumentParser` capturent les arguments de la " "ligne de commande comme des chaînes. Très souvent par contre, on désire " "interpréter les chaînes de la ligne de commande comme un autre type, tel " "que :class:`float` ou :class:`int`. L'argument nommé ``type`` d':meth:" "`~ArgumentParser.add_argument` nous permet de faire les vérifications et les " "conversions de type nécessaires. Les types et les fonctions natives peuvent " "être utilisés directement pour la valeur de l'argument ``type`` ::" #: library/argparse.rst:1058 msgid "" "See the section on the default_ keyword argument for information on when the " "``type`` argument is applied to default arguments." msgstr "" "Consultez la rubrique de l'argument nommé default_ pour plus d'information " "sur quand l'argument ``type`` est appliqué aux arguments par défaut." #: library/argparse.rst:1061 msgid "" "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 ::" #: library/argparse.rst:1071 msgid "" "``type=`` can take any callable that takes a single string argument and " "returns the converted value::" msgstr "" "``type=`` peut prendre n'importe quelle fonction ou objet appelable qui " "prend une seule chaîne de caractère comme argument et qui renvoie la valeur " "convertie ::" #: library/argparse.rst:1090 msgid "" "The choices_ keyword argument may be more convenient for type checkers that " "simply check against a range of values::" msgstr "" "L'argument nommé choices_ est parfois plus facile d'utilisation pour les " "vérificateurs de type qui comparent la valeur à une gamme prédéfinie ::" #: library/argparse.rst:1101 msgid "See the choices_ section for more details." msgstr "Voir la rubrique de choices_ pour plus de détails." #: library/argparse.rst:1105 msgid "choices" msgstr "Le paramètre *choices*" #: library/argparse.rst:1107 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:1122 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:1134 msgid "" "Any container can be passed as the *choices* value, so :class:`list` " "objects, :class:`set` objects, and custom containers are all supported. This " "includes :class:`enum.Enum`, which could be used to restrain argument's " "choices; if we reuse previous rock/paper/scissors game example, this could " "be as follows::" msgstr "" "N'importe quel conteneur peut être fourni pour la valeur de *choices*, donc " "les objets :class:`list`, les objets :class:`set` et les conteurs " "personnalisés sont tous acceptés. Ceci inclus :class:`enum.Enum` qui peut " "être utilisé pour limiter le choix des arguments. Si on revient à notre " "exemple pierre-papier-ciseaux, on peut faire comme suit ::" #: library/argparse.rst:1153 msgid "required" msgstr "Le paramètre *required*" #: library/argparse.rst:1155 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:1168 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:1174 msgid "" "Required options are generally considered bad form because users expect " "*options* to be *optional*, and thus they should be avoided when possible." msgstr "" "En général, les options obligatoires manifestent un style boiteux, car les " "utilisateurs s'attendent que les *options* soient *optionnelles*. Elles " "devraient donc être évitées si possible." #: library/argparse.rst:1179 msgid "help" msgstr "Le paramètre *help*" #: library/argparse.rst:1181 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:1201 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:1218 msgid "" "As the help string supports %-formatting, if you want a literal ``%`` to " "appear in the help string, you must escape it as ``%%``." msgstr "" "Comme la chaîne d'aide utilise le caractère ``%`` pour le formatage, si vous " "désirez afficher un ``%`` littéral dans la chaîne d'aide, vous devez en " "faire l’échappement avec ``%%``." #: library/argparse.rst:1221 msgid "" ":mod:`argparse` supports silencing the help entry for certain options, by " "setting the ``help`` value to ``argparse.SUPPRESS``::" msgstr "" ":mod:`argparse` peut supprimer la rubrique d'aide de certaines options. Pour " "ce faire, passez ``argparse.SUPPRESS`` à ``help`` ::" #: library/argparse.rst:1234 msgid "metavar" msgstr "Le paramètre *metavar*" #: library/argparse.rst:1236 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:1260 msgid "An alternative name can be specified with ``metavar``::" msgstr "Un nom alternatif peut être fourni à ``metavar`` ::" #: library/argparse.rst:1277 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:1281 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:1298 msgid "dest" msgstr "Le paramètre *dest*" #: library/argparse.rst:1300 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:1312 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'option. :class:`ArgumentParser` " "génère la valeur de ``dest`` en prenant la première chaîne d'option longue " "et en retirant le préfixe ``--``. Si une chaîne d'option longue n'est pas " "fournie, ``dest`` sera dérivée de la première chaîne d'option courte sans le " "préfixe ``-``. Tous les ``-`` subséquents seront convertis en ``_`` pour " "s'assurer que le chaîne est un nom d'attribut valide. Les exemples suivants " "illustrent ce comportement ::" #: library/argparse.rst:1329 msgid "``dest`` allows a custom attribute name to be provided::" msgstr "``dest`` vous permet de fournir un nom d'attribut personnalisé ::" #: library/argparse.rst:1337 msgid "Action classes" msgstr "Classes Action" #: library/argparse.rst:1339 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:1348 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:1354 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:1359 msgid "" "Action instances should be callable, so subclasses must override the " "``__call__`` method, which should accept four parameters:" msgstr "" "Les instances d'``Action`` doivent être appelables et donc les sous-classes " "doivent surcharger la méthode ``__call__``. Cette méthode doit accepter " "quatre paramètres :" #: library/argparse.rst:1362 msgid "``parser`` - The ArgumentParser object which contains this action." msgstr "``parser`` – L'objet ``ArgumentParser`` qui contient cette action." #: library/argparse.rst:1364 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:1368 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:1372 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:1376 msgid "" "The ``__call__`` method may perform arbitrary actions, but will typically " "set attributes on the ``namespace`` based on ``dest`` and ``values``." msgstr "" "La méthode ``__call__`` peut réaliser un traitement arbitraire, mais en " "général elle affect des attributs sur ``namespace`` en fonction de ``dest`` " "et de ``values``." #: library/argparse.rst:1379 msgid "" "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:1384 msgid "The parse_args() method" msgstr "La méthode *parse_args()*" #: library/argparse.rst:1388 msgid "" "Convert argument strings to objects and assign them as attributes of the " "namespace. Return the populated namespace." msgstr "" "Convertie les chaînes d'arguments en objets et les assigne comme attributs " "de l'objet ``namespace``. Retourne l'objet ``namespace`` rempli." #: library/argparse.rst:1391 msgid "" "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:1395 msgid "" "args_ - List of strings to parse. The default is taken from :data:`sys." "argv`." msgstr "" "args_ – Liste de chaînes à analyser. La valeur par défaut est récupérée " "dans : :data:`sys.argv`." #: library/argparse.rst:1398 msgid "" "namespace_ - An object to take the attributes. The default is a new empty :" "class:`Namespace` object." msgstr "" "namespace_ – Un objet pour recevoir les attributs. Par défaut : une nouvelle " "instance (vide) de :class:`Namespace`." #: library/argparse.rst:1403 msgid "Option value syntax" msgstr "" #: library/argparse.rst:1405 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 "" #: library/argparse.rst:1417 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 "" #: library/argparse.rst:1424 msgid "" "For short options (options only one character long), the option and its " "value can be concatenated::" msgstr "" "Pour les options courtes (les options qui utilisent un seul caractère), " "l'option et sa valeur peuvent être concaténées ::" #: library/argparse.rst:1430 msgid "" "Several short options can be joined together, using only a single ``-`` " "prefix, as long as only the last option (or none of them) requires a value::" msgstr "" "Plusieurs options courtes peuvent être groupées ensemble après un seul " "préfixe ``-`` pour autant que seule la dernière (ou aucune) nécessite une " "valeur ::" #: library/argparse.rst:1442 msgid "Invalid arguments" msgstr "Arguments invalides" #: library/argparse.rst:1444 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 "" #: library/argparse.rst:1470 msgid "Arguments containing ``-``" msgstr "Arguments contenant ``-``" #: library/argparse.rst:1472 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 "" #: library/argparse.rst:1510 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 "" #: library/argparse.rst:1521 msgid "Argument abbreviations (prefix matching)" msgstr "Arguments abrégés (Par comparaison de leurs préfixes)" #: library/argparse.rst:1523 msgid "" "The :meth:`~ArgumentParser.parse_args` method :ref:`by default " "` allows long options to be abbreviated to a prefix, if the " "abbreviation is unambiguous (the prefix matches a unique option)::" msgstr "" #: library/argparse.rst:1538 msgid "" "An error is produced for arguments that could produce more than one options. " "This feature can be disabled by setting :ref:`allow_abbrev` to ``False``." msgstr "" "Une erreur est générée pour les arguments qui peuvent produire plus d'une " "option. Ce comportement peut être désactivé en passant ``False`` à :ref:" "`allow_abbrev`." #: library/argparse.rst:1544 msgid "Beyond ``sys.argv``" msgstr "Au-delà de ``sys.argv``" #: library/argparse.rst:1546 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 "" #: library/argparse.rst:1566 msgid "The Namespace object" msgstr "L'objet ``Namespace``" #: library/argparse.rst:1570 msgid "" "Simple class used by default by :meth:`~ArgumentParser.parse_args` to create " "an object holding attributes and return it." msgstr "" "Classe rudimentaire qui est utilisé par défaut par :meth:`~ArgumentParser." "parse_args` pour créer un objet qui stock les attributs. Cet objet est " "renvoyé par ``ArgumentParser.parse_args``." #: library/argparse.rst:1573 msgid "" "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:1583 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:1599 msgid "Other utilities" msgstr "Autres outils" #: library/argparse.rst:1602 msgid "Sub-commands" msgstr "Sous commandes" #: library/argparse.rst:1609 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 "" #: library/argparse.rst:1621 msgid "Description of parameters:" msgstr "Description des paramètres :" #: library/argparse.rst:1623 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 "" #: library/argparse.rst:1627 msgid "" "description - description for the sub-parser group in help output, by " "default ``None``" msgstr "" #: library/argparse.rst:1630 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 "" #: library/argparse.rst:1634 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 "" #: library/argparse.rst:1637 msgid "" "action_ - the basic type of action to be taken when this argument is " "encountered at the command line" msgstr "" #: library/argparse.rst:1640 msgid "" "dest_ - name of the attribute under which sub-command name will be stored; " "by default ``None`` and no value is stored" msgstr "" #: library/argparse.rst:1643 msgid "" "required_ - Whether or not a subcommand must be provided, by default " "``False`` (added in 3.7)" msgstr "" #: library/argparse.rst:1646 msgid "help_ - help for sub-parser group in help output, by default ``None``" msgstr "" #: library/argparse.rst:1648 msgid "" "metavar_ - string presenting available sub-commands in help; by default it " "is ``None`` and presents sub-commands in form {cmd1, cmd2, ..}" msgstr "" #: library/argparse.rst:1651 msgid "Some example usage::" msgstr "Quelques exemples d'utilisation ::" #: library/argparse.rst:1672 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 "" #: library/argparse.rst:1679 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 "" #: library/argparse.rst:1715 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 "" #: library/argparse.rst:1736 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 "" #: library/argparse.rst:1747 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 "" #: library/argparse.rst:1784 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 "" #: library/argparse.rst:1800 msgid "New *required* keyword argument." msgstr "Introduction des arguments nommés obligatoires." #: library/argparse.rst:1805 msgid "FileType objects" msgstr "Objets ``FileType``" #: library/argparse.rst:1809 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 "" #: library/argparse.rst:1821 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 "" #: library/argparse.rst:1830 msgid "The *encodings* and *errors* keyword arguments." msgstr "Les arguments nommés ``encodings`` et ``errors``." #: library/argparse.rst:1835 msgid "Argument groups" msgstr "Groupes d'arguments" #: library/argparse.rst:1839 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 "" #: library/argparse.rst:1856 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 "" #: library/argparse.rst:1882 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 "" #: library/argparse.rst:1887 msgid "Mutual exclusion" msgstr "Exclusion mutuelle" #: library/argparse.rst:1891 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 "" #: library/argparse.rst:1907 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 "" #: library/argparse.rst:1919 msgid "" "Note that currently mutually exclusive argument groups do not support the " "*title* and *description* arguments of :meth:`~ArgumentParser." "add_argument_group`." msgstr "" #: library/argparse.rst:1925 msgid "Parser defaults" msgstr "Valeurs par défaut de l'analyseur" #: library/argparse.rst:1929 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 "" #: library/argparse.rst:1941 msgid "" "Note that parser-level defaults always override argument-level defaults::" msgstr "" #: library/argparse.rst:1949 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 "" #: library/argparse.rst:1955 msgid "" "Get the default value for a namespace attribute, as set by either :meth:" "`~ArgumentParser.add_argument` or by :meth:`~ArgumentParser.set_defaults`::" msgstr "" #: library/argparse.rst:1966 msgid "Printing help" msgstr "Afficher l'aide" #: library/argparse.rst:1968 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 "" #: library/argparse.rst:1974 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 "" #: library/argparse.rst:1980 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 "" #: library/argparse.rst:1984 msgid "" "There are also variants of these methods that simply return a string instead " "of printing it:" msgstr "" #: library/argparse.rst:1989 msgid "" "Return a string containing a brief description of how the :class:" "`ArgumentParser` should be invoked on the command line." msgstr "" #: library/argparse.rst:1994 msgid "" "Return a string containing a help message, including the program usage and " "information about the arguments registered with the :class:`ArgumentParser`." msgstr "" #: library/argparse.rst:1999 msgid "Partial parsing" msgstr "*Parsing* partiel" #: library/argparse.rst:2003 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 "" #: library/argparse.rst:2019 msgid "" ":ref:`Prefix matching ` rules apply to :meth:" "`parse_known_args`. The parser may consume an option even if it's just a " "prefix of one of its known options, instead of leaving it in the remaining " "arguments list." msgstr "" #: library/argparse.rst:2026 msgid "Customizing file parsing" msgstr "Personnaliser le *parsing* de fichiers" #: library/argparse.rst:2030 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 "" #: library/argparse.rst:2035 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 "" #: library/argparse.rst:2039 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 "" #: library/argparse.rst:2048 msgid "Exiting methods" msgstr "" #: library/argparse.rst:2052 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 "" #: library/argparse.rst:2064 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 "" #: library/argparse.rst:2069 msgid "Intermixed parsing" msgstr "Analyse entremêlée" #: library/argparse.rst:2074 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 "" #: library/argparse.rst:2079 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 "" #: library/argparse.rst:2084 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 "" #: library/argparse.rst:2099 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 "" #: library/argparse.rst:2109 msgid "Upgrading optparse code" msgstr "Mettre à jour du code ``optparse``" #: library/argparse.rst:2111 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 "" #: library/argparse.rst:2118 msgid "" "The :mod:`argparse` module improves on the standard library :mod:`optparse` " "module in a number of ways including:" msgstr "" "Le module :mod:`argparse` fournit plusieurs améliorations par rapport au " "module :mod:`optparse` de la bibliothèque standard :" #: library/argparse.rst:2121 msgid "Handling positional arguments." msgstr "Gère les arguments positionnels." #: library/argparse.rst:2122 msgid "Supporting sub-commands." msgstr "Prise en charge des sous commandes." #: library/argparse.rst:2123 msgid "Allowing alternative option prefixes like ``+`` and ``/``." msgstr "" "Permet d'utiliser les alternatives ``+`` ou ``/`` comme préfixes d'option." #: library/argparse.rst:2124 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:2125 msgid "Producing more informative usage messages." msgstr "Fournit des messages d'aide plus complets." #: library/argparse.rst:2126 msgid "Providing a much simpler interface for custom ``type`` and ``action``." msgstr "" "Fournit une interface plus simple pour les types et actions personnalisés" #: library/argparse.rst:2128 msgid "A partial upgrade path from :mod:`optparse` to :mod:`argparse`:" msgstr "Le portage partiel d':mod:`optparse` à :mod:`argparse` :" #: library/argparse.rst:2130 msgid "" "Replace all :meth:`optparse.OptionParser.add_option` calls with :meth:" "`ArgumentParser.add_argument` calls." msgstr "" "Remplacer tous les appels à :meth:`optparse.OptionParser.add_option` par des " "appels à :meth:`ArgumentParser.add_argument`." #: library/argparse.rst:2133 msgid "" "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:2138 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:2142 msgid "" "Replace callback actions and the ``callback_*`` keyword arguments with " "``type`` or ``action`` arguments." msgstr "" "Remplacer les actions de rappel (*callback actions* en anglais) et les " "arguments nommés ``callback_*`` par des arguments ``type`` et ``actions``." #: library/argparse.rst:2145 msgid "" "Replace string names for ``type`` keyword arguments with the corresponding " "type objects (e.g. int, float, complex, etc)." msgstr "" "Remplacer les chaînes représentant le nom des types pour l'argument nommé " "``type`` par les objets types correspondants (par exemple : ``int``, " "``float``, ``complex``, etc)." #: library/argparse.rst:2148 msgid "" "Replace :class:`optparse.Values` with :class:`Namespace` and :exc:`optparse." "OptionError` and :exc:`optparse.OptionValueError` with :exc:`ArgumentError`." msgstr "" "Remplacer :class:`optparse.Values` par :class:`Namespace` ; et :exc:" "`optparse.OptionError` et :exc:`optparse.OptionValueError` par :exc:" "`ArgumentError`." #: library/argparse.rst:2152 msgid "" "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:2156 msgid "" "Replace the OptionParser constructor ``version`` argument with a call to " "``parser.add_argument('--version', action='version', version='')``." msgstr "" "Remplacer l'argument ``version`` du constructeur d'``OptionParser`` par un " "appel à ``parser.add_argument('--version', action='version', version='')``."