argparse.po

# 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: 2023-10-12 19:43+0200\n"
"PO-Revision-Date: 2022-11-02 10:58-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.13.0\n"

#: ../Doc/library/argparse.rst:2
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`"

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
#, fuzzy
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: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: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: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
#, fuzzy
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
#, fuzzy
msgid ":class:`int`, ``'?'``, ``'*'``, or ``'+'``"
msgstr ":class:`int`, ``'?'``, ``'*'``, ``'+'``, o ``argparse.REMAINDER``"

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

#: ../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: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: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: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: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: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: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: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
#, fuzzy
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
#, fuzzy
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:780
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
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 ""
"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:263
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:282
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:292
#, 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:309
msgid "usage"
msgstr "uso"

#: ../Doc/library/argparse.rst:311
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:327
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:342
#, 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:349
msgid "description"
msgstr "*description*"

#: ../Doc/library/argparse.rst:351
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:366
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:371
msgid "epilog"
msgstr "*epilog*"

#: ../Doc/library/argparse.rst:373
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:390
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:396
msgid "parents"
msgstr "*parents*"

#: ../Doc/library/argparse.rst:398
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:418
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:423
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:431
msgid "formatter_class"
msgstr "*formatter_class*"

#: ../Doc/library/argparse.rst:433
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:442
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:467
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:493
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:498
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:516
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` utiliza el nombre del parámetro type_ para "
"cada argumento como el nombre a mostrar para sus valores (en lugar de "
"utilizar dest_ como lo hace el formato habitual)::"

#: ../Doc/library/argparse.rst:537
msgid "prefix_chars"
msgstr "*prefix_chars*"

#: ../Doc/library/argparse.rst:539
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 mayoría de las opciones de la línea de comandos usarán ``-`` como "
"prefijo, por ejemplo ``-f/--foo``. Los analizadores que necesiten soportar "
"caracteres prefijo diferentes o adicionales, por ejemplo, para opciones como "
"``+f`` o ``/foo``, pueden especificarlos usando el argumento "
"``prefix_chars=`` para el constructor *ArgumentParser*::"

#: ../Doc/library/argparse.rst:551
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 ""
"El argumento ``prefix_chars=`` tiene un valor por defecto de ``'-'``. "
"Proporcionar un conjunto de caracteres que no incluya ``-`` causará que las "
"opciones ``-f/--foo`` no sean inhabilitadas."

#: ../Doc/library/argparse.rst:557
msgid "fromfile_prefix_chars"
msgstr "*fromfile_prefix_chars*"

#: ../Doc/library/argparse.rst:559
msgid ""
"Sometimes, when dealing with a particularly long argument list, 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 ""
"Algunas veces, cuando se trata de una lista de argumentos particularmente "
"larga, puede tener sentido mantener la lista de argumentos en un archivo en "
"lugar de escribirla en la línea de comandos. Si el argumento "
"``fromfile_prefix_chars=`` se da al constructor :class:`ArgumentParser`, "
"entonces los argumentos que empiezan con cualquiera de los caracteres "
"especificados se tratarán como archivos, y serán reemplazados por los "
"argumentos que contienen. Por ejemplo::"

#: ../Doc/library/argparse.rst:574
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 ""
"Los argumentos leídos de un archivo deben ser por defecto uno por línea "
"(pero vea también :meth:`~ArgumentParser.convert_arg_line_to_args`) y se "
"tratan como si estuvieran en el mismo lugar que el argumento de referencia "
"del archivo original en la línea de comandos. Así, en el ejemplo anterior, "
"la expresión ``[‘-f’, ‘foo’, ‘@args.txt’]`` se considera equivalente a la "
"expresión ``[‘-f’, ‘foo’, ‘-f’, ‘bar’]``."

#: ../Doc/library/argparse.rst:580
msgid ""
":class:`ArgumentParser` uses :term:`filesystem encoding and error handler` "
"to read the file containing arguments."
msgstr ""

#: ../Doc/library/argparse.rst:583
msgid ""
"The ``fromfile_prefix_chars=`` argument defaults to ``None``, meaning that "
"arguments will never be treated as file references."
msgstr ""
"El argumento ``fromfile_prefix_chars=`` por defecto es ``None``, lo que "
"significa que los argumentos nunca serán tratados como referencias de "
"archivos."

#: ../Doc/library/argparse.rst:586
msgid ""
":class:`ArgumentParser` changed encoding and errors to read arguments files "
"from default (e.g. :func:`locale.getpreferredencoding(False) <locale."
"getpreferredencoding>` and ``\"strict\"``) to :term:`filesystem encoding and "
"error handler`. Arguments file should be encoded in UTF-8 instead of ANSI "
"Codepage on Windows."
msgstr ""

#: ../Doc/library/argparse.rst:594
msgid "argument_default"
msgstr "*argument_default*"

#: ../Doc/library/argparse.rst:596
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 ""
"Generalmente, los valores por defecto de los argumentos se especifican ya "
"sea pasando un valor por defecto a :meth:`~ArgumentParser.add_argument` o "
"llamando a los métodos :meth:`~ArgumentParser.set_defaults` con un conjunto "
"específico de pares nombre-valor. A veces, sin embargo, puede ser útil "
"especificar un único valor por defecto para todos los argumentos del "
"analizador. Esto se puede lograr pasando el argumento de palabra clave "
"``argument_default=`` a :class:`ArgumentParser`. Por ejemplo, para suprimir "
"globalmente la creación de atributos en las llamadas a :meth:"
"`~ArgumentParser.parse_args` , proporcionamos el argumento "
"``argument_default=SUPPRESS``::"

#: ../Doc/library/argparse.rst:616
msgid "allow_abbrev"
msgstr "*allow_abbrev*"

#: ../Doc/library/argparse.rst:618
msgid ""
"Normally, when you pass an argument list to the :meth:`~ArgumentParser."
"parse_args` method of an :class:`ArgumentParser`, it :ref:`recognizes "
"abbreviations <prefix-matching>` of long options."
msgstr ""
"Normalmente, cuando pasas una lista de argumentos al método :meth:"
"`~ArgumentParser.parse_args` de un :class:`ArgumentParser`, :ref:`reconoce "
"las abreviaturas <prefix-matching>` de las opciones largas."

#: ../Doc/library/argparse.rst:622
msgid "This feature can be disabled by setting ``allow_abbrev`` to ``False``::"
msgstr ""
"Esta característica puede ser desactivada poniendo ``allow_abbrev`` a "
"``False``::"

#: ../Doc/library/argparse.rst:635
msgid "conflict_handler"
msgstr "*conflict_handler*"

#: ../Doc/library/argparse.rst:637
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 ""
"Los objetos :class:`ArgumentParser` no permiten dos acciones con la misma "
"cadena de caracteres de opción. Por defecto, los objetos :class:"
"`ArgumentParser` lanzan una excepción si se intenta crear un argumento con "
"una cadena de caracteres de opción que ya está en uso::"

#: ../Doc/library/argparse.rst:649
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 ""
"A veces (por ejemplo, cuando se utiliza parents_) puede ser útil anular "
"simplemente cualquier argumento antiguo con la misma cadena de caracteres de "
"opción. Para lograr este comportamiento, se puede suministrar el valor "
"``'resolve'`` al argumento ``conflict_handler=`` de :class:`ArgumentParser`::"

#: ../Doc/library/argparse.rst:665
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 ""
"Ten en cuenta que los objetos :class:`ArgumentParser` sólo eliminan una "
"acción si todas sus cadenas de caracteres de opción están anuladas. Así, en "
"el ejemplo anterior, la antigua acción ``-f/--foo`` se mantiene como la "
"acción ``-f``, porque sólo la cadena de caracteres de opción ``--foo`` fue "
"anulada."

#: ../Doc/library/argparse.rst:672
msgid "add_help"
msgstr "*add_help*"

#: ../Doc/library/argparse.rst:674
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 ""
"Por defecto, los objetos *ArgumentParser* añaden una opción que simplemente "
"muestra el mensaje de ayuda del analizador. Por ejemplo, considera un "
"archivo llamado ``myprogram.py`` que contiene el siguiente código::"

#: ../Doc/library/argparse.rst:683
msgid ""
"If ``-h`` or ``--help`` is supplied at the command line, the ArgumentParser "
"help will be printed:"
msgstr ""
"Si ``-h`` o ``--help`` se indica en la línea de comandos, se imprimirá la "
"ayuda de *ArgumentParser*:"

#: ../Doc/library/argparse.rst:695
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 ""
"Ocasionalmente, puede ser útil desactivar la inclusión de esta opción de "
"ayuda. Esto se puede lograr pasando ``False`` como argumento de "
"``add_help=`` a :class:`ArgumentParser`::"

#: ../Doc/library/argparse.rst:707
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 ""
"La opción de ayuda es típicamente ``-h/--help``. La excepción a esto es si "
"``prefix_chars=`` se especifica y no incluye ``-``, en cuyo caso ``-h`` y "
"``--help`` no son opciones válidas. En este caso, el primer carácter en "
"``prefix_chars`` se utiliza para preceder a las opciones de ayuda::"

#: ../Doc/library/argparse.rst:722
msgid "exit_on_error"
msgstr "exit_on_error"

#: ../Doc/library/argparse.rst:724
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 ""
"Normalmente, cuando pasa una lista de argumentos no válidos al método :meth:"
"`~ArgumentParser.parse_args` de un :class:`ArgumentParser`, saldrá con "
"información de error."

#: ../Doc/library/argparse.rst:727
msgid ""
"If the user would like to catch errors manually, the feature can be enabled "
"by setting ``exit_on_error`` to ``False``::"
msgstr ""
"Si el usuario desea detectar errores manualmente, la función se puede "
"habilitar configurando ``exit_on_error`` en ``False`` ::"

#: ../Doc/library/argparse.rst:744
msgid "The add_argument() method"
msgstr "El método *add_argument()*"

#: ../Doc/library/argparse.rst:750
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 ""
"Define cómo se debe interpretar un determinado argumento de línea de "
"comandos. Cada parámetro tiene su propia descripción más detallada a "
"continuación, pero en resumen son::"

#: ../Doc/library/argparse.rst:753
msgid ""
"`name or flags`_ - Either a name or a list of option strings, e.g. ``foo`` "
"or ``-f, --foo``."
msgstr ""
"`name or flags`_ - Ya sea un nombre o una lista de cadena de caracteres de "
"opción, e.g. ``foo`` o ``-f, --foo``."

#: ../Doc/library/argparse.rst:756
msgid ""
"action_ - The basic type of action to be taken when this argument is "
"encountered at the command line."
msgstr ""
"action_ - El tipo básico de acción a tomar cuando este argumento se "
"encuentra en la línea de comandos."

#: ../Doc/library/argparse.rst:759
msgid "nargs_ - The number of command-line arguments that should be consumed."
msgstr ""
"nargs_ - El número de argumentos de la línea de comandos que deben ser "
"consumidos."