# Copyright (C) 2001-2020, Python Software Foundation

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

# Maintained by the python-doc-es workteam.

# docs-es@python.org /

# https://mail.python.org/mailman3/lists/docs-es.python.org/

# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to

# get the list of volunteers

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2024-11-21 16:38-0300\n"

"PO-Revision-Date: 2024-10-30 12:17-0600\n"

"Last-Translator: Diego Alberto Barriga Martínez <umoqnier@riseup.net>\n"

"Language: es\n"

"Language-Team: python-doc-es\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

"MIME-Version: 1.0\n"

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

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

"Generated-By: Babel 2.16.0\n"

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

#, fuzzy

msgid ""

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

"commands"

msgstr ""

":mod:`argparse` — Analizador sintáctico (*Parser*) para las opciones, "

"argumentos y sub-comandos de la línea de comandos"

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

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

msgstr "**Código fuente:** :source:`Lib/argparse.py`"

#: ../Doc/library/argparse.rst:-1

msgid "Tutorial"

msgstr "Tutorial"

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

msgid ""

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

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

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

msgstr ""

"Esta página contiene la información de referencia de la API. Para una "

"introducción más amigable al análisis de la línea de comandos de Python, "

"echa un vistazo al :ref:`argparse tutorial <argparse-tutorial>`."

#: ../Doc/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. "

"The module will also issue errors when users give the program invalid "

"arguments."

msgstr ""

"El módulo :mod:`argparse` facilita la escritura de interfaces de línea de "

"comandos amigables. El programa define qué argumentos requiere, y :mod:"

"`argparse` averiguará cómo analizarlos vía :data:`sys.argv`. El módulo :mod:"

"`argparse` también genera automáticamente mensajes de ayuda y de uso. El "

"módulo también emitirá errores cuando las usuarias den argumentos inválidos "

"al programa."

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

msgid "Core Functionality"

msgstr "Funcionalidad principal"

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

msgid ""

"The :mod:`argparse` module's support for command-line interfaces is built "

"around an instance of :class:`argparse.ArgumentParser`. It is a container "

"for argument specifications and has options that apply to the parser as "

"whole::"

msgstr ""

"El soporte del módulo :mod:`argparse` para las interfaces de líneas de "

"comandos es construido alrededor de una instancia de :class:`argparse."

"ArgumentParser`. Este es un contenedor para las especificaciones de los "

"argumentos y tiene opciones que aplican el analizador como un todo::"

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

msgid ""

"parser = argparse.ArgumentParser(\n"

" prog='ProgramName',\n"

" description='What the program does',\n"

" epilog='Text at the bottom of help')"

msgstr ""

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

msgid ""

"The :meth:`ArgumentParser.add_argument` method attaches individual argument "

"specifications to the parser. It supports positional arguments, options "

"that accept values, and on/off flags::"

msgstr ""

"El método :meth:`ArgumentParser.add_argument` adjunta especificaciones de "

"argumentos individuales al analizador. Soporta argumentos posicionales, "

"opciones que aceptan valores, y banderas de activación y desactivación::"

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

msgid ""

"parser.add_argument('filename') # positional argument\n"

"parser.add_argument('-c', '--count') # option that takes a value\n"

"parser.add_argument('-v', '--verbose',\n"

" action='store_true') # on/off flag"

msgstr ""

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

msgid ""

"The :meth:`ArgumentParser.parse_args` method runs the parser and places the "

"extracted data in a :class:`argparse.Namespace` object::"

msgstr ""

"El método :meth:`ArgumentParser.parse_args` corre el analizador y coloca los "

"datos extraídos en un objeto :class:`argparse.Namespace`::"

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

msgid ""

"args = parser.parse_args()\n"

"print(args.filename, args.count, args.verbose)"

msgstr ""

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

msgid "Quick Links for add_argument()"

msgstr "Enlaces rápidos para add_argument()"

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

msgid "Name"

msgstr "Nombre"

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

msgid "Description"

msgstr "Descripción"

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

msgid "Values"

msgstr "Valores"

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

msgid "action_"

msgstr "action_"

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

msgid "Specify how an argument should be handled"

msgstr "Especifica como debe ser manejado un argumento"

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

msgid ""

"``'store'``, ``'store_const'``, ``'store_true'``, ``'append'``, "

"``'append_const'``, ``'count'``, ``'help'``, ``'version'``"

msgstr ""

"``'store'``, ``'store_const'``, ``'store_true'``, ``'append'``, "

"``'append_const'``, ``'count'``, ``'help'``, ``'version'``"

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

msgid "choices_"

msgstr "choices_"

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

msgid "Limit values to a specific set of choices"

msgstr "Limita los valores a un conjunto específico de opciones"

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

msgid ""

"``['foo', 'bar']``, ``range(1, 10)``, or :class:`~collections.abc.Container` "

"instance"

msgstr ""

"``['foo', 'bar']``, ``range(1, 10)``, o una instancia de :class:"

"`~collections.abc.Container`"

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

msgid "const_"

msgstr "const_"

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

msgid "Store a constant value"

msgstr "Guarda un valor constante"

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

msgid "default_"

msgstr "default_"

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

msgid "Default value used when an argument is not provided"

msgstr "Valor por defecto usado cuando un argumento no es proporcionado"

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

msgid "Defaults to ``None``"

msgstr "Por defecto a ``None``"

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

msgid "dest_"

msgstr "dest_"

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

msgid "Specify the attribute name used in the result namespace"

msgstr ""

"Especifica el nombre del atributo usado en el espacio de nombres del "

"resultado"

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

msgid "help_"

msgstr "help_"

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

msgid "Help message for an argument"

msgstr "Mensaje de ayuda para un argumento"

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

msgid "metavar_"

msgstr "metavar_"

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

msgid "Alternate display name for the argument as shown in help"

msgstr ""

"Alterna la visualización del nombre para el argumento como es mostrado en la "

"ayuda"

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

msgid "nargs_"

msgstr "nargs_"

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

msgid "Number of times the argument can be used"

msgstr "Número de veces que puede ser usado un argumento"

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

msgid ":class:`int`, ``'?'``, ``'*'``, or ``'+'``"

msgstr ":class:`int`, ``'?'``, ``'*'``, o ``'+'``"

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

msgid "required_"

msgstr "required_"

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

msgid "Indicate whether an argument is required or optional"

msgstr "Indica si un argumento es requerido u opcional"

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

msgid "``True`` or ``False``"

msgstr "``True`` o ``False``"

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

msgid ":ref:`type <argparse-type>`"

msgstr ":ref:`type <argparse-type>`"

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

msgid "Automatically convert an argument to the given type"

msgstr "Convierte automáticamente un argumento al tipo dado"

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

msgid ""

":class:`int`, :class:`float`, ``argparse.FileType('w')``, or callable "

"function"

msgstr ""

":class:`int`, :class:`float`, ``argparse.FileType('w')``, o una función "

"invocable"

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

msgid "Example"

msgstr "Ejemplo"

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

msgid ""

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

"produces either the sum or the max::"

msgstr ""

"El siguiente código es un programa Python que toma una lista de números "

"enteros y obtiene la suma o el máximo::"

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

msgid ""

"import argparse\n"

"\n"

"parser = argparse.ArgumentParser(description='Process some integers.')\n"

"parser.add_argument('integers', metavar='N', type=int, nargs='+',\n"

" help='an integer for the accumulator')\n"

"parser.add_argument('--sum', dest='accumulate', action='store_const',\n"

" const=sum, default=max,\n"

" help='sum the integers (default: find the max)')\n"

"\n"

"args = parser.parse_args()\n"

"print(args.accumulate(args.integers))"

msgstr ""

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

msgid ""

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

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

msgstr ""

"Se asume que el código Python anterior se guarda en un archivo llamado "

"``prog.py``, se puede ejecutar en la línea de comandos y proporciona "

"mensajes de ayuda útiles:"

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

msgid ""

"$ python prog.py -h\n"

"usage: prog.py [-h] [--sum] N [N ...]\n"

"\n"

"Process some integers.\n"

"\n"

"positional arguments:\n"

" N an integer for the accumulator\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

" --sum sum the integers (default: find the max)"

msgstr ""

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

msgid ""

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

"of the command-line integers:"

msgstr ""

"Cuando se ejecuta con los parámetros apropiados, muestra la suma o el máximo "

"de los números enteros de la línea de comandos:"

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

msgid ""

"$ python prog.py 1 2 3 4\n"

"4\n"

"\n"

"$ python prog.py 1 2 3 4 --sum\n"

"10"

msgstr ""

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

msgid "If invalid arguments are passed in, an error will be displayed:"

msgstr "Si se proporcionan argumentos inválidos, se mostrará un error:"

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

msgid ""

"$ python prog.py a b c\n"

"usage: prog.py [-h] [--sum] N [N ...]\n"

"prog.py: error: argument N: invalid int value: 'a'"

msgstr ""

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

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

msgstr "Las siguientes secciones te guiarán a través de este ejemplo."

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

msgid "Creating a parser"

msgstr "Creando un analizador sintáctico (*parser*)"

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

msgid ""

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

"`ArgumentParser` object::"

msgstr ""

"El primer paso para usar :mod:`argparse` es crear un objeto :class:"

"`ArgumentParser` ::"

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

msgid ""

">>> parser = argparse.ArgumentParser(description='Process some integers.')"

msgstr ""

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

msgid ""

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

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

msgstr ""

"El objeto :class:`ArgumentParser` contendrá toda la información necesaria "

"para analizar la línea de comandos con los tipos de datos de Python."

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

msgid "Adding arguments"

msgstr "Añadiendo argumentos"

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

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

"Completar un :class:`ArgumentParser` con información sobre los argumentos "

"del programa se hace realizando llamadas al método :meth:`~ArgumentParser."

"add_argument`. Generalmente, estas llamadas le dicen a :class:"

"`ArgumentParser` cómo capturar las cadenas de caracteres de la línea de "

"comandos y convertirlas en objetos. Esta información se almacena y se usa "

"cuando se llama a :meth:`~ArgumentParser.parse_args`. Por ejemplo::"

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

msgid ""

">>> parser.add_argument('integers', metavar='N', type=int, nargs='+',\n"

"... help='an integer for the accumulator')\n"

">>> parser.add_argument('--sum', dest='accumulate', action='store_const',\n"

"... const=sum, default=max,\n"

"... help='sum the integers (default: find the max)')"

msgstr ""

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

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 integers, 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 ""

"Después, llamando a :meth:`~ArgumentParser.parse_args` retornará un objeto "

"con dos atributos, ``integers`` y ``accumulate``. El atributo ``integers`` "

"será una lista de uno o más enteros, y el atributo ``accumulate`` será o "

"bien la función :func:`sum`, si se especificó ``--sum`` en la línea de "

"comandos, o la función :func:`max` si no."

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

msgid "Parsing arguments"

msgstr "Analizando argumentos"

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

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` analiza los argumentos mediante el método :meth:"

"`~ArgumentParser.parse_args`. Éste inspeccionará la línea de comandos, "

"convertirá cada argumento al tipo apropiado y luego invocará la acción "

"correspondiente. En la mayoría de los casos, esto significa que un simple "

"objeto :class:`Namespace` se construirá a partir de los atributos analizados "

"en la línea de comandos::"

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

msgid ""

">>> parser.parse_args(['--sum', '7', '-1', '42'])\n"

"Namespace(accumulate=<built-in function sum>, integers=[7, -1, 42])"

msgstr ""

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

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

"En un *script*, :meth:`~ArgumentParser.parse_args` será llamado típicamente "

"sin argumentos, y la :class:`ArgumentParser` determinará automáticamente los "

"argumentos de la línea de comandos de :data:`sys.argv`."

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

msgid "ArgumentParser objects"

msgstr "Objetos *ArgumentParser*"

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

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

"Crea un nuevo objeto :class:`ArgumentParser`. Todos los parámetros deben "

"pasarse como argumentos de palabra clave. Cada parámetro tiene su propia "

"descripción más detallada a continuación, pero en resumen son:"

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

msgid ""

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

msgstr ""

"prog_ - El nombre del programa (default: ``os.path.basename(sys.argv[0])``)"

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

msgid ""

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

"arguments added to parser)"

msgstr ""

"usage_ - La cadena de caracteres que describe el uso del programa (por "

"defecto: generado a partir de los argumentos añadidos al analizador)"

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

msgid ""

"description_ - Text to display before the argument help (by default, no text)"

msgstr ""

"description_ - Texto a mostrar antes del argumento ayuda (por defecto, "

"ninguno)"

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

msgid "epilog_ - Text to display after the argument help (by default, no text)"

msgstr ""

"epilog_ - Texto a mostrar después del argumento ayuda (por defecto, ninguno)"

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

msgid ""

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

"also be included"

msgstr ""

"parents_ - Una lista de objetos :class:`ArgumentParser` cuyos argumentos "

"también deberían ser incluidos"

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

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

msgstr "formatter_class_ - Una clase para personalizar la salida de la ayuda"

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

msgid ""

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

"(default: '-')"

msgstr ""

"prefix_chars_ - El conjunto de caracteres que preceden a los argumentos "

"opcionales (por defecto: ‘-‘)"

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

msgid ""

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

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

msgstr ""

"fromfile_prefix_chars_ - El conjunto de caracteres que preceden a los "

"archivos de los cuales se deberían leer los argumentos adicionales (por "

"defecto: ``None``)"

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

msgid ""

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

"``None``)"

msgstr ""

"argument_default_ - El valor global por defecto de los argumentos (por "

"defecto: ``None``)"

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

msgid ""

"conflict_handler_ - The strategy for resolving conflicting optionals "

"(usually unnecessary)"

msgstr ""

"conflict_handler_ - La estrategia para resolver los opcionales conflictivos "

"(normalmente es innecesaria)"

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

msgid ""

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

msgstr ""

"add_help_ - Añade una opción ``-h/--help`` al analizador (por defecto: "

"``True``)"

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

msgid ""

"allow_abbrev_ - Allows long options to be abbreviated if the abbreviation is "

"unambiguous. (default: ``True``)"

msgstr ""

"allow_abbrev_ - Permite abreviar las opciones largas si la abreviatura es "

"inequívoca. (por defecto: ``True``)"

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

msgid ""

"exit_on_error_ - Determines whether or not ArgumentParser exits with error "

"info when an error occurs. (default: ``True``)"

msgstr ""

"exit_on_error_ - Determina si ArgumentParser sale o no con información de "

"error cuando se produce un error. (predeterminado: ``True``)"

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

msgid "*allow_abbrev* parameter was added."

msgstr "se añadió el parámetro *allow_abbrev*."

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

msgid ""

"In previous versions, *allow_abbrev* also disabled grouping of short flags "

"such as ``-vv`` to mean ``-v -v``."

msgstr ""

"En versiones anteriores, *allow_abbrev* también deshabilitaba la agrupación "

"de banderas (*flags*) cortas como ``-vv`` para que sea ``-v -v``."

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

msgid "*exit_on_error* parameter was added."

msgstr "Se agregó el parámetro *exit_on_error*."

#: ../Doc/library/argparse.rst:244 ../Doc/library/argparse.rst:783

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

msgstr ""

"En las siguientes secciones se describe cómo se utiliza cada una de ellas."

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

msgid "prog"

msgstr "*prog*"

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

#, fuzzy

msgid ""

"By default, :class:`ArgumentParser` objects use the base name (see :func:`os."

"path.basename`) of ``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 the name that was used to "

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

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

msgstr ""

"Por defecto, los objetos :class:`ArgumentParser` utilizan ``sys.argv[0]`` "

"para determinar cómo mostrar el nombre del programa en los mensajes de "

"ayuda. Este valor por defecto es casi siempre deseable porque hará que los "

"mensajes de ayuda coincidan con la forma en que el programa fue invocado en "

"la línea de comandos. Por ejemplo, considera un archivo llamado ``myprogram."

"py`` con el siguiente código::"

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

msgid ""

"import argparse\n"

"parser = argparse.ArgumentParser()\n"

"parser.add_argument('--foo', help='foo help')\n"

"args = parser.parse_args()"

msgstr ""

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

msgid ""

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

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

msgstr ""

"La ayuda para este programa mostrará ``myprogram.py`` como el nombre del "

"programa (sin importar desde dónde se haya invocado el programa):"

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

msgid ""

"$ python myprogram.py --help\n"

"usage: myprogram.py [-h] [--foo FOO]\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

" --foo FOO foo help\n"

"$ cd ..\n"

"$ python subdir/myprogram.py --help\n"

"usage: myprogram.py [-h] [--foo FOO]\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

" --foo FOO foo help"

msgstr ""

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

msgid ""

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

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

msgstr ""

"Para cambiar este comportamiento por defecto, se puede proporcionar otro "

"valor usando el argumento ``prog=`` para :class:`ArgumentParser`::"

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

msgid ""

">>> parser = argparse.ArgumentParser(prog='myprogram')\n"

">>> parser.print_help()\n"

"usage: myprogram [-h]\n"

"\n"

"options:\n"

" -h, --help show this help message and exit"

msgstr ""

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

#, python-format

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

"Ten en cuenta que el nombre del programa, ya sea determinado a partir de "

"``sys.argv[0]`` o del argumento ``prog=`` , está disponible para los "

"mensajes de ayuda usando el especificador de formato ``%(prog)s``."

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

#, python-format

msgid ""

">>> parser = argparse.ArgumentParser(prog='myprogram')\n"

">>> parser.add_argument('--foo', help='foo of the %(prog)s program')\n"

">>> parser.print_help()\n"

"usage: myprogram [-h] [--foo FOO]\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

" --foo FOO foo of the myprogram program"

msgstr ""

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

msgid "usage"

msgstr "uso"

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

msgid ""

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

"arguments it contains::"

msgstr ""

"Por defecto, :class:`ArgumentParser` determina el mensaje de uso a partir de "

"los argumentos que contiene::"

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

msgid ""

">>> parser = argparse.ArgumentParser(prog='PROG')\n"

">>> parser.add_argument('--foo', nargs='?', help='foo help')\n"

">>> parser.add_argument('bar', nargs='+', help='bar help')\n"

">>> parser.print_help()\n"

"usage: PROG [-h] [--foo [FOO]] bar [bar ...]\n"

"\n"

"positional arguments:\n"

" bar bar help\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

" --foo [FOO] foo help"

msgstr ""

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

msgid ""

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

msgstr ""

"El mensaje por defecto puede ser sustituido con el argumento de palabra "

"clave ``usage=``::"

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

#, python-format

msgid ""

">>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s "

"[options]')\n"

">>> parser.add_argument('--foo', nargs='?', help='foo help')\n"

">>> parser.add_argument('bar', nargs='+', help='bar help')\n"

">>> parser.print_help()\n"

"usage: PROG [options]\n"

"\n"

"positional arguments:\n"

" bar bar help\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

" --foo [FOO] foo help"

msgstr ""

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

#, python-format

msgid ""

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

"in your usage messages."

msgstr ""

"El especificador de formato ``%(prog)s`` está preparado para introducir el "

"nombre del programa en los mensajes de ayuda."

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

msgid "description"

msgstr "*description*"

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

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 mayoría de las llamadas al constructor :class:`ArgumentParser` usarán el "

"argumento de palabra clave ``description=``. Este argumento da una breve "

"descripción de lo que hace el programa y cómo funciona. En los mensajes de "

"ayuda, la descripción se muestra entre la cadena de caracteres de uso "

"(*usage*) de la línea de comandos y los mensajes de ayuda para los distintos "

"argumentos::"

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

msgid ""

">>> parser = argparse.ArgumentParser(description='A foo that bars')\n"

">>> parser.print_help()\n"

"usage: argparse.py [-h]\n"

"\n"

"A foo that bars\n"

"\n"

"options:\n"

" -h, --help show this help message and exit"

msgstr ""

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

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

"Por defecto, la descripción será ajustada a una línea para que encaje en el "

"espacio dado. Para cambiar este comportamiento, revisa el argumento "

"formatter_class_."

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

msgid "epilog"

msgstr "*epilog*"

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

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

"A algunos programas les gusta mostrar una descripción adicional del programa "

"después de la descripción de los argumentos. Dicho texto puede ser "

"especificado usando el argumento ``epilog=`` para :class:`ArgumentParser`::"

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

msgid ""

">>> parser = argparse.ArgumentParser(\n"

"... description='A foo that bars',\n"

"... epilog=\"And that's how you'd foo a bar\")\n"

">>> parser.print_help()\n"

"usage: argparse.py [-h]\n"

"\n"

"A foo that bars\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

"\n"

"And that's how you'd foo a bar"

msgstr ""

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

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

"Al igual que con el argumento description_, el texto ``epilog=`` está por "

"defecto ajustado a una línea, pero este comportamiento puede ser modificado "

"con el argumento formatter_class_ para :class:`ArgumentParser`."

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

msgid "parents"

msgstr "*parents*"

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

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

"A veces, varios analizadores comparten un conjunto de argumentos comunes. En "

"lugar de repetir las definiciones de estos argumentos, se puede usar un "

"único analizador con todos los argumentos compartidos y pasarlo en el "

"argumento ``parents=`` a :class:`ArgumentParser`. El argumento ``parents=`` "

"toma una lista de objetos :class:`ArgumentParser`, recoge todas las acciones "

"de posición y de opción de éstos, y añade estas acciones al objeto :class:"

"`ArgumentParser` que se está construyendo::"

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

msgid ""

">>> parent_parser = argparse.ArgumentParser(add_help=False)\n"

">>> parent_parser.add_argument('--parent', type=int)\n"

"\n"

">>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])\n"

">>> foo_parser.add_argument('foo')\n"

">>> foo_parser.parse_args(['--parent', '2', 'XXX'])\n"

"Namespace(foo='XXX', parent=2)\n"

"\n"

">>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])\n"

">>> bar_parser.add_argument('--bar')\n"

">>> bar_parser.parse_args(['--bar', 'YYY'])\n"

"Namespace(bar='YYY', parent=None)"

msgstr ""

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

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

"Ten en cuenta que la mayoría de los analizadores padre especificarán "

"``add_help=False``. De lo contrario, el :class:`ArgumentParser` verá dos "

"opciones ``-h/—help`` (una para el padre y otra para el hijo) y generará un "

"error."

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

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

"Debes inicializar completamente los analizadores antes de pasarlos a través "

"de ``parents=``. Si cambias los analizadores padre después del analizador "

"hijo, esos cambios no se reflejarán en el hijo."

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

msgid "formatter_class"

msgstr "*formatter_class*"

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

msgid ""

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

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

"classes:"

msgstr ""

"Los objetos :class:`ArgumentParser` permiten personalizar el formato de la "

"ayuda especificando una clase de formato alternativa. Actualmente, hay "

"cuatro clases de este tipo:"

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

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` y :class:`RawTextHelpFormatter` dan más "

"control sobre cómo se muestran las descripciones de texto. Por defecto, los "

"objetos :class:`ArgumentParser` ajustan a la línea los textos de "

"description_ y epilog_ en los mensajes de ayuda de la línea de comandos::"

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

msgid ""

">>> parser = argparse.ArgumentParser(\n"

"... prog='PROG',\n"

"... description='''this description\n"

"... was indented weird\n"

"... but that is okay''',\n"

"... epilog='''\n"

"... likewise for this epilog whose whitespace will\n"

"... be cleaned up and whose words will be wrapped\n"

"... across a couple lines''')\n"

">>> parser.print_help()\n"

"usage: PROG [-h]\n"

"\n"

"this description was indented weird but that is okay\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

"\n"

"likewise for this epilog whose whitespace will be cleaned up and whose "

"words\n"

"will be wrapped across a couple lines"

msgstr ""

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

msgid ""

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

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

"should not be line-wrapped::"

msgstr ""

"Pasar :class:`RawDescriptionHelpFormatter` como ``formatter_class=`` indica "

"que description_ y epilog_ ya tienen el formato correcto y no deben ser "

"ajustados a la línea::"

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

msgid ""

">>> parser = argparse.ArgumentParser(\n"

"... prog='PROG',\n"

"... formatter_class=argparse.RawDescriptionHelpFormatter,\n"

"... description=textwrap.dedent('''\\\n"

"... Please do not mess up this text!\n"

"... --------------------------------\n"

"... I have indented it\n"

"... exactly the way\n"

"... I want it\n"

"... '''))\n"

">>> parser.print_help()\n"

"usage: PROG [-h]\n"

"\n"

"Please do not mess up this text!\n"

"--------------------------------\n"

" I have indented it\n"

" exactly the way\n"

" I want it\n"

"\n"

"options:\n"

" -h, --help show this help message and exit"

msgstr ""

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

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` mantiene espacios en blanco para todo tipo de "

"texto de ayuda, incluyendo descripciones de argumentos. Sin embargo, varias "

"líneas nuevas son reemplazadas por una sola. Si deseas conservar varias "

"líneas en blanco, añade espacios entre las nuevas líneas."

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

msgid ""

":class:`ArgumentDefaultsHelpFormatter` automatically adds information about "

"default values to each of the argument help messages::"

msgstr ""

":class:`ArgumentDefaultsHelpFormatter` añade automáticamente información "

"sobre los valores por defecto a cada uno de los mensajes de ayuda de los "

"argumentos::"

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

msgid ""

">>> parser = argparse.ArgumentParser(\n"

"... prog='PROG',\n"

"... formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n"

">>> parser.add_argument('--foo', type=int, default=42, help='FOO!')\n"

">>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')\n"

">>> parser.print_help()\n"

"usage: PROG [-h] [--foo FOO] [bar ...]\n"

"\n"

"positional arguments:\n"

" bar BAR! (default: [1, 2, 3])\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

" --foo FOO FOO! (default: 42)"

msgstr ""

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

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