optparse.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: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: 2021-08-04 21:42+0200\n"
"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@gmail.com>\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.10.3\n"

#: ../Doc/library/optparse.rst:2
msgid ":mod:`optparse` --- Parser for command line options"
msgstr ""
":mod:`optparse` --- Analizador sintáctico (parser) para opciones de línea de "
"comandos"

#: ../Doc/library/optparse.rst:11
msgid "**Source code:** :source:`Lib/optparse.py`"
msgstr "**Source code:** :source:`Lib/optparse.py`"

#: ../Doc/library/optparse.rst:13
msgid ""
"The :mod:`optparse` module is deprecated and will not be developed further; "
"development will continue with the :mod:`argparse` module."
msgstr ""
"El módulo :mod:`optparse` está obsoleto y no será desarrollado de aquí en "
"adelante. El desarrollo continuará en el módulo :mod:`argparse`."

#: ../Doc/library/optparse.rst:19
msgid ""
":mod:`optparse` is a more convenient, flexible, and powerful library for "
"parsing command-line options than the old :mod:`getopt` module.  :mod:"
"`optparse` uses a more declarative style of command-line parsing: you create "
"an instance of :class:`OptionParser`, populate it with options, and parse "
"the command line. :mod:`optparse` allows users to specify options in the "
"conventional GNU/POSIX syntax, and additionally generates usage and help "
"messages for you."
msgstr ""
":mod:`optparse` es una biblioteca más conveniente, flexible y poderosa para "
"analizar opciones de línea de comandos que el antiguo módulo :mod:`getopt`. :"
"mod:`optparse` usa un estilo más declarativo: creas una instancia de :class:"
"`OptionParser`, le añades las opciones deseadas y realizas el análisis "
"sintáctico de la línea de comandos. :mod:`optparse` permite a los usuarios "
"especificar opciones siguiendo la sintaxis convencional de GNU/POSIX, además "
"de generar mensajes de uso y de ayuda automáticamente."

#: ../Doc/library/optparse.rst:26
msgid "Here's an example of using :mod:`optparse` in a simple script::"
msgstr ""
"A continuación puedes ver un ejemplo de uso de :mod:`optparse` mediante un "
"script simple::"

#: ../Doc/library/optparse.rst:39
msgid ""
"With these few lines of code, users of your script can now do the \"usual "
"thing\" on the command-line, for example::"
msgstr ""
"Con estas pocas líneas de código, los usuarios de tu script ahora pueden "
"hacer un uso \"normal\" del mismo mediante la línea de comandos, por "
"ejemplo::"

#: ../Doc/library/optparse.rst:44
msgid ""
"As it parses the command line, :mod:`optparse` sets attributes of the "
"``options`` object returned by :meth:`parse_args` based on user-supplied "
"command-line values.  When :meth:`parse_args` returns from parsing this "
"command line, ``options.filename`` will be ``\"outfile\"`` and ``options."
"verbose`` will be ``False``.  :mod:`optparse` supports both long and short "
"options, allows short options to be merged together, and allows options to "
"be associated with their arguments in a variety of ways.  Thus, the "
"following command lines are all equivalent to the above example::"
msgstr ""
"A medida que analiza la línea de comandos, :mod:`optparse` establece los "
"atributos del objeto ``options`` retornado por :meth:`parse_args` basándose "
"en los valores de la línea de comandos proporcionada por el usuario. Cuando :"
"meth:`parse_args` termina de analizar esta línea de comandos, ``options."
"filename`` será ``\"outfile\"`` y ``options.verbose`` será ``False``. :mod:"
"`optparse` admite opciones largas y cortas, fusionar opciones cortas y "
"asociar opciones con sus argumentos de diversas formas. Por lo tanto, las "
"siguientes líneas de comandos son todas equivalentes al ejemplo previo::"

#: ../Doc/library/optparse.rst:58
msgid "Additionally, users can run one of the following ::"
msgstr "Además, los usuarios pueden ejecutar uno de los siguientes::"

#: ../Doc/library/optparse.rst:63
msgid ""
"and :mod:`optparse` will print out a brief summary of your script's options:"
msgstr ""
"y :mod:`optparse` imprimirá un breve resumen de las opciones de tu script:"

#: ../Doc/library/optparse.rst:74
msgid ""
"where the value of *yourscript* is determined at runtime (normally from "
"``sys.argv[0]``)."
msgstr ""
"donde el valor de *yourscript* se determina en tiempo de ejecución "
"(normalmente a partir de ``sys.argv [0]``)."

#: ../Doc/library/optparse.rst:81
msgid "Background"
msgstr "Contexto"

#: ../Doc/library/optparse.rst:83
msgid ""
":mod:`optparse` was explicitly designed to encourage the creation of "
"programs with straightforward, conventional command-line interfaces.  To "
"that end, it supports only the most common command-line syntax and semantics "
"conventionally used under Unix.  If you are unfamiliar with these "
"conventions, read this section to acquaint yourself with them."
msgstr ""
":mod:`optparse` ha sido diseñado explícitamente para fomentar la creación de "
"programas con interfaces de línea de comandos convencionales y sencillas. "
"Con ese fin en mente, solo admite la sintaxis y semántica de línea de "
"comandos más común y convencionalmente usada en Unix. Si no estás "
"familiarizado con estas convenciones, lee esta sección para familiarizarte "
"con ellas."

#: ../Doc/library/optparse.rst:93
msgid "Terminology"
msgstr "Terminología"

#: ../Doc/library/optparse.rst:104
msgid "argument"
msgstr "argumento"

#: ../Doc/library/optparse.rst:96
msgid ""
"a string entered on the command-line, and passed by the shell to ``execl()`` "
"or ``execv()``.  In Python, arguments are elements of ``sys.argv[1:]`` "
"(``sys.argv[0]`` is the name of the program being executed).  Unix shells "
"also use the term \"word\"."
msgstr ""
"una cadena de caracteres ingresada en la línea de comandos y pasada mediante "
"la shell a ``execl()`` o ``execv()``. En Python, los argumentos son "
"elementos de ``sys.argv[1:]`` (dado que ``sys.argv[0]`` es el propio nombre "
"del programa que se está ejecutando). Las shells de Unix también usan el "
"término \"*word*\" ('palabra') para referirse a ellos."

#: ../Doc/library/optparse.rst:101
msgid ""
"It is occasionally desirable to substitute an argument list other than ``sys."
"argv[1:]``, so you should read \"argument\" as \"an element of ``sys."
"argv[1:]``, or of some other list provided as a substitute for ``sys."
"argv[1:]``\"."
msgstr ""
"En ocasiones es deseable proporcionar una lista de argumentos que no sea "
"``sys.argv[1:]``, por lo que deberías considerar un 'argumento' como 'un "
"elemento de ``sys.argv[1:]`` o de alguna otra lista proporcionada como "
"sustituto de ``sys.argv[1:]``'."

#: ../Doc/library/optparse.rst:134
msgid "option"
msgstr "opción"

#: ../Doc/library/optparse.rst:107
msgid ""
"an argument used to supply extra information to guide or customize the "
"execution of a program.  There are many different syntaxes for options; the "
"traditional Unix syntax is a hyphen (\"-\") followed by a single letter, e."
"g. ``-x`` or ``-F``.  Also, traditional Unix syntax allows multiple options "
"to be merged into a single argument, e.g. ``-x -F`` is equivalent to ``-"
"xF``.  The GNU project introduced ``--`` followed by a series of hyphen-"
"separated words, e.g. ``--file`` or ``--dry-run``.  These are the only two "
"option syntaxes provided by :mod:`optparse`."
msgstr ""
"un argumento utilizado para proporcionar información adicional con la "
"finalidad de guiar o personalizar la ejecución de un programa. Existen "
"muchas sintaxis diferentes para especificar opciones. La sintaxis "
"tradicional de Unix es un guion ('-') seguido de una sola letra, por ejemplo "
"``-x`` o ``-F``. La sintaxis tradicional de Unix permite además fusionar "
"múltiples opciones en un solo argumento, por ejemplo ``-x -F`` es "
"equivalente a ``-xF``. Por otro lado, el proyecto GNU introdujo ``--`` "
"seguido de una serie de palabras separadas por guiones, por ejemplo ``--"
"file`` o ``--dry-run``. Estas son las dos únicas sintaxis para opciones que "
"el módulo :mod:`optparse` proporciona."

#: ../Doc/library/optparse.rst:116
msgid "Some other option syntaxes that the world has seen include:"
msgstr "Algunas de las otras sintaxis para opciones que el mundo ha visto son:"

#: ../Doc/library/optparse.rst:118
msgid ""
"a hyphen followed by a few letters, e.g. ``-pf`` (this is *not* the same as "
"multiple options merged into a single argument)"
msgstr ""
"un guion seguido de algunas letras, por ejemplo ``-pf`` (esto *no* es lo "
"mismo que múltiples opciones fusionadas en un solo argumento)"

#: ../Doc/library/optparse.rst:121
msgid ""
"a hyphen followed by a whole word, e.g. ``-file`` (this is technically "
"equivalent to the previous syntax, but they aren't usually seen in the same "
"program)"
msgstr ""
"un guion seguido de una palabra completa, por ejemplo ``-file`` (esto es "
"técnicamente equivalente a la sintaxis anterior, pero generalmente no se ven "
"ambas en un mismo programa)"

#: ../Doc/library/optparse.rst:125
msgid ""
"a plus sign followed by a single letter, or a few letters, or a word, e.g. "
"``+f``, ``+rgb``"
msgstr ""
"un signo más seguido de una sola letra, unas pocas letras o una palabra, por "
"ejemplo ``+f`` o ``+rgb``"

#: ../Doc/library/optparse.rst:128
msgid ""
"a slash followed by a letter, or a few letters, or a word, e.g. ``/f``, ``/"
"file``"
msgstr ""
"una barra seguida de una letra, de unas pocas letras o de una palabra, por "
"ejemplo ``/f`` o ``/file``"

#: ../Doc/library/optparse.rst:131
#, fuzzy
msgid ""
"These option syntaxes are not supported by :mod:`optparse`, and they never "
"will be.  This is deliberate: the first three are non-standard on any "
"environment, and the last only makes sense if you're exclusively targeting "
"Windows or certain legacy platforms (e.g. VMS, MS-DOS)."
msgstr ""
"Estas sintaxis para opciones no son compatibles con :mod:`optparse` y nunca "
"lo serán. Esto es deliberado: los tres primeros no son estándar en ningún "
"entorno y el último solo tiene sentido si se dirige exclusivamente a VMS, MS-"
"DOS y/o Windows."

#: ../Doc/library/optparse.rst:160
msgid "option argument"
msgstr "argumento de opción"

#: ../Doc/library/optparse.rst:137
msgid ""
"an argument that follows an option, is closely associated with that option, "
"and is consumed from the argument list when that option is. With :mod:"
"`optparse`, option arguments may either be in a separate argument from their "
"option:"
msgstr ""
"un argumento que sigue a una opción, está estrechamente asociado con ella y "
"se consume de la lista de argumentos cuando esa opción es consumida. Con :"
"mod:`optparse`, los argumentos de las opciones pueden estar en un argumento "
"separado de su opción:"

#: ../Doc/library/optparse.rst:147
msgid "or included in the same argument:"
msgstr "o incluidos en el mismo argumento:"

#: ../Doc/library/optparse.rst:154
msgid ""
"Typically, a given option either takes an argument or it doesn't. Lots of "
"people want an \"optional option arguments\" feature, meaning that some "
"options will take an argument if they see it, and won't if they don't.  This "
"is somewhat controversial, because it makes parsing ambiguous: if ``-a`` "
"takes an optional argument and ``-b`` is another option entirely, how do we "
"interpret ``-ab``?  Because of this ambiguity, :mod:`optparse` does not "
"support this feature."
msgstr ""
"Normalmente, una opción dada puede aceptar o no un argumento. Mucha gente "
"desea una característica de \"argumentos de opción opcionales\", lo que "
"implica que algunas opciones aceptarán un argumento si está presente y no lo "
"aceptarán si no lo está. Esto es algo controvertido, porque hace que el "
"análisis sea ambiguo: si ``-a`` toma un argumento opcional y ``-b`` es otra "
"opción completamente distinta, ¿cómo interpretamos ``-ab``? Debido a esta "
"ambigüedad, :mod:`optparse` no es compatible con esta funcionalidad."

#: ../Doc/library/optparse.rst:165
msgid "positional argument"
msgstr "argumento posicional"

#: ../Doc/library/optparse.rst:163
msgid ""
"something leftover in the argument list after options have been parsed, i.e. "
"after options and their arguments have been parsed and removed from the "
"argument list."
msgstr ""
"es algo que queda en la lista de argumentos después de que las opciones "
"hayan sido analizadas sintácticamente, es decir, después de que las opciones "
"y sus argumentos hayan sido analizados y eliminados de la lista de "
"argumentos."

#: ../Doc/library/optparse.rst:171
msgid "required option"
msgstr "opción requerida"

#: ../Doc/library/optparse.rst:168
msgid ""
"an option that must be supplied on the command-line; note that the phrase "
"\"required option\" is self-contradictory in English.  :mod:`optparse` "
"doesn't prevent you from implementing required options, but doesn't give you "
"much help at it either."
msgstr ""
"es una opción que debe proporcionarse forzosamente en la línea de comandos. "
"Ten en cuenta que la frase \"opción requerida\" se contradice a si misma. :"
"mod:`optparse` no te impide implementar opciones requeridas, pero tampoco "
"brinda mucha ayuda para ello."

#: ../Doc/library/optparse.rst:173
msgid "For example, consider this hypothetical command-line::"
msgstr "Por ejemplo, considera esta hipotética linea de comandos:"

#: ../Doc/library/optparse.rst:177
msgid ""
"``-v`` and ``--report`` are both options.  Assuming that ``--report`` takes "
"one argument, ``report.txt`` is an option argument.  ``foo`` and ``bar`` are "
"positional arguments."
msgstr ""
"``-v`` y ``--report`` son ambas opciones. ``report.txt`` es un argumento de "
"opción, suponiendo que ``--report`` toma un argumento. En cambio, ``foo`` y "
"``bar`` son ambos argumentos posicionales."

#: ../Doc/library/optparse.rst:185
msgid "What are options for?"
msgstr "¿Qué finalidad tienen las opciones?"

#: ../Doc/library/optparse.rst:187
msgid ""
"Options are used to provide extra information to tune or customize the "
"execution of a program.  In case it wasn't clear, options are usually "
"*optional*.  A program should be able to run just fine with no options "
"whatsoever.  (Pick a random program from the Unix or GNU toolsets.  Can it "
"run without any options at all and still make sense?  The main exceptions "
"are ``find``, ``tar``, and ``dd``\\ ---all of which are mutant oddballs that "
"have been rightly criticized for their non-standard syntax and confusing "
"interfaces.)"
msgstr ""
"Las opciones se utilizan para poder proporcionar información adicional con "
"el fin de ajustar o personalizar la ejecución de un programa. Por si aún no "
"ha quedado claro, las opciones suelen ser *opcionales*. Un programa debería "
"poder ejecutarse sin problemas sin ninguna opción. (Elija un programa "
"aleatorio del conjunto de herramientas de Unix o GNU. ¿Puede ejecutarse sin "
"ninguna opción y aún así tener sentido? Las principales excepciones son "
"``find``, ``tar`` y ``dd``\\ ---los cuales son todos bichos raros mutantes "
"que han sido apropiadamente criticados por su sintaxis no estándar y por "
"tener interfaces confusas)."

#: ../Doc/library/optparse.rst:195
msgid ""
"Lots of people want their programs to have \"required options\".  Think "
"about it. If it's required, then it's *not optional*!  If there is a piece "
"of information that your program absolutely requires in order to run "
"successfully, that's what positional arguments are for."
msgstr ""
"Como se ha comentado, mucha gente quiere que sus programas tengan \"opciones "
"requeridas\". Pero pensemos en ello detenidamente. ¡Si es necesario, "
"entonces *no es opcional*! Si hay una pieza de información absolutamente "
"requerida para que tu programa pueda ejecutarse correctamente no uses "
"opciones, para eso están los argumentos posicionales."

#: ../Doc/library/optparse.rst:200
msgid ""
"As an example of good command-line interface design, consider the humble "
"``cp`` utility, for copying files.  It doesn't make much sense to try to "
"copy files without supplying a destination and at least one source. Hence, "
"``cp`` fails if you run it with no arguments.  However, it has a flexible, "
"useful syntax that does not require any options at all::"
msgstr ""
"Como ejemplo de un buen diseño de una interfaz de línea de comandos, "
"considera la humilde herramienta ``cp`` para copiar archivos. No tiene mucho "
"sentido intentar copiar archivos sin proporcionar un destino y al menos una "
"fuente de origen. Por lo tanto, ``cp`` falla si lo ejecutas sin argumentos. "
"Sin embargo, tiene una sintaxis flexible y útil que no requiere ninguna "
"opción::"

#: ../Doc/library/optparse.rst:209
msgid ""
"You can get pretty far with just that.  Most ``cp`` implementations provide "
"a bunch of options to tweak exactly how the files are copied: you can "
"preserve mode and modification time, avoid following symlinks, ask before "
"clobbering existing files, etc.  But none of this distracts from the core "
"mission of ``cp``, which is to copy either one file to another, or several "
"files to another directory."
msgstr ""
"Puedes hacer mucho simplemente con eso. La mayoría de las implementaciones "
"de ``cp`` proporcionan un montón de opciones para modificar exactamente cómo "
"se copian los archivos: se puede preservar el modo y la fecha de "
"modificación, evitar que se sigan enlaces simbólicos, preguntar antes de "
"sobrescribir el contenido de archivos existentes, etc. Pero nada de esto "
"distrae de la misión principal de ``cp``, que consiste en copiar uno o "
"varios archivos en otro directorio."

#: ../Doc/library/optparse.rst:220
msgid "What are positional arguments for?"
msgstr "¿Qué finalidad tienen los argumentos posicionales?"

#: ../Doc/library/optparse.rst:222
msgid ""
"Positional arguments are for those pieces of information that your program "
"absolutely, positively requires to run."
msgstr ""
"Los argumentos posicionales son adecuados para aquellas piezas de "
"información que tu programa, absolutamente y sin duda alguna, requiere para "
"funcionar."

#: ../Doc/library/optparse.rst:225
msgid ""
"A good user interface should have as few absolute requirements as possible.  "
"If your program requires 17 distinct pieces of information in order to run "
"successfully, it doesn't much matter *how* you get that information from the "
"user---most people will give up and walk away before they successfully run "
"the program.  This applies whether the user interface is a command-line, a "
"configuration file, or a GUI: if you make that many demands on your users, "
"most of them will simply give up."
msgstr ""
"Una buena interfaz de usuario debería tener la menor cantidad de requisitos "
"absolutos posibles. Si tu programa requiere 17 piezas distintas de "
"información para ejecutarse correctamente, no importa mucho *cómo* obtengas "
"esa información del usuario; la mayoría de ellos se rendirán y se irán antes "
"de ejecutar con éxito el programa. Esto se aplica tanto si la interfaz de "
"usuario es una línea de comandos, un archivo de configuración o una GUI: si "
"hace demasiadas demandas a sus usuarios, la mayoría simplemente se rendirá."

#: ../Doc/library/optparse.rst:233
msgid ""
"In short, try to minimize the amount of information that users are "
"absolutely required to supply---use sensible defaults whenever possible.  Of "
"course, you also want to make your programs reasonably flexible.  That's "
"what options are for.  Again, it doesn't matter if they are entries in a "
"config file, widgets in the \"Preferences\" dialog of a GUI, or command-line "
"options---the more options you implement, the more flexible your program is, "
"and the more complicated its implementation becomes.  Too much flexibility "
"has drawbacks as well, of course; too many options can overwhelm users and "
"make your code much harder to maintain."
msgstr ""
"En resumen, trata de minimizar la cantidad de información que los usuarios "
"están absolutamente obligados a proporcionar, utiliza valores "
"predeterminados sensatos siempre que sea posible. Como es natural, también "
"deseas que tus programas sean razonablemente flexibles, para eso están las "
"opciones. De nuevo, no importa si son entradas en un archivo de "
"configuración, widgets en un cuadro de diálogo de \"Preferencias\" de una "
"GUI u opciones en la línea de comandos; cuantas más opciones implementes, "
"más flexible será tu programa y más complicada se vuelve su implementación. "
"Una excesiva flexibilidad evidentemente también tiene inconvenientes, "
"demasiadas opciones pueden abrumar a los usuarios y hacer que tu código sea "
"mucho más difícil de mantener."

#: ../Doc/library/optparse.rst:246
msgid "Tutorial"
msgstr "Tutorial"

#: ../Doc/library/optparse.rst:248
msgid ""
"While :mod:`optparse` is quite flexible and powerful, it's also "
"straightforward to use in most cases.  This section covers the code patterns "
"that are common to any :mod:`optparse`\\ -based program."
msgstr ""
"Si bien :mod:`optparse` es bastante flexible y potente, también es sencillo "
"de usar en la mayoría de los casos. Esta sección cubre los patrones de "
"código comunes a cualquier programa basado en :mod:`optparse`."

#: ../Doc/library/optparse.rst:252
msgid ""
"First, you need to import the OptionParser class; then, early in the main "
"program, create an OptionParser instance::"
msgstr ""
"En primer lugar, necesitas importar la clase OptionParser y luego, al "
"comienzo del programa principal, crear una instancia de ella::"

#: ../Doc/library/optparse.rst:259
msgid "Then you can start defining options.  The basic syntax is::"
msgstr "Ahora ya puedes comenzar a definir opciones. La sintaxis básica es:"

#: ../Doc/library/optparse.rst:264
msgid ""
"Each option has one or more option strings, such as ``-f`` or ``--file``, "
"and several option attributes that tell :mod:`optparse` what to expect and "
"what to do when it encounters that option on the command line."
msgstr ""
"Cada opción tiene una o más cadenas de caracteres de opción, como ``-f`` o "
"``--file`` y varios atributos de opción que le dicen a :mod:`optparse` qué "
"esperar y qué hacer cuando encuentra esa opción en la línea de comandos."

#: ../Doc/library/optparse.rst:268
msgid ""
"Typically, each option will have one short option string and one long option "
"string, e.g.::"
msgstr ""
"Normalmente, cada opción tendrá una cadena de opción corta y una cadena de "
"opción larga, por ejemplo:"

#: ../Doc/library/optparse.rst:273
msgid ""
"You're free to define as many short option strings and as many long option "
"strings as you like (including zero), as long as there is at least one "
"option string overall."
msgstr ""
"Puedes definir tantas cadenas de opción cortas y tantas largas como desees "
"(incluso ninguna), siempre que haya al menos una cadena de opción en total."

#: ../Doc/library/optparse.rst:277
msgid ""
"The option strings passed to :meth:`OptionParser.add_option` are effectively "
"labels for the option defined by that call.  For brevity, we will frequently "
"refer to *encountering an option* on the command line; in reality, :mod:"
"`optparse` encounters *option strings* and looks up options from them."
msgstr ""
"Las cadenas de opción pasadas a :meth:`OptionParser.add_option` son en "
"definitiva etiquetas para la opción definida por esa llamada. Simplemente "
"por brevedad, con frecuencia nos referiremos a *encontrar una opción* en la "
"línea de comandos. En realidad, :mod:`optparse` encuentra *cadenas de "
"caracteres de opción* y busca opciones en ellas."

#: ../Doc/library/optparse.rst:283
msgid ""
"Once all of your options are defined, instruct :mod:`optparse` to parse your "
"program's command line::"
msgstr ""
"Una vez que todas tus opciones estén definidas, indica a :mod:`optparse` que "
"analice sintácticamente la línea de comandos de tu programa::"

#: ../Doc/library/optparse.rst:288
msgid ""
"(If you like, you can pass a custom argument list to :meth:`parse_args`, but "
"that's rarely necessary: by default it uses ``sys.argv[1:]``.)"
msgstr ""
"(Si lo deseas, puedes pasar una lista de argumentos personalizada a :meth:"
"`parse_args`, pero eso rara vez es necesario: por defecto se usa ``sys.argv "
"[1:]``.)"

#: ../Doc/library/optparse.rst:291
msgid ":meth:`parse_args` returns two values:"
msgstr ":meth:`parse_args` retorna dos valores:"

#: ../Doc/library/optparse.rst:293
msgid ""
"``options``, an object containing values for all of your options---e.g. if "
"``--file`` takes a single string argument, then ``options.file`` will be the "
"filename supplied by the user, or ``None`` if the user did not supply that "
"option"
msgstr ""
"``options``, un objeto que contiene valores para todas tus opciones. Por "
"ejemplo, si ``--file`` toma un argumento de una sola cadena de caracteres, "
"entonces ``options.file`` será el nombre del archivo proporcionado por el "
"usuario o ``None`` si el usuario no proporcionó esa opción en la linea de "
"comandos"

#: ../Doc/library/optparse.rst:298
msgid ""
"``args``, the list of positional arguments leftover after parsing options"
msgstr ""
"``args``, la lista de argumentos posicionales que quedan después de analizar "
"las opciones"

#: ../Doc/library/optparse.rst:300
msgid ""
"This tutorial section only covers the four most important option "
"attributes: :attr:`~Option.action`, :attr:`~Option.type`, :attr:`~Option."
"dest` (destination), and :attr:`~Option.help`. Of these, :attr:`~Option."
"action` is the most fundamental."
msgstr ""
"Este tutorial solo cubre los cuatro atributos de opción más importantes: :"
"attr:`~Option.action`, :attr:`~Option.type`, :attr:`~Option.dest` (destino) "
"y :attr:`~Option.help`. De todos ellos, :attr:`~Option.action` es el "
"fundamental."

#: ../Doc/library/optparse.rst:309
msgid "Understanding option actions"
msgstr "Comprendiendo las acciones de opción"

#: ../Doc/library/optparse.rst:311
msgid ""
"Actions tell :mod:`optparse` what to do when it encounters an option on the "
"command line.  There is a fixed set of actions hard-coded into :mod:"
"`optparse`; adding new actions is an advanced topic covered in section :ref:"
"`optparse-extending-optparse`.  Most actions tell :mod:`optparse` to store a "
"value in some variable---for example, take a string from the command line "
"and store it in an attribute of ``options``."
msgstr ""
"Las acciones le dicen a :mod:`optparse` qué hacer cuando encuentra una "
"determinada opción en la línea de comandos. Hay un conjunto fijo de acciones "
"codificadas en :mod:`optparse`. Agregar nuevas acciones es un tema avanzado "
"cubierto en la sección :ref:`optparse-extending-optparse`. La mayoría de las "
"acciones indican a :mod:`optparse` que almacene un valor en alguna variable, "
"por ejemplo, tomar una cadena de caracteres de la línea de comandos y "
"almacenarla en un atributo del objeto ``options``."

#: ../Doc/library/optparse.rst:318
msgid ""
"If you don't specify an option action, :mod:`optparse` defaults to ``store``."
msgstr ""
"Si no se especifica una acción para la opción, :mod:`optparse` usa por "
"defecto ``store``."

#: ../Doc/library/optparse.rst:324
msgid "The store action"
msgstr "La acción store"

#: ../Doc/library/optparse.rst:326
msgid ""
"The most common option action is ``store``, which tells :mod:`optparse` to "
"take the next argument (or the remainder of the current argument), ensure "
"that it is of the correct type, and store it to your chosen destination."
msgstr ""
"La acción para opciones más común es ``store``, que le dice a :mod:"
"`optparse` que tome el siguiente argumento (o el resto del argumento "
"actual), se asegure de que sea del tipo correcto y lo guarde en el destino "
"elegido."

#: ../Doc/library/optparse.rst:330
msgid "For example::"
msgstr "Por ejemplo::"

#: ../Doc/library/optparse.rst:335
msgid ""
"Now let's make up a fake command line and ask :mod:`optparse` to parse it::"
msgstr ""
"Ahora creamos una línea de comandos simulada y le pedimos a :mod:`optparse` "
"que la analice::"

#: ../Doc/library/optparse.rst:340
msgid ""
"When :mod:`optparse` sees the option string ``-f``, it consumes the next "
"argument, ``foo.txt``, and stores it in ``options.filename``.  So, after "
"this call to :meth:`parse_args`, ``options.filename`` is ``\"foo.txt\"``."
msgstr ""
"Cuando :mod:`optparse` se encuentra con la cadena de opción ``-f``, consume "
"el siguiente argumento, ``foo.txt`` y lo almacena en ``options.filename``. "
"Por lo tanto, después de la llamada a :meth:`parse_args`, ``options."
"filename`` será ``\"foo.txt\"``."

#: ../Doc/library/optparse.rst:344
msgid ""
"Some other option types supported by :mod:`optparse` are ``int`` and "
"``float``. Here's an option that expects an integer argument::"
msgstr ""
"Algunos de los otros tipos de opción admitidos por :mod:`optparse` son "
"``int`` y ``float``. Aquí hay una opción que espera un argumento entero::"

#: ../Doc/library/optparse.rst:349
msgid ""
"Note that this option has no long option string, which is perfectly "
"acceptable. Also, there's no explicit action, since the default is ``store``."
msgstr ""
"Ten en cuenta que esta opción no tiene una cadena de opción larga, lo cual "
"es perfectamente aceptable. Además, no hay ninguna acción explícita, ya que "
"el valor predeterminado es ``store``."

#: ../Doc/library/optparse.rst:352
msgid ""
"Let's parse another fake command-line.  This time, we'll jam the option "
"argument right up against the option: since ``-n42`` (one argument) is "
"equivalent to ``-n 42`` (two arguments), the code ::"
msgstr ""
"Analicemos otra línea de comandos simulada. En esta ocasión, vamos a "
"proporcionar el argumento de la opción pegado junto a la misma, sin "
"separación entre ambos: dado que ``-n42`` (un argumento) es equivalente a ``-"
"n 42`` (dos argumentos), el código::"

#: ../Doc/library/optparse.rst:359
msgid "will print ``42``."
msgstr "imprimirá ``42``."

#: ../Doc/library/optparse.rst:361
msgid ""
"If you don't specify a type, :mod:`optparse` assumes ``string``.  Combined "
"with the fact that the default action is ``store``, that means our first "
"example can be a lot shorter::"
msgstr ""
"Si no se especifica un tipo, :mod:`optparse` asume ``string``. Esto, "
"combinado con el hecho de que la acción predeterminada es ``store``, implica "
"que nuestro primer ejemplo puede implementarse de forma mucho más concisa::"

#: ../Doc/library/optparse.rst:367
msgid ""
"If you don't supply a destination, :mod:`optparse` figures out a sensible "
"default from the option strings: if the first long option string is ``--foo-"
"bar``, then the default destination is ``foo_bar``.  If there are no long "
"option strings, :mod:`optparse` looks at the first short option string: the "
"default destination for ``-f`` is ``f``."
msgstr ""
"Si no se proporciona un destino, :mod:`optparse` infiere un destino por "
"defecto adecuado a partir de las cadenas de opción proporcionadas: si la "
"primera cadena de opción larga es ``--foo-bar``, entonces el destino "
"predeterminado es ``foo_bar``. Si no hay cadenas de opción largas, :mod:"
"`optparse` mira la primera cadena de opción corta: por ejemplo, el destino "
"predeterminado para ``-f`` es ``f``."

#: ../Doc/library/optparse.rst:373
msgid ""
":mod:`optparse` also includes the built-in ``complex`` type.  Adding types "
"is covered in section :ref:`optparse-extending-optparse`."
msgstr ""
":mod:`optparse` también incluye el tipo incorporado ``complex``. La adición "
"de nuevos tipos se cubre en la sección :ref:`optparse-extending-optparse`."

#: ../Doc/library/optparse.rst:380
msgid "Handling boolean (flag) options"
msgstr "Manejo de opciones booleanas (flags)"

#: ../Doc/library/optparse.rst:382
msgid ""
"Flag options---set a variable to true or false when a particular option is "
"seen---are quite common.  :mod:`optparse` supports them with two separate "
"actions, ``store_true`` and ``store_false``.  For example, you might have a "
"``verbose`` flag that is turned on with ``-v`` and off with ``-q``::"
msgstr ""
"Las opciones flags\\ ---establecen una variable en verdadero o falso cuando "
"se encuentra una opción en particular--- son bastante comunes. :mod:"
"`optparse` las admite con dos acciones diferenciadas, ``store_true`` y "
"``store_false``. Por ejemplo, puedes tener un flag ``verbose`` que se activa "
"con ``-v`` y se desactiva con ``-q``::"

#: ../Doc/library/optparse.rst:390
msgid ""
"Here we have two different options with the same destination, which is "
"perfectly OK.  (It just means you have to be a bit careful when setting "
"default values---see below.)"
msgstr ""
"Aquí tenemos dos opciones diferentes con el mismo destino, lo cual es "
"totalmente correcto. Solo significa que debes tener un poco de cuidado al "
"establecer los valores predeterminados, lo veremos a continuación."

#: ../Doc/library/optparse.rst:394
msgid ""
"When :mod:`optparse` encounters ``-v`` on the command line, it sets "
"``options.verbose`` to ``True``; when it encounters ``-q``, ``options."
"verbose`` is set to ``False``."
msgstr ""
"Cuando :mod:`optparse` encuentra ``-v`` en la línea de comandos, establece "
"``options.verbose`` en ``True``; cuando encuentra ``-q``, ``options."
"verbose`` se establece en ``False``."

#: ../Doc/library/optparse.rst:402
msgid "Other actions"
msgstr "Otras acciones"

#: ../Doc/library/optparse.rst:404
msgid "Some other actions supported by :mod:`optparse` are:"
msgstr "Algunas de las otras acciones soportadas por :mod:`optparse` son:"

#: ../Doc/library/optparse.rst:407 ../Doc/library/optparse.rst:928
msgid "``\"store_const\"``"
msgstr "``\"store_const\"``"

#: ../Doc/library/optparse.rst:407 ../Doc/library/optparse.rst:928
msgid "store a constant value"
msgstr "almacena un valor constante"

#: ../Doc/library/optparse.rst:410 ../Doc/library/optparse.rst:937
msgid "``\"append\"``"
msgstr "``\"append\"``"

#: ../Doc/library/optparse.rst:410 ../Doc/library/optparse.rst:937
msgid "append this option's argument to a list"
msgstr "agrega el argumento de esta opción a una lista"

#: ../Doc/library/optparse.rst:413 ../Doc/library/optparse.rst:943
msgid "``\"count\"``"
msgstr "``\"count\"``"

#: ../Doc/library/optparse.rst:413 ../Doc/library/optparse.rst:943
msgid "increment a counter by one"
msgstr "incrementa un contador en uno"

#: ../Doc/library/optparse.rst:416 ../Doc/library/optparse.rst:946
msgid "``\"callback\"``"
msgstr "``\"callback\"``"

#: ../Doc/library/optparse.rst:416 ../Doc/library/optparse.rst:946
msgid "call a specified function"
msgstr "llama a una función específica"

#: ../Doc/library/optparse.rst:418
msgid ""
"These are covered in section :ref:`optparse-reference-guide`, and section :"
"ref:`optparse-option-callbacks`."
msgstr ""
"Estas acciones se tratan en la sección :ref:`optparse-reference-guide` y en "
"la sección :ref:`optparse-option-callbacks`."

#: ../Doc/library/optparse.rst:425
msgid "Default values"
msgstr "Valores por defecto"

#: ../Doc/library/optparse.rst:427
msgid ""
"All of the above examples involve setting some variable (the "
"\"destination\") when certain command-line options are seen.  What happens "
"if those options are never seen?  Since we didn't supply any defaults, they "
"are all set to ``None``.  This is usually fine, but sometimes you want more "
"control.  :mod:`optparse` lets you supply a default value for each "
"destination, which is assigned before the command line is parsed."
msgstr ""
"Todos los ejemplos anteriores implican establecer alguna variable (el "
"\"destino\") cuando aparecen ciertas opciones en la línea de comandos. ¿Qué "
"pasa si esas opciones nunca se encuentran? Dado que no proporcionamos ningún "
"valor predeterminado, todas las variables están establecidas en ``None``. "
"Por lo general, esto está bien, pero a veces se desea tener más control. :"
"mod:`optparse` permite proporcionar un valor predeterminado para cada "
"destino, que es asignado antes de analizar la línea de comandos."

#: ../Doc/library/optparse.rst:434
msgid ""
"First, consider the verbose/quiet example.  If we want :mod:`optparse` to "
"set ``verbose`` to ``True`` unless ``-q`` is seen, then we can do this::"
msgstr ""
"Primero, considera el ejemplo verbose/quiet anterior. Si queremos que :mod:"
"`optparse` establezca ``verbose`` en ``True`` a menos que encuentre ``-q``, "
"entonces podemos hacer lo siguiente::"

#: ../Doc/library/optparse.rst:440
msgid ""
"Since default values apply to the *destination* rather than to any "
"particular option, and these two options happen to have the same "
"destination, this is exactly equivalent::"
msgstr ""
"Dado que los valores predeterminados se aplican a *destination* en lugar de "
"a cualquier opción en particular y que estas dos opciones tienen el mismo "
"destino, lo anterior es exactamente equivalente a:"

#: ../Doc/library/optparse.rst:447
msgid "Consider this::"
msgstr "Considera lo siguiente::"

#: ../Doc/library/optparse.rst:452
msgid ""
"Again, the default value for ``verbose`` will be ``True``: the last default "
"value supplied for any particular destination is the one that counts."
msgstr ""
"Nuevamente, el valor predeterminado para ``verbose`` será ``True``: el "
"último valor predeterminado proporcionado para cualquier destino en "
"particular es el único que se tendrá en cuenta."

#: ../Doc/library/optparse.rst:455
msgid ""
"A clearer way to specify default values is the :meth:`set_defaults` method "
"of OptionParser, which you can call at any time before calling :meth:"
"`parse_args`::"
msgstr ""
"Una forma más clara de especificar valores predeterminados es el método :"
"meth:`set_defaults` de OptionParser, al que puedes llamar en cualquier "
"momento antes de llamar a :meth:`parse_args`::"

#: ../Doc/library/optparse.rst:462
msgid ""
"As before, the last value specified for a given option destination is the "
"one that counts.  For clarity, try to use one method or the other of setting "
"default values, not both."
msgstr ""
"Como vimos antes, el último valor especificado para un destino de opción "
"dado es el que cuenta. Para mayor claridad, intenta utilizar un método u "
"otro para establecer valores predeterminados, no ambos."

#: ../Doc/library/optparse.rst:470
msgid "Generating help"
msgstr "Generando ayuda"

#: ../Doc/library/optparse.rst:472
msgid ""
":mod:`optparse`'s ability to generate help and usage text automatically is "
"useful for creating user-friendly command-line interfaces.  All you have to "
"do is supply a :attr:`~Option.help` value for each option, and optionally a "
"short usage message for your whole program.  Here's an OptionParser "
"populated with user-friendly (documented) options::"
msgstr ""
"La capacidad de :mod:`optparse` para generar ayuda y texto de uso "
"automáticamente es útil para crear interfaces de línea de comandos fáciles "
"de usar. Todo lo que tienes que hacer es proporcionar un valor :attr:`~ "
"Option.help` para cada opción y, opcionalmente, un breve mensaje de uso para "
"el programa en general. A continuación hay un OptionParser al que se le han "
"añadido múltiples opciones fáciles de usar (documentadas)::"

#: ../Doc/library/optparse.rst:493
msgid ""
"If :mod:`optparse` encounters either ``-h`` or ``--help`` on the command-"
"line, or if you just call :meth:`parser.print_help`, it prints the following "
"to standard output:"
msgstr ""
"Si :mod:`optparse` encuentra ``-h`` o ``--help`` en la línea de comandos, o "
"si simplemente se llama al método :meth:`parser.print_help`, se imprime lo "
"siguiente en la salida estándar:"

#: ../Doc/library/optparse.rst:510
msgid ""
"(If the help output is triggered by a help option, :mod:`optparse` exits "
"after printing the help text.)"
msgstr ""
"(Si la salida de ayuda se activa mediante una opción de ayuda, :mod:"
"`optparse` termina la ejecución después de imprimir el texto de ayuda.)"

#: ../Doc/library/optparse.rst:513
msgid ""
"There's a lot going on here to help :mod:`optparse` generate the best "
"possible help message:"
msgstr ""
"Estamos haciendo muchas cosas aquí con el fin de ayudar a que :mod:"
"`optparse` genere el mejor mensaje de ayuda posible:"

#: ../Doc/library/optparse.rst:516
msgid "the script defines its own usage message::"
msgstr "el script define su propio mensaje de uso::"

#: ../Doc/library/optparse.rst:520
msgid ""
":mod:`optparse` expands ``%prog`` in the usage string to the name of the "
"current program, i.e. ``os.path.basename(sys.argv[0])``.  The expanded "
"string is then printed before the detailed option help."
msgstr ""
":mod:`optparse` expande ``% prog`` en la cadena de uso reemplazándolo por el "
"nombre del programa actual, es decir, ``os.path.basename (sys.argv [0])``. A "
"continuación, la cadena expandida se imprime antes de la ayuda detallada de "
"la opción."

#: ../Doc/library/optparse.rst:524
msgid ""
"If you don't supply a usage string, :mod:`optparse` uses a bland but "
"sensible default: ``\"Usage: %prog [options]\"``, which is fine if your "
"script doesn't take any positional arguments."
msgstr ""
"Si no proporcionas una cadena de uso, :mod:`optparse` usa un valor "
"predeterminado anodino pero apropiado: ``\"Usage: %prog [options]\"``, lo "
"cual está bien si tu script no toma ningún argumento posicional."

#: ../Doc/library/optparse.rst:528
msgid ""
"every option defines a help string, and doesn't worry about line-wrapping---"
"\\ :mod:`optparse` takes care of wrapping lines and making the help output "
"look good."
msgstr ""
"cada opción simplemente define una cadena de ayuda y no se preocupa por el "
"ajuste de línea. :mod:`optparse` se encarga de ajustar las líneas y hacer "
"que la salida de ayuda se vea bien."

#: ../Doc/library/optparse.rst:532
#, fuzzy
msgid ""
"options that take a value indicate this fact in their automatically "
"generated help message, e.g. for the \"mode\" option::"
msgstr ""
"las opciones que toman un valor indican este hecho en su mensaje de ayuda "
"generado automáticamente, por ejemplo, para la opción \"*mode*\"::"

#: ../Doc/library/optparse.rst:537
#, fuzzy
msgid ""
"Here, \"MODE\" is called the meta-variable: it stands for the argument that "
"the user is expected to supply to ``-m``/``--mode``.  By default, :mod:"
"`optparse` converts the destination variable name to uppercase and uses that "
"for the meta-variable.  Sometimes, that's not what you want---for example, "
"the ``--filename`` option explicitly sets ``metavar=\"FILE\"``, resulting in "
"this automatically generated option description::"
msgstr ""
"Aquí, a \"*MODE*\" se le denomina una metavariable: representa el argumento "
"que se espera que el usuario proporcione a ``-m``/``--mode``. De forma "
"predeterminada, :mod:`optparse` convierte el nombre de la variable de "
"destino a mayúsculas y lo usa para la metavariable. En ocasiones, eso no es "
"lo que se desea, por ejemplo, la opción ``--filename`` establece "
"explícitamente ``metavar=\"FILE\"``, lo que da como resultado la siguiente "
"descripción de opción generada automáticamente::"

#: ../Doc/library/optparse.rst:546
msgid ""
"This is important for more than just saving space, though: the manually "
"written help text uses the meta-variable ``FILE`` to clue the user in that "
"there's a connection between the semi-formal syntax ``-f FILE`` and the "
"informal semantic description \"write output to FILE\". This is a simple but "
"effective way to make your help text a lot clearer and more useful for end "
"users."
msgstr ""
"Sin embargo, esto es importante para algo más que para ahorrar espacio: el "
"texto de ayuda escrito manualmente utiliza la metavariable ``FILE`` para "
"indicarle al usuario que hay una conexión entre la sintaxis semiformal ``-f "
"FILE`` y la descripción semántica informal \"escribir la salida en FILE\". "
"Esta es una manera simple pero efectiva de hacer que tu texto de ayuda sea "
"mucho más claro y útil para los usuarios finales."

#: ../Doc/library/optparse.rst:552
#, python-format
msgid ""
"options that have a default value can include ``%default`` in the help "
"string---\\ :mod:`optparse` will replace it with :func:`str` of the option's "
"default value.  If an option has no default value (or the default value is "
"``None``), ``%default`` expands to ``none``."
msgstr ""
"las opciones que tienen un valor predeterminado pueden incluir ``%default`` "
"en la cadena de ayuda, en cuyo caso, :mod:`optparse` lo reemplazará por el "
"resultado de aplicar :func:`str` al valor por defecto de esa opción. Si una "
"opción no tiene un valor por defecto (o el valor por defecto es ``None``), "
"``%default`` se reemplazará por ``none``."

#: ../Doc/library/optparse.rst:558
msgid "Grouping Options"
msgstr "Agrupando opciones"

#: ../Doc/library/optparse.rst:560
msgid ""
"When dealing with many options, it is convenient to group these options for "
"better help output.  An :class:`OptionParser` can contain several option "
"groups, each of which can contain several options."
msgstr ""
"Cuando se trabaja con muchas opciones, suele ser conveniente agruparlas para "
"obtener una mejor salida de ayuda. La clase :class:`OptionParser` puede "
"contener varios grupos de opciones, cada uno de los cuales puede contener "
"múltiples opciones."

#: ../Doc/library/optparse.rst:564
msgid "An option group is obtained using the class :class:`OptionGroup`:"
msgstr ""
"Podemos obtener un grupo de opciones usando la clase :class:`OptionGroup`:"

#: ../Doc/library/optparse.rst:568 ../Doc/library/optparse.rst:1620
msgid "where"
msgstr "donde"

#: ../Doc/library/optparse.rst:570
msgid ""
"parser is the :class:`OptionParser` instance the group will be inserted in to"
msgstr ""
"*parser* es la instancia de :class:`OptionParser` en la que se insertará el "
"grupo"

#: ../Doc/library/optparse.rst:572
msgid "title is the group title"
msgstr "*title* es el título dado al grupo"

#: ../Doc/library/optparse.rst:573
msgid "description, optional, is a long description of the group"
msgstr "*description*, opcional, es la descripción larga del grupo"

#: ../Doc/library/optparse.rst:575
msgid ""
":class:`OptionGroup` inherits from :class:`OptionContainer` (like :class:"
"`OptionParser`) and so the :meth:`add_option` method can be used to add an "
"option to the group."
msgstr ""
"la clase :class:`OptionGroup` hereda de :class:`OptionContainer` (al igual "
"que :class:`OptionParser`), por lo que el método :meth:`add_option` se puede "
"usar para agregar una opción al grupo."

#: ../Doc/library/optparse.rst:579
msgid ""
"Once all the options are declared, using the :class:`OptionParser` method :"
"meth:`add_option_group` the group is added to the previously defined parser."
msgstr ""
"Una vez que se han declarado todas las opciones, usando el método :meth:"
"`add_option_group` de la clase :class:`OptionParser` el grupo se agrega al "
"analizador sintáctico previamente definido."

#: ../Doc/library/optparse.rst:582
msgid ""
"Continuing with the parser defined in the previous section, adding an :class:"
"`OptionGroup` to a parser is easy::"
msgstr ""
"Agregar un :class:`OptionGroup` a un analizador es fácil, continuando con el "
"analizador definido en la sección anterior::"

#: ../Doc/library/optparse.rst:591
msgid "This would result in the following help output:"
msgstr "Esto daría como resultado la siguiente salida de ayuda:"

#: ../Doc/library/optparse.rst:612
msgid ""
"A bit more complete example might involve using more than one group: still "
"extending the previous example::"
msgstr ""
"Un ejemplo un poco más completo podría implicar el uso de más de un grupo, "
"ampliando el ejemplo anterior::"

#: ../Doc/library/optparse.rst:629
msgid "that results in the following output:"
msgstr "lo que da como resultado la siguiente salida:"

#: ../Doc/library/optparse.rst:655
msgid ""
"Another interesting method, in particular when working programmatically with "
"option groups is:"
msgstr ""
"Otro método interesante, particularmente cuando se trabaja programáticamente "
"con grupos de opciones, es:"

#: ../Doc/library/optparse.rst:660
msgid ""
"Return the :class:`OptionGroup` to which the short or long option string "
"*opt_str* (e.g. ``'-o'`` or ``'--option'``) belongs. If there's no such :"
"class:`OptionGroup`, return ``None``."
msgstr ""
"Retorna el :class:`OptionGroup` al que pertenece la cadena de opción corta o "
"larga *opt_str* (por ejemplo, ``'-o'`` o ``' --option'``). Si no existe "
"dicho :class:`OptionGroup`, el método retorna ``None``."

#: ../Doc/library/optparse.rst:667
msgid "Printing a version string"
msgstr "Imprimir una cadena de caracteres con la versión del programa"

#: ../Doc/library/optparse.rst:669
msgid ""
"Similar to the brief usage string, :mod:`optparse` can also print a version "
"string for your program.  You have to supply the string as the ``version`` "
"argument to OptionParser::"
msgstr ""
"De forma similar a lo que ocurre con la cadena de uso abreviada, :mod:"
"`optparse` también puede imprimir una cadena de versión para tu programa. "
"Debes proporcionar la cadena mediante el argumento ``version`` de "
"OptionParser::"

#: ../Doc/library/optparse.rst:675
msgid ""
"``%prog`` is expanded just like it is in ``usage``.  Apart from that, "
"``version`` can contain anything you like.  When you supply it, :mod:"
"`optparse` automatically adds a ``--version`` option to your parser. If it "
"encounters this option on the command line, it expands your ``version`` "
"string (by replacing ``%prog``), prints it to stdout, and exits."
msgstr ""
"``%prog`` se expande al igual que en ``usage``. Aparte de eso, ``version`` "
"puede contener cualquier cosa que desees. Cuando se proporciona, :mod:"
"`optparse` agrega automáticamente una opción ``--version`` al analizador. Si "
"encuentra esta opción en la línea de comandos, expande la cadena ``version`` "
"(reemplazando ``%prog``), la imprime en la salida estándar y termina la "
"ejecución."

#: ../Doc/library/optparse.rst:681
msgid "For example, if your script is called ``/usr/bin/foo``:"
msgstr "Por ejemplo, si tu script se llama ``/usr/bin/foo``:"

#: ../Doc/library/optparse.rst:688
msgid ""
"The following two methods can be used to print and get the ``version`` "
"string:"
msgstr ""
"Para imprimir y obtener la cadena de caracteres ``version``, se pueden "
"utilizar cualquiera de los siguientes métodos:"

#: ../Doc/library/optparse.rst:692
msgid ""
"Print the version message for the current program (``self.version``) to "
"*file* (default stdout).  As with :meth:`print_usage`, any occurrence of "
"``%prog`` in ``self.version`` is replaced with the name of the current "
"program.  Does nothing if ``self.version`` is empty or undefined."
msgstr ""
"Imprime el mensaje con la versión del programa actual (``self.version``) en "
"*file* (por defecto, la salida estándar). Al igual que con :meth:"
"`print_usage`, cualquier aparición de ``%prog`` en ``self.version`` se "
"reemplaza con el nombre del programa actual. El método no hace nada si "
"``self.version`` está vacío o no está definido."

#: ../Doc/library/optparse.rst:699
msgid ""
"Same as :meth:`print_version` but returns the version string instead of "
"printing it."
msgstr ""
"Igual que :meth:`print_version`, pero retorna la cadena de versión en lugar "
"de imprimirla."

#: ../Doc/library/optparse.rst:706
msgid "How :mod:`optparse` handles errors"
msgstr "Cómo maneja los errores el módulo :mod:`optparse`"

#: ../Doc/library/optparse.rst:708
msgid ""
"There are two broad classes of errors that :mod:`optparse` has to worry "
"about: programmer errors and user errors.  Programmer errors are usually "
"erroneous calls to :func:`OptionParser.add_option`, e.g. invalid option "
"strings, unknown option attributes, missing option attributes, etc.  These "
"are dealt with in the usual way: raise an exception (either :exc:`optparse."
"OptionError` or :exc:`TypeError`) and let the program crash."
msgstr ""
"A grandes rasgos, hay dos clases de errores de los que :mod:`optparse` tiene "
"que preocuparse: errores del programador y errores del usuario. Los errores "
"del programador suelen ser el resultado de llamadas erróneas a :func:"
"`OptionParser.add_option`, como cadenas de opción no válidas, atributos de "
"opción desconocidos, atributos de opción que faltan, etc. Se tratan de la "
"forma habitual: generan una excepción (ya sea :exc:`optparse.OptionError` o :"
"exc:`TypeError`) y hacen que el programa se bloquee."

#: ../Doc/library/optparse.rst:715
msgid ""
"Handling user errors is much more important, since they are guaranteed to "
"happen no matter how stable your code is.  :mod:`optparse` can automatically "
"detect some user errors, such as bad option arguments (passing ``-n 4x`` "
"where ``-n`` takes an integer argument), missing arguments (``-n`` at the "
"end of the command line, where ``-n`` takes an argument of any type).  Also, "
"you can call :func:`OptionParser.error` to signal an application-defined "
"error condition::"
msgstr ""
"Manejar los errores del usuario es mucho más importante, ya que está "
"garantizado que sucederán sin importar cuán estable sea el código. :mod:"
"`optparse` puede detectar automáticamente algunos errores del usuario, como "
"argumentos de opción incorrectos (pasar ``-n 4x`` donde ``-n`` toma un "
"argumento entero) o la falta de argumentos (``-n`` al final de la línea de "
"comandos, donde ``-n`` toma un argumento de cualquier tipo). Además de esto, "
"puedes llamar a :func:`OptionParser.error` para establecer una condición de "
"error definida por la propia aplicación::"

#: ../Doc/library/optparse.rst:728
msgid ""
"In either case, :mod:`optparse` handles the error the same way: it prints "
"the program's usage message and an error message to standard error and exits "
"with error status 2."
msgstr ""
"En cualquier caso, :mod:`optparse` maneja el error de la misma manera: "
"imprime el mensaje de uso del programa junto a un mensaje de error en la "
"salida de errores estándar y termina la ejecución con el estado de error 2."

#: ../Doc/library/optparse.rst:732
msgid ""
"Consider the first example above, where the user passes ``4x`` to an option "
"that takes an integer:"
msgstr ""
"Considera el primero de los dos ejemplos anteriores, donde el usuario pasa "
"``4x`` a una opción que toma un número entero:"

#: ../Doc/library/optparse.rst:742
msgid "Or, where the user fails to pass a value at all:"
msgstr ""
"O, en el caso en el que el usuario definitivamente no pase ningún valor:"

#: ../Doc/library/optparse.rst:751
msgid ""
":mod:`optparse`\\ -generated error messages take care always to mention the "
"option involved in the error; be sure to do the same when calling :func:"
"`OptionParser.error` from your application code."
msgstr ""
"Los mensajes de error generados por :mod:`optparse` tienen siempre cuidado "
"de mencionar la opción involucrada en el error. Asegúrate de hacer lo mismo "
"cuando llames a :func:`OptionParser.error` desde el código de tu aplicación."

#: ../Doc/library/optparse.rst:755
msgid ""
"If :mod:`optparse`'s default error-handling behaviour does not suit your "
"needs, you'll need to subclass OptionParser and override its :meth:"
"`~OptionParser.exit` and/or :meth:`~OptionParser.error` methods."
msgstr ""
"Si el comportamiento del manejo de errores predeterminado de :mod:`optparse` "
"no se adapta a tus necesidades, deberás subclasificar OptionParser y "
"redefinir su método :meth:`~OptionParser.exit` y/o :meth:`~OptionParser."
"error`."

#: ../Doc/library/optparse.rst:763
msgid "Putting it all together"
msgstr "Reuniendo todas las piezas"

#: ../Doc/library/optparse.rst:765
msgid "Here's what :mod:`optparse`\\ -based scripts usually look like::"
msgstr "Así es como los scripts basados en :mod:`optparse` usualmente se ven:"

#: ../Doc/library/optparse.rst:793
msgid "Reference Guide"
msgstr "Guía de referencia"

#: ../Doc/library/optparse.rst:799
msgid "Creating the parser"
msgstr "Creando el analizador sintáctico (parser)"

#: ../Doc/library/optparse.rst:801
msgid ""
"The first step in using :mod:`optparse` is to create an OptionParser "
"instance."
msgstr ""
"El primer paso para poder usar :mod:`optparse` es crear una instancia de "
"OptionParser."

#: ../Doc/library/optparse.rst:805
msgid ""
"The OptionParser constructor has no required arguments, but a number of "
"optional keyword arguments.  You should always pass them as keyword "
"arguments, i.e. do not rely on the order in which the arguments are declared."
msgstr ""
"El constructor de la clase OptionParser no tiene argumentos obligatorios, "
"pero sí varios argumentos opcionales por palabra clave. Siempre deben "
"pasarse como argumentos por palabras clave, es decir, no se debe confiar "
"nunca en el orden en que se declaran los argumentos."

#: ../Doc/library/optparse.rst:814
msgid "``usage`` (default: ``\"%prog [options]\"``)"
msgstr "``usage`` (por defecto: ``\"%prog [options]\"``)"

#: ../Doc/library/optparse.rst:810
msgid ""
"The usage summary to print when your program is run incorrectly or with a "
"help option.  When :mod:`optparse` prints the usage string, it expands "
"``%prog`` to ``os.path.basename(sys.argv[0])`` (or to ``prog`` if you passed "
"that keyword argument).  To suppress a usage message, pass the special "
"value :data:`optparse.SUPPRESS_USAGE`."
msgstr ""
"El resumen de uso a imprimir cuando el programa se ejecuta incorrectamente o "
"con una opción de ayuda. Cuando :mod:`optparse` imprime la cadena de uso, "
"reemplaza ``%prog`` con ``os.path.basename(sys.argv[0])`` (o con ``prog`` si "
"se proporcionó eso argumento por palabra clave). Para suprimir un mensaje de "
"uso, se debe pasar el valor especial :data:`optparse.SUPPRESS_USAGE`."

#: ../Doc/library/optparse.rst:821
msgid "``option_list`` (default: ``[]``)"
msgstr "``option_list`` (por defecto: ``[]``)"

#: ../Doc/library/optparse.rst:817
msgid ""
"A list of Option objects to populate the parser with.  The options in "
"``option_list`` are added after any options in ``standard_option_list`` (a "
"class attribute that may be set by OptionParser subclasses), but before any "
"version or help options. Deprecated; use :meth:`add_option` after creating "
"the parser instead."
msgstr ""
"Una lista de objetos Option con los que poblar el analizador. Las opciones "
"en ``option_list`` se agregan después de cualquier opción en "
"``standard_option_list`` (un atributo de clase que puede ser establecido por "
"las subclases de OptionParser), pero antes de cualquier versión u opción de "
"ayuda. Obsoleto: usar en su lugar el método :meth:`add_option`, una vez "
"creado el analizador."

#: ../Doc/library/optparse.rst:824
msgid "``option_class`` (default: optparse.Option)"
msgstr "``option_class`` (por defecto: *optparse.Option*)"

#: ../Doc/library/optparse.rst:824
msgid "Class to use when adding options to the parser in :meth:`add_option`."
msgstr ""
"Clase usada por el método :meth:`add_option` para añadir opciones al "
"analizador."

#: ../Doc/library/optparse.rst:830
msgid "``version`` (default: ``None``)"
msgstr "``version`` (por defecto: ``None``)"

#: ../Doc/library/optparse.rst:827
msgid ""
"A version string to print when the user supplies a version option. If you "
"supply a true value for ``version``, :mod:`optparse` automatically adds a "
"version option with the single option string ``--version``.  The substring "
"``%prog`` is expanded the same as for ``usage``."
msgstr ""
"Una cadena de caracteres con la versión del programa a imprimir cuando el "
"usuario proporciona una opción de versión. Si se proporciona un valor "
"verdadero para ``version``, :mod:`optparse` agrega automáticamente una "
"opción de versión con ``--version`` como única cadena de opción. La "
"subcadena ``%prog`` se expande de la misma manera que en ``usage``."

#: ../Doc/library/optparse.rst:835
msgid "``conflict_handler`` (default: ``\"error\"``)"
msgstr "``conflict_handler`` (por defecto: ``\"error\"``)"

#: ../Doc/library/optparse.rst:833
msgid ""
"Specifies what to do when options with conflicting option strings are added "
"to the parser; see section :ref:`optparse-conflicts-between-options`."
msgstr ""
"Especifica qué hacer cuando se agregan al analizador opciones con cadenas de "
"opción en conflicto entre si. Ver sección :ref:`optparse-conflicts-between-"
"options`."

#: ../Doc/library/optparse.rst:841
msgid "``description`` (default: ``None``)"
msgstr "``description`` (por defecto: ``None``)"

#: ../Doc/library/optparse.rst:838
msgid ""
"A paragraph of text giving a brief overview of your program. :mod:`optparse` "
"reformats this paragraph to fit the current terminal width and prints it "
"when the user requests help (after ``usage``, but before the list of "
"options)."
msgstr ""
"Un párrafo de texto que ofrece una breve descripción del programa. :mod:"
"`optparse` reformatea este párrafo para que se ajuste al ancho actual de la "
"terminal y lo imprime cuando el usuario solicita ayuda (después de "
"``usage``, pero antes de la lista de opciones)."

#: ../Doc/library/optparse.rst:846
msgid "``formatter`` (default: a new :class:`IndentedHelpFormatter`)"
msgstr ""
"``formatter`` (por defecto: una nueva instancia de la clase :class:"
"`IndentedHelpFormatter`)"

#: ../Doc/library/optparse.rst:844
msgid ""
"An instance of optparse.HelpFormatter that will be used for printing help "
"text.  :mod:`optparse` provides two concrete classes for this purpose: "
"IndentedHelpFormatter and TitledHelpFormatter."
msgstr ""
"Una instancia de la clase optparse.HelpFormatter que será usada para "
"imprimir el texto de ayuda. El módulo :mod:`optparse` proporciona dos clases "
"concretas para este propósito: IndentedHelpFormatter y TitledHelpFormatter."

#: ../Doc/library/optparse.rst:850
msgid "``add_help_option`` (default: ``True``)"
msgstr "``add_help_option`` (por defecto: ``True``)"

#: ../Doc/library/optparse.rst:849
msgid ""
"If true, :mod:`optparse` will add a help option (with option strings ``-h`` "
"and ``--help``) to the parser."
msgstr ""
"Si es verdadero, :mod:`optparse` agregará al analizador una opción de ayuda "
"(con las cadenas de opción ``-h`` y ``--help``)."

#: ../Doc/library/optparse.rst:854
msgid "``prog``"
msgstr "``prog``"

#: ../Doc/library/optparse.rst:853
msgid ""
"The string to use when expanding ``%prog`` in ``usage`` and ``version`` "
"instead of ``os.path.basename(sys.argv[0])``."
msgstr ""
"La cadena de caracteres a usar como substituta de ``os.path.basename(sys."
"argv[0])`` cuando se expanda ``%prog`` en ``usage`` y en ``version``."

#: ../Doc/library/optparse.rst:856
msgid "``epilog`` (default: ``None``)"
msgstr "``epilog`` (por defecto: ``None``)"

#: ../Doc/library/optparse.rst:857
msgid "A paragraph of help text to print after the option help."
msgstr ""
"Un párrafo con texto de ayuda que se imprimirá después de la opción de ayuda."

#: ../Doc/library/optparse.rst:862
msgid "Populating the parser"
msgstr "Completando el analizador con opciones"

#: ../Doc/library/optparse.rst:864
msgid ""
"There are several ways to populate the parser with options.  The preferred "
"way is by using :meth:`OptionParser.add_option`, as shown in section :ref:"
"`optparse-tutorial`.  :meth:`add_option` can be called in one of two ways:"
msgstr ""
"Hay varias formas de agregar las opciones al analizador. La forma preferida "
"es mediante el método :meth:`OptionParser.add_option`, tal como se muestra "
"en la sección del :ref:`optparse-tutorial`. El método :meth:`add_option` se "
"puede llamar de dos formas diferentes:"

#: ../Doc/library/optparse.rst:868
msgid "pass it an Option instance (as returned by :func:`make_option`)"
msgstr ""
"pasándole una instancia de Option (como la que retorna :func:`make_option`)"

#: ../Doc/library/optparse.rst:870
msgid ""
"pass it any combination of positional and keyword arguments that are "
"acceptable to :func:`make_option` (i.e., to the Option constructor), and it "
"will create the Option instance for you"
msgstr ""
"pasándole cualquier combinación de argumentos posicionales y por palabra "
"clave que sean aceptables para :func:`make_option` (es decir, para el "
"constructor de la clase Option), lo que creará la instancia Option "
"automáticamente"

#: ../Doc/library/optparse.rst:874
msgid ""
"The other alternative is to pass a list of pre-constructed Option instances "
"to the OptionParser constructor, as in::"
msgstr ""
"La otra alternativa es pasar una lista de instancias de Option previamente "
"construidas al constructor OptionParser, como en el siguiente ejemplo::"

#: ../Doc/library/optparse.rst:885
msgid ""
"(:func:`make_option` is a factory function for creating Option instances; "
"currently it is an alias for the Option constructor.  A future version of :"
"mod:`optparse` may split Option into several classes, and :func:"
"`make_option` will pick the right class to instantiate.  Do not instantiate "
"Option directly.)"
msgstr ""
"(:func:`make_option` es una función fábrica para crear instancias Option. "
"Actualmente es simplemente un alias para el constructor Option, pero es "
"posible que una futura versión de :mod:`optparse` pueda dividir Option en "
"varias clases, en cuyo caso, :func:`make_option` elegirá la clase correcta a "
"instanciar. Esta es la razón por la que no se debe instanciar Option "
"directamente.)"

#: ../Doc/library/optparse.rst:894
msgid "Defining options"
msgstr "Definiendo las opciones"

#: ../Doc/library/optparse.rst:896
msgid ""
"Each Option instance represents a set of synonymous command-line option "
"strings, e.g. ``-f`` and ``--file``.  You can specify any number of short or "
"long option strings, but you must specify at least one overall option string."
msgstr ""
"Cada instancia de Option representa un conjunto de cadenas de opción "
"sinónimas para la línea de comandos, por ejemplo ``-f`` y ``--file``. Se "
"puede especificar cualquier número de cadenas de opción cortas o largas, "
"pero se debe proporcionar al menos una cadena de opción en total."

#: ../Doc/library/optparse.rst:900
msgid ""
"The canonical way to create an :class:`Option` instance is with the :meth:"
"`add_option` method of :class:`OptionParser`."
msgstr ""
"La forma canónica de crear una instancia de :class:`Option` es mediante el "
"método :meth:`add_option` de la clase :class:`OptionParser`."

#: ../Doc/library/optparse.rst:906
msgid "To define an option with only a short option string::"
msgstr "Para definir una opción con solo una cadena de opción corta::"

#: ../Doc/library/optparse.rst:910
msgid "And to define an option with only a long option string::"
msgstr "Y para definir una opción con solo una cadena de opción larga::"

#: ../Doc/library/optparse.rst:914
msgid ""
"The keyword arguments define attributes of the new Option object.  The most "
"important option attribute is :attr:`~Option.action`, and it largely "
"determines which other attributes are relevant or required.  If you pass "
"irrelevant option attributes, or fail to pass required ones, :mod:`optparse` "
"raises an :exc:`OptionError` exception explaining your mistake."
msgstr ""
"Los argumentos por palabra clave definen atributos para el nuevo objeto "
"Option. El atributo de opción más importante es :attr:`~Option.action`, que "
"determina en gran medida qué otros atributos son apropiados u obligatorios. "
"Si se pasan atributos de opción no apropiados, o no se pasan los "
"requeridos, :mod:`optparse` lanza una excepción :exc:`OptionError` "
"explicando el error."

#: ../Doc/library/optparse.rst:920
msgid ""
"An option's *action* determines what :mod:`optparse` does when it encounters "
"this option on the command-line.  The standard option actions hard-coded "
"into :mod:`optparse` are:"
msgstr ""
"La acción (*action*) de una opción determina que hace el módulo :mod:"
"`optparse` cuando encuentra dicha opción en la línea de comandos. Las "
"acciones de opción estándares codificadas en :mod:`optparse` son:"

#: ../Doc/library/optparse.rst:925
msgid "``\"store\"``"
msgstr "``\"store\"``"

#: ../Doc/library/optparse.rst:925
msgid "store this option's argument (default)"
msgstr "almacena el argumento de esta opción (por defecto)"

#: ../Doc/library/optparse.rst:931
msgid "``\"store_true\"``"
msgstr "``\"store_true\"``"

#: ../Doc/library/optparse.rst:931
msgid "store ``True``"
msgstr "almacena ``True``"

#: ../Doc/library/optparse.rst:934
msgid "``\"store_false\"``"
msgstr "``\"store_false\"``"

#: ../Doc/library/optparse.rst:934
msgid "store ``False``"
msgstr "almacena ``False``"

#: ../Doc/library/optparse.rst:940
msgid "``\"append_const\"``"
msgstr "``\"append_const\"``"

#: ../Doc/library/optparse.rst:940
msgid "append a constant value to a list"
msgstr "agrega un valor constante a una lista"

#: ../Doc/library/optparse.rst:949 ../Doc/library/optparse.rst:1226
msgid "``\"help\"``"
msgstr "``\"help\"``"

#: ../Doc/library/optparse.rst:949
msgid ""
"print a usage message including all options and the documentation for them"
msgstr ""
"imprime un mensaje de uso que incluye todas las opciones y la documentación "
"correspondiente"

#: ../Doc/library/optparse.rst:951
msgid ""
"(If you don't supply an action, the default is ``\"store\"``.  For this "
"action, you may also supply :attr:`~Option.type` and :attr:`~Option.dest` "
"option attributes; see :ref:`optparse-standard-option-actions`.)"
msgstr ""
"(Si no se proporciona una acción, el valor predeterminado es ``\"store\"``. "
"Para esta acción en concreto, también se pueden proporcionar los atributos "
"de opción :attr:`~Option.type` y :attr:`~Option.dest`. Consultar :ref:"
"`optparse-standard-option-actions` para más información.)"

#: ../Doc/library/optparse.rst:955
msgid ""
"As you can see, most actions involve storing or updating a value somewhere. :"
"mod:`optparse` always creates a special object for this, conventionally "
"called ``options`` (it happens to be an instance of :class:`optparse."
"Values`).  Option arguments (and various other values) are stored as "
"attributes of this object, according to the :attr:`~Option.dest` "
"(destination) option attribute."
msgstr ""
"Como se puede observar, la mayoría de las acciones implican almacenar o "
"actualizar un valor en algún lugar. :mod:`optparse` siempre crea un objeto "
"especial para esto, convencionalmente llamado ``options`` (que resulta ser "
"una instancia de :class:`optparse.Values`). Los argumentos de opción (y "
"algunos otros valores) se almacenan como atributos de este objeto, de "
"acuerdo con el atributo de opción :attr:`~ Option.dest` (destino) "
"establecido."

#: ../Doc/library/optparse.rst:961
msgid "For example, when you call ::"
msgstr "Por ejemplo, cuando se llama a::"

#: ../Doc/library/optparse.rst:965
msgid ""
"one of the first things :mod:`optparse` does is create the ``options`` "
"object::"
msgstr ""
"una de las primeras cosas que hace el módulo :mod:`optparse` es crear el "
"objeto ``options``::"

#: ../Doc/library/optparse.rst:969
msgid "If one of the options in this parser is defined with ::"
msgstr "Si una de las opciones de este analizador es definida con::"

#: ../Doc/library/optparse.rst:973
msgid "and the command-line being parsed includes any of the following::"
msgstr ""
"y la línea de comandos que se analiza incluye cualquiera de las siguientes "
"variantes::"

#: ../Doc/library/optparse.rst:980
msgid ""
"then :mod:`optparse`, on seeing this option, will do the equivalent of ::"
msgstr ""
"entonces el módulo :mod:`optparse`, al encontrar esta opción, hará algo "
"equivalente a::"

#: ../Doc/library/optparse.rst:984
msgid ""
"The :attr:`~Option.type` and :attr:`~Option.dest` option attributes are "
"almost as important as :attr:`~Option.action`, but :attr:`~Option.action` is "
"the only one that makes sense for *all* options."
msgstr ""
"Los atributos de opción :attr:`~Option.type` y :attr:`~Option.dest` son casi "
"tan importantes como :attr:`~Option.action`, pero :attr:`~Option.action` es "
"el único de ellos que es apropiado para *todas* las opciones."

#: ../Doc/library/optparse.rst:992
msgid "Option attributes"
msgstr "Atributos de opción"

#: ../Doc/library/optparse.rst:994
msgid ""
"The following option attributes may be passed as keyword arguments to :meth:"
"`OptionParser.add_option`.  If you pass an option attribute that is not "
"relevant to a particular option, or fail to pass a required option "
"attribute, :mod:`optparse` raises :exc:`OptionError`."
msgstr ""
"Los siguientes atributos de opción pueden pasarse como argumentos por "
"palabra clave al método :meth:`OptionParser.add_option`. Si se pasa un "
"atributo de opción que no es apropiado para una opción en particular, o no "
"se pasa un atributo de opción obligatorio, :mod:`optparse` lanza una "
"excepción :exc:`OptionError`."

#: ../Doc/library/optparse.rst:1001
msgid "(default: ``\"store\"``)"
msgstr "(por defecto: ``\"store\"``)"

#: ../Doc/library/optparse.rst:1003
msgid ""
"Determines :mod:`optparse`'s behaviour when this option is seen on the "
"command line; the available options are documented :ref:`here <optparse-"
"standard-option-actions>`."
msgstr ""
"Determina el comportamiento del módulo :mod:`optparse` cuando esta opción se "
"encuentra en la línea de comandos. Las opciones disponibles están "
"documentadas :ref:`aquí <optparse-standard-option-actions>`."

#: ../Doc/library/optparse.rst:1009
msgid "(default: ``\"string\"``)"
msgstr "(por defecto: ``\"string\"``)"

#: ../Doc/library/optparse.rst:1011
msgid ""
"The argument type expected by this option (e.g., ``\"string\"`` or "
"``\"int\"``); the available option types are documented :ref:`here <optparse-"
"standard-option-types>`."
msgstr ""
"El tipo de argumento esperado para esta opción (por ejemplo, ``\"string\"`` "
"o ``\"int\"``). Los tipos de opción disponibles están documentados :ref:"
"`aquí <optparse-standard-option-types>`."

#: ../Doc/library/optparse.rst:1017 ../Doc/library/optparse.rst:1067
msgid "(default: derived from option strings)"
msgstr "(por defecto: derivado de las cadenas de opción)"

#: ../Doc/library/optparse.rst:1019
msgid ""
"If the option's action implies writing or modifying a value somewhere, this "
"tells :mod:`optparse` where to write it: :attr:`~Option.dest` names an "
"attribute of the ``options`` object that :mod:`optparse` builds as it parses "
"the command line."
msgstr ""
"Si la acción asociada a la opción implica escribir o modificar un valor en "
"algún lugar, este atributo le dice a :mod:`optparse` dónde escribirlo: :attr:"
"`~Option.dest` es el nombre de un atributo del objeto ``options`` que :mod:"
"`optparse` construye a medida que analiza la línea de comandos."

#: ../Doc/library/optparse.rst:1026
msgid ""
"The value to use for this option's destination if the option is not seen on "
"the command line.  See also :meth:`OptionParser.set_defaults`."
msgstr ""
"El valor que se utilizará como destino de esta opción si la opción no "
"aparece en la línea de comandos. Ver también :meth:`OptionParser."
"set_defaults`."

#: ../Doc/library/optparse.rst:1031
msgid "(default: 1)"
msgstr "(por defecto: 1)"

#: ../Doc/library/optparse.rst:1033
msgid ""
"How many arguments of type :attr:`~Option.type` should be consumed when this "
"option is seen.  If > 1, :mod:`optparse` will store a tuple of values to :"
"attr:`~Option.dest`."
msgstr ""
"Cuántos argumentos de tipo :attr:`~Option.type` deben consumirse cuando se "
"encuentre esta opción. Si es mayor a 1, :mod:`optparse` almacenará una tupla "
"con los valores de los argumentos en :attr:`~Option.dest`."

#: ../Doc/library/optparse.rst:1039
msgid "For actions that store a constant value, the constant value to store."
msgstr ""
"Para acciones que almacenan un valor constante, el valor constante a "
"almacenar."

#: ../Doc/library/optparse.rst:1043
msgid ""
"For options of type ``\"choice\"``, the list of strings the user may choose "
"from."
msgstr ""
"Para opciones de tipo ``\"choice\"``, la lista con las cadenas que el "
"usuario puede elegir."

#: ../Doc/library/optparse.rst:1048
msgid ""
"For options with action ``\"callback\"``, the callable to call when this "
"option is seen.  See section :ref:`optparse-option-callbacks` for detail on "
"the arguments passed to the callable."
msgstr ""
"Para las opciones con la acción ``\"callback\"`` asignada, el objeto "
"invocable a llamar cuando se encuentra esta opción. Consultar la sección :"
"ref:`optparse-option-callbacks` para obtener más detalles sobre los "
"argumentos que son pasados al objeto invocable."

#: ../Doc/library/optparse.rst:1055
msgid ""
"Additional positional and keyword arguments to pass to ``callback`` after "
"the four standard callback arguments."
msgstr ""
"Argumentos posicionales y por palabra clave adicionales para ser pasados a "
"``callback`` después de los cuatro argumentos pasados a la retrollamada "
"estándar."

#: ../Doc/library/optparse.rst:1060
msgid ""
"Help text to print for this option when listing all available options after "
"the user supplies a :attr:`~Option.help` option (such as ``--help``).  If no "
"help text is supplied, the option will be listed without help text.  To hide "
"this option, use the special value :data:`optparse.SUPPRESS_HELP`."
msgstr ""
"Texto de ayuda a imprimir para esta opción cuando se enumeran todas las "
"opciones disponibles, después de que el usuario proporcione una opción :attr:"
"`~Option.help` (como ``--help``). Si no se proporciona ningún texto de "
"ayuda, la opción seguirá apareciendo, solo que sin texto de ayuda. Para "
"ocultar esta opción completamente, se debe asignar al atributo el valor "
"especial :data:`optparse.SUPPRESS_HELP`."

#: ../Doc/library/optparse.rst:1069
msgid ""
"Stand-in for the option argument(s) to use when printing help text.  See "
"section :ref:`optparse-tutorial` for an example."
msgstr ""
"Reemplazo para los argumentos de opción que se utilizará al imprimir el "
"texto de ayuda. Consultar la sección :ref:`optparse-tutorial` para ver un "
"ejemplo."

#: ../Doc/library/optparse.rst:1076
msgid "Standard option actions"
msgstr "Acciones de opción estándares"

#: ../Doc/library/optparse.rst:1078
msgid ""
"The various option actions all have slightly different requirements and "
"effects. Most actions have several relevant option attributes which you may "
"specify to guide :mod:`optparse`'s behaviour; a few have required "
"attributes, which you must specify for any option using that action."
msgstr ""
"Las diversas acciones de opción tienen requisitos y efectos ligeramente "
"diferentes. La mayoría de las acciones tienen varios atributos de opción "
"relacionados que puedes especificar para dirigir el comportamiento del "
"módulo :mod:`optparse`. Además, algunas de ellas tienen atributos "
"requeridos, que se deben especificar para cualquier opción que utilice esa "
"acción."

#: ../Doc/library/optparse.rst:1083
msgid ""
"``\"store\"`` [relevant: :attr:`~Option.type`, :attr:`~Option.dest`, :attr:"
"`~Option.nargs`, :attr:`~Option.choices`]"
msgstr ""
"``\"store\"`` [atributos relacionados: :attr:`~Option.type`, :attr:`~Option."
"dest`, :attr:`~Option.nargs`, :attr:`~Option.choices`]"

#: ../Doc/library/optparse.rst:1086
msgid ""
"The option must be followed by an argument, which is converted to a value "
"according to :attr:`~Option.type` and stored in :attr:`~Option.dest`.  If :"
"attr:`~Option.nargs` > 1, multiple arguments will be consumed from the "
"command line; all will be converted according to :attr:`~Option.type` and "
"stored to :attr:`~Option.dest` as a tuple.  See the :ref:`optparse-standard-"
"option-types` section."
msgstr ""
"La opción debe ir seguida de un argumento, que se convierte en un valor de "
"acuerdo a :attr:`~Option.type` y se almacena en :attr:`~Option.dest`. Si :"
"attr:`~Option.nargs` es mayor que 1, se consumirán varios argumentos de la "
"línea de comandos. Todos ellos se convertirán de acuerdo a :attr:`~Option."
"type` y se almacenarán en :attr:`~Option.dest` como una tupla. Consultar la "
"sección :ref:`optparse-standard-option-types` para más información."

#: ../Doc/library/optparse.rst:1093
msgid ""
"If :attr:`~Option.choices` is supplied (a list or tuple of strings), the "
"type defaults to ``\"choice\"``."
msgstr ""
"Si se proporciona :attr:`~Option.choices` (una lista o tupla de cadenas de "
"caracteres), el tipo por defecto es ``\"choice\"``."

#: ../Doc/library/optparse.rst:1096
msgid "If :attr:`~Option.type` is not supplied, it defaults to ``\"string\"``."
msgstr ""
"Si no se proporciona :attr:`~Option.type`, el tipo por defecto es "
"``\"string\"``."

#: ../Doc/library/optparse.rst:1098
msgid ""
"If :attr:`~Option.dest` is not supplied, :mod:`optparse` derives a "
"destination from the first long option string (e.g., ``--foo-bar`` implies "
"``foo_bar``). If there are no long option strings, :mod:`optparse` derives a "
"destination from the first short option string (e.g., ``-f`` implies ``f``)."
msgstr ""
"Si :attr:`~Option.dest` no se proporciona, :mod:`optparse` infiere un "
"destino de la primera cadena de opción larga (por ejemplo, ``--foo-bar`` "
"implica que se usará ``foo_bar`` como destino). Si no hay cadenas de opción "
"largas, :mod:`optparse` obtiene el destino a partir de la primera cadena de "
"opción corta (por ejemplo, ``-f`` conlleva que se usará ``f``)."

#: ../Doc/library/optparse.rst:1103 ../Doc/library/optparse.rst:1123
#: ../Doc/library/optparse.rst:1145 ../Doc/library/optparse.rst:1163
#: ../Doc/library/optparse.rst:1202 ../Doc/library/optparse.rst:1240
msgid "Example::"
msgstr "Ejemplo::"

#: ../Doc/library/optparse.rst:1108
msgid "As it parses the command line ::"
msgstr "Mientras analiza la línea de comandos::"

#: ../Doc/library/optparse.rst:1112
msgid ":mod:`optparse` will set ::"
msgstr ":mod:`optparse` establecerá::"

#: ../Doc/library/optparse.rst:1118
msgid ""
"``\"store_const\"`` [required: :attr:`~Option.const`; relevant: :attr:"
"`~Option.dest`]"
msgstr ""
"``\"store_const\"`` [atributo requerido: :attr:`~Option.const`; atributo "
"relacionado: :attr:`~Option.dest`]"

#: ../Doc/library/optparse.rst:1121
msgid "The value :attr:`~Option.const` is stored in :attr:`~Option.dest`."
msgstr "El valor :attr:`~Option.const` es almacenado en :attr:`~Option.dest`."

#: ../Doc/library/optparse.rst:1132
msgid "If ``--noisy`` is seen, :mod:`optparse` will set  ::"
msgstr "Si se encuentra ``--noisy``, :mod:`optparse` establecerá::"

#: ../Doc/library/optparse.rst:1136
msgid "``\"store_true\"`` [relevant: :attr:`~Option.dest`]"
msgstr "``\"store_true\"`` [atributo relacionado: :attr:`~Option.dest`]"

#: ../Doc/library/optparse.rst:1138
msgid ""
"A special case of ``\"store_const\"`` that stores ``True`` to :attr:`~Option."
"dest`."
msgstr ""
"Un caso especial de ``\"store_const\"`` que almacena ``True`` en :attr:"
"`~Option.dest`."

#: ../Doc/library/optparse.rst:1141
msgid "``\"store_false\"`` [relevant: :attr:`~Option.dest`]"
msgstr "``\"store_false\"`` [atributo relacionado: :attr:`~Option.dest`]"

#: ../Doc/library/optparse.rst:1143
msgid "Like ``\"store_true\"``, but stores ``False``."
msgstr "Como ``\"store_true\"``, pero almacena ``False``."

#: ../Doc/library/optparse.rst:1150
msgid ""
"``\"append\"`` [relevant: :attr:`~Option.type`, :attr:`~Option.dest`, :attr:"
"`~Option.nargs`, :attr:`~Option.choices`]"
msgstr ""
"``\"append\"`` [atributos relacionados: :attr:`~Option.type`, :attr:`~Option."
"dest`, :attr:`~Option.nargs`, :attr:`~Option.choices`]"

#: ../Doc/library/optparse.rst:1153
msgid ""
"The option must be followed by an argument, which is appended to the list "
"in :attr:`~Option.dest`.  If no default value for :attr:`~Option.dest` is "
"supplied, an empty list is automatically created when :mod:`optparse` first "
"encounters this option on the command-line.  If :attr:`~Option.nargs` > 1, "
"multiple arguments are consumed, and a tuple of length :attr:`~Option.nargs` "
"is appended to :attr:`~Option.dest`."
msgstr ""
"La opción debe ir seguida de un argumento, que se añade a la lista de :attr:"
"`~Option.dest`. Si no se proporciona un valor predeterminado para :attr:"
"`~Option.dest`, se crea automáticamente una lista vacía cuando :mod:"
"`optparse` encuentra por primera vez esta opción en la línea de comandos. "
"Si :attr:`~Option.nargs` es mayor que 1, se consumen varios argumentos y se "
"agrega una tupla de longitud :attr:`~Option.nargs` a :attr:`~Option.dest`."

#: ../Doc/library/optparse.rst:1160
msgid ""
"The defaults for :attr:`~Option.type` and :attr:`~Option.dest` are the same "
"as for the ``\"store\"`` action."
msgstr ""
"Los valores por defecto para los atributos :attr:`~Option.type` y :attr:"
"`~Option.dest` son los mismos que para la acción ``\"store\"``."

#: ../Doc/library/optparse.rst:1167
msgid ""
"If ``-t3`` is seen on the command-line, :mod:`optparse` does the equivalent "
"of::"
msgstr ""
"Si se encuentra ``-t3`` en la línea de comandos, :mod:`optparse` procede de "
"forma equivalente a::"

#: ../Doc/library/optparse.rst:1173
msgid "If, a little later on, ``--tracks=4`` is seen, it does::"
msgstr "Si, un poco más adelante, se encuentra ``--tracks=4``, procede así::"

#: ../Doc/library/optparse.rst:1177
msgid ""
"The ``append`` action calls the ``append`` method on the current value of "
"the option.  This means that any default value specified must have an "
"``append`` method.  It also means that if the default value is non-empty, "
"the default elements will be present in the parsed value for the option, "
"with any values from the command line appended after those default values::"
msgstr ""
"La acción ``append`` llama al método ``append`` con el valor actual de la "
"opción. Esto significa que cualquier valor por defecto especificado debe "
"tener un método ``append``. También significa que si existe un valor por "
"defecto, los elementos por defecto estarán presentes en el valor analizado "
"para la opción, con todos los valores de la línea de comandos agregados a la "
"lista a continuación de ellos::"

#: ../Doc/library/optparse.rst:1188
msgid ""
"``\"append_const\"`` [required: :attr:`~Option.const`; relevant: :attr:"
"`~Option.dest`]"
msgstr ""
"``\"append_const\"`` [atributo requerido: :attr:`~Option.const`; atributo "
"relacionado: :attr:`~Option.dest`]"

#: ../Doc/library/optparse.rst:1191
msgid ""
"Like ``\"store_const\"``, but the value :attr:`~Option.const` is appended "
"to :attr:`~Option.dest`; as with ``\"append\"``, :attr:`~Option.dest` "
"defaults to ``None``, and an empty list is automatically created the first "
"time the option is encountered."
msgstr ""
"Igual que ``\"store_const\"``, pero el valor :attr:`~Option.const` se agrega "
"a :attr:`~Option.dest`. Como ocurre con ``\"append\"``, :attr:`~Option.dest` "
"por defecto es ``None`` y se crea automáticamente una lista vacía la primera "
"vez que se encuentra la opción en la linea de comandos."

#: ../Doc/library/optparse.rst:1196
msgid "``\"count\"`` [relevant: :attr:`~Option.dest`]"
msgstr "``\"count\"`` [atributo relacionado: :attr:`~Option.dest`]"

#: ../Doc/library/optparse.rst:1198
msgid ""
"Increment the integer stored at :attr:`~Option.dest`.  If no default value "
"is supplied, :attr:`~Option.dest` is set to zero before being incremented "
"the first time."
msgstr ""
"Incrementa el entero almacenado en :attr:`~Option.dest`. Si no se "
"proporciona un valor por defecto, :attr:`~Option.dest` se establece en cero "
"antes de incrementarse por primera vez."

#: ../Doc/library/optparse.rst:1206
msgid ""
"The first time ``-v`` is seen on the command line, :mod:`optparse` does the "
"equivalent of::"
msgstr ""
"La primera vez que se encuentra ``-v`` en la línea de comandos, :mod:"
"`optparse` procede de forma equivalente a::"

#: ../Doc/library/optparse.rst:1212
msgid "Every subsequent occurrence of ``-v`` results in  ::"
msgstr "Cada aparición posterior de ``-v`` da como resultado::"

#: ../Doc/library/optparse.rst:1216
msgid ""
"``\"callback\"`` [required: :attr:`~Option.callback`; relevant: :attr:"
"`~Option.type`, :attr:`~Option.nargs`, :attr:`~Option.callback_args`, :attr:"
"`~Option.callback_kwargs`]"
msgstr ""
"``\"callback\"`` [atributo requerido: :attr:`~Option.callback`; atributos "
"relacionados: :attr:`~Option.type`, :attr:`~Option.nargs`, :attr:`~Option."
"callback_args`, :attr:`~Option.callback_kwargs`]"

#: ../Doc/library/optparse.rst:1220
msgid ""
"Call the function specified by :attr:`~Option.callback`, which is called "
"as ::"
msgstr ""
"Llama a la función especificada por :attr:`~Option.callback`, que es llamada "
"como::"

#: ../Doc/library/optparse.rst:1224
msgid "See section :ref:`optparse-option-callbacks` for more detail."
msgstr "Ver sección :ref:`optparse-option-callbacks` para más detalles."

#: ../Doc/library/optparse.rst:1228
msgid ""
"Prints a complete help message for all the options in the current option "
"parser.  The help message is constructed from the ``usage`` string passed to "
"OptionParser's constructor and the :attr:`~Option.help` string passed to "
"every option."
msgstr ""
"Imprime un mensaje de ayuda completo para todas las opciones presentes en el "
"analizador de opciones actual. El mensaje de ayuda se construye a partir de "
"la cadena ``usage``, pasada al constructor de OptionParser, y la cadena :"
"attr:`~Option.help`, pasada a cada opción."

#: ../Doc/library/optparse.rst:1233
msgid ""
"If no :attr:`~Option.help` string is supplied for an option, it will still "
"be listed in the help message.  To omit an option entirely, use the special "
"value :data:`optparse.SUPPRESS_HELP`."
msgstr ""
"Si no se proporciona una cadena :attr:`~Option.help` para una opción, dicha "
"opción seguirá apareciendo en el mensaje de ayuda. Para omitir una opción "
"por completo, debe usarse el valor especial :data:`optparse.SUPPRESS_HELP`."

#: ../Doc/library/optparse.rst:1237
msgid ""
":mod:`optparse` automatically adds a :attr:`~Option.help` option to all "
"OptionParsers, so you do not normally need to create one."
msgstr ""
"El módulo :mod:`optparse` agrega automáticamente una opción :attr:`~Option."
"help` a todos los OptionParsers, por lo que normalmente no es necesario "
"crear una."

#: ../Doc/library/optparse.rst:1255
msgid ""
"If :mod:`optparse` sees either ``-h`` or ``--help`` on the command line, it "
"will print something like the following help message to stdout (assuming "
"``sys.argv[0]`` is ``\"foo.py\"``):"
msgstr ""
"Si :mod:`optparse` encuentra ``-h`` o ``--help`` en la línea de comandos, "
"imprimirá un mensaje de ayuda en la salida estándar como el siguiente "
"(asumiendo que ``sys.argv [0]`` es ``\"foo.py\"``):"

#: ../Doc/library/optparse.rst:1268
msgid ""
"After printing the help message, :mod:`optparse` terminates your process "
"with ``sys.exit(0)``."
msgstr ""
"Después de imprimir el mensaje de ayuda, :mod:`optparse` termina su proceso "
"con ``sys.exit(0)``."

#: ../Doc/library/optparse.rst:1271
msgid "``\"version\"``"
msgstr "``\"version\"``"

#: ../Doc/library/optparse.rst:1273
msgid ""
"Prints the version number supplied to the OptionParser to stdout and exits. "
"The version number is actually formatted and printed by the "
"``print_version()`` method of OptionParser.  Generally only relevant if the "
"``version`` argument is supplied to the OptionParser constructor.  As with :"
"attr:`~Option.help` options, you will rarely create ``version`` options, "
"since :mod:`optparse` automatically adds them when needed."
msgstr ""
"Imprime el número de versión proporcionado a OptionParser en la salida "
"estándar y termina la ejecución. El número de versión en realidad es "
"formateado e impreso por el método ``print_version()`` de OptionParser. "
"Generalmente solo es relevante si el argumento ``version`` se proporciona al "
"constructor de OptionParser. Al igual que en el caso de las opciones :attr:"
"`~Option.help`, rara vez será necesario crear opciones de ``version``, ya "
"que :mod:`optparse` las agrega automáticamente cuando es necesario."

#: ../Doc/library/optparse.rst:1284
msgid "Standard option types"
msgstr "Tipos de opción estándares"

#: ../Doc/library/optparse.rst:1286
msgid ""
":mod:`optparse` has five built-in option types: ``\"string\"``, ``\"int\"``, "
"``\"choice\"``, ``\"float\"`` and ``\"complex\"``.  If you need to add new "
"option types, see section :ref:`optparse-extending-optparse`."
msgstr ""
"El módulo :mod:`optparse` proporciona cinco tipos de opción incorporados: "
"``\"string\"``, ``\"int\"``, ``\"choice\"``, ``\"float\"`` y "
"``\"complex\"``. Consultar la sección :ref:`optparse-extending-optparse` si "
"se necesitan agregar nuevos tipos de opción."

#: ../Doc/library/optparse.rst:1290
msgid ""
"Arguments to string options are not checked or converted in any way: the "
"text on the command line is stored in the destination (or passed to the "
"callback) as-is."
msgstr ""
"Los argumentos de las opciones en la cadena ingresada no se verifican ni se "
"convierten de ninguna manera: el texto de la línea de comandos se almacena "
"en el destino (o se pasa a la retrollamada) tal cual."

#: ../Doc/library/optparse.rst:1293
msgid "Integer arguments (type ``\"int\"``) are parsed as follows:"
msgstr ""
"Los argumentos enteros (tipo ``\"int\"``) se analizan de la siguiente manera:"

#: ../Doc/library/optparse.rst:1295
msgid "if the number starts with ``0x``, it is parsed as a hexadecimal number"
msgstr ""
"si el número comienza con ``0x``, se analiza como un número hexadecimal"

#: ../Doc/library/optparse.rst:1297
msgid "if the number starts with ``0``, it is parsed as an octal number"
msgstr "si el número comienza con ``0``, se analiza como un número octal"

#: ../Doc/library/optparse.rst:1299
msgid "if the number starts with ``0b``, it is parsed as a binary number"
msgstr "si el número comienza con ``0b``, se analiza como un número binario"

#: ../Doc/library/optparse.rst:1301
msgid "otherwise, the number is parsed as a decimal number"
msgstr "en cualquier otro caso, el número se analiza como un número decimal"

#: ../Doc/library/optparse.rst:1304
msgid ""
"The conversion is done by calling :func:`int` with the appropriate base (2, "
"8, 10, or 16).  If this fails, so will :mod:`optparse`, although with a more "
"useful error message."
msgstr ""
"La conversión se realiza llamando a :func:`int` con la base apropiada (2, 8, "
"10 o 16). Si esto falla, también lo hará :mod:`optparse`, aunque mostrando "
"un mensaje de error más útil para el usuario."

#: ../Doc/library/optparse.rst:1308
msgid ""
"``\"float\"`` and ``\"complex\"`` option arguments are converted directly "
"with :func:`float` and :func:`complex`, with similar error-handling."
msgstr ""
"Los argumentos de las opciones de tipo ``\"float\"`` y ``\"complex\"`` se "
"convierten directamente usando :func:`float` y :func:`complex` "
"respectivamente, con un manejo de errores similar."

#: ../Doc/library/optparse.rst:1311
msgid ""
"``\"choice\"`` options are a subtype of ``\"string\"`` options.  The :attr:"
"`~Option.choices` option attribute (a sequence of strings) defines the set "
"of allowed option arguments.  :func:`optparse.check_choice` compares user-"
"supplied option arguments against this master list and raises :exc:"
"`OptionValueError` if an invalid string is given."
msgstr ""
"Las opciones de tipo ``\"choice\"`` son un subtipo de las opciones "
"``\"string\"``. El atributo de opción :attr:`~Option.choices` (que es una "
"secuencia de cadenas) define el conjunto de argumentos de opción permitidos. "
"Posteriormente, :func:`optparse.check_choice` comparará los argumentos de "
"las opciones proporcionadas por el usuario con esta lista maestra y lanzará "
"una excepción :exc:`OptionValueError` si se proporciona una cadena no válida."

#: ../Doc/library/optparse.rst:1321
msgid "Parsing arguments"
msgstr "Analizando los argumentos"

#: ../Doc/library/optparse.rst:1323
msgid ""
"The whole point of creating and populating an OptionParser is to call its :"
"meth:`parse_args` method::"
msgstr ""
"El objetivo primario de crear y agregar opciones a un OptionParser es llamar "
"a su método :meth:`parse_args`::"

#: ../Doc/library/optparse.rst:1328
msgid "where the input parameters are"
msgstr "donde los parámetros de entrada son"

#: ../Doc/library/optparse.rst:1331 ../Doc/library/optparse.rst:1345
#: ../Doc/library/optparse.rst:1664
msgid "``args``"
msgstr "``args``"

#: ../Doc/library/optparse.rst:1331
msgid "the list of arguments to process (default: ``sys.argv[1:]``)"
msgstr "la lista de argumentos a procesar (por defecto: ``sys.argv [1:]``)"

#: ../Doc/library/optparse.rst:1336
msgid "``values``"
msgstr "``values``"

#: ../Doc/library/optparse.rst:1334
msgid ""
"an :class:`optparse.Values` object to store option arguments in (default: a "
"new instance of :class:`Values`) -- if you give an existing object, the "
"option defaults will not be initialized on it"
msgstr ""
"un objeto de la clase :class:`optparse.Values` para almacenar en él los "
"argumentos de las opciones. Por defecto es una nueva instancia de la clase :"
"class:`Values`. Si se proporciona un objeto previamente creado, los valores "
"predeterminados de la opción no se inicializarán en el mismo"

#: ../Doc/library/optparse.rst:1338
msgid "and the return values are"
msgstr "y los valores de retorno son"

#: ../Doc/library/optparse.rst:1342
msgid "``options``"
msgstr "``options``"

#: ../Doc/library/optparse.rst:1341
msgid ""
"the same object that was passed in as ``values``, or the optparse.Values "
"instance created by :mod:`optparse`"
msgstr ""
"el mismo objeto que se pasó como ``values``, o la instancia *optparse."
"Values* creada por :mod:`optparse`"

#: ../Doc/library/optparse.rst:1345
msgid "the leftover positional arguments after all options have been processed"
msgstr ""
"los argumentos posicionales que quedan en la linea de comandos después de "
"que se hayan procesado todas las opciones"

#: ../Doc/library/optparse.rst:1347
msgid ""
"The most common usage is to supply neither keyword argument.  If you supply "
"``values``, it will be modified with repeated :func:`setattr` calls (roughly "
"one for every option argument stored to an option destination) and returned "
"by :meth:`parse_args`."
msgstr ""
"El uso más habitual es no proporcionar ningún argumento por palabra clave. "
"Si se proporciona ``values``, dicho argumento será modificado mediante "
"llamadas repetidas a :func:`setattr` (aproximadamente una por cada argumento "
"de opción a almacenar en un destino de opción) y finalmente será retornado "
"por el método :meth:`parse_args`."

#: ../Doc/library/optparse.rst:1352
msgid ""
"If :meth:`parse_args` encounters any errors in the argument list, it calls "
"the OptionParser's :meth:`error` method with an appropriate end-user error "
"message. This ultimately terminates your process with an exit status of 2 "
"(the traditional Unix exit status for command-line errors)."
msgstr ""
"Si el método :meth:`parse_args` encuentra algún error en la lista de "
"argumentos, llama al método :meth:`error` de OptionParser con un mensaje de "
"error apropiado para el usuario final. Esto causa que el proceso termine con "
"un estado de salida de 2 (el estado de salida tradicional en Unix para "
"errores en la línea de comandos)."

#: ../Doc/library/optparse.rst:1361
msgid "Querying and manipulating your option parser"
msgstr "Consultar y manipular el analizador de opciones"

#: ../Doc/library/optparse.rst:1363
msgid ""
"The default behavior of the option parser can be customized slightly, and "
"you can also poke around your option parser and see what's there.  "
"OptionParser provides several methods to help you out:"
msgstr ""
"El comportamiento predeterminado del analizador de opciones se puede "
"personalizar ligeramente. También se puede indagar en el analizador de "
"opciones y ver qué hay en él. OptionParser proporciona varios métodos para "
"ayudar con éstos propósitos:"

#: ../Doc/library/optparse.rst:1369
msgid ""
"Set parsing to stop on the first non-option.  For example, if ``-a`` and ``-"
"b`` are both simple options that take no arguments, :mod:`optparse` normally "
"accepts this syntax::"
msgstr ""
"Configura el análisis para que se detenga en lo primero que encuentre que no "
"sea una opción. Por ejemplo, si ``-a`` y ``-b`` son opciones simples que no "
"toman argumentos, :mod:`optparse` normalmente acepta esta sintaxis::"

#: ../Doc/library/optparse.rst:1375
msgid "and treats it as equivalent to  ::"
msgstr "y la trata de forma equivalente a::"

#: ../Doc/library/optparse.rst:1379
msgid ""
"To disable this feature, call :meth:`disable_interspersed_args`.  This "
"restores traditional Unix syntax, where option parsing stops with the first "
"non-option argument."
msgstr ""
"Para deshabilitar esta funcionalidad, se debe llamar al método :meth:"
"`disable_interspersed_args`. Esto restaura la sintaxis tradicional usada en "
"Unix, donde el análisis de opción se detiene con el primer argumento que no "
"es una opción."

#: ../Doc/library/optparse.rst:1383
msgid ""
"Use this if you have a command processor which runs another command which "
"has options of its own and you want to make sure these options don't get "
"confused.  For example, each command might have a different set of options."
msgstr ""
"Se debe usar este método si se dispone de un procesador de comandos que "
"ejecuta otro comando con sus propias opciones y se desea asegurarse de que "
"estas opciones no se confunden entre si. Lo que puede ocurrir si, por "
"ejemplo, cada comando tiene un conjunto diferente de opciones."

#: ../Doc/library/optparse.rst:1389
msgid ""
"Set parsing to not stop on the first non-option, allowing interspersing "
"switches with command arguments.  This is the default behavior."
msgstr ""
"Configura el análisis para que no se detenga si encuentra un argumento que "
"no sea una opción, lo que permite intercalar modificadores con argumentos de "
"linea de comandos. Este es el comportamiento por defecto."

#: ../Doc/library/optparse.rst:1394
msgid ""
"Returns the Option instance with the option string *opt_str*, or ``None`` if "
"no options have that option string."
msgstr ""
"Retorna la instancia de Option con la cadena de opción *opt_str*, o ``None`` "
"si ninguna opción tiene esa cadena de opción."

#: ../Doc/library/optparse.rst:1399
msgid ""
"Return ``True`` if the OptionParser has an option with option string "
"*opt_str* (e.g., ``-q`` or ``--verbose``)."
msgstr ""
"Retorna ``True`` si OptionParser tiene una opción con la cadena de opción "
"*opt_str* (por ejemplo, ``-q`` o ``--verbose``)."

#: ../Doc/library/optparse.rst:1404
msgid ""
"If the :class:`OptionParser` has an option corresponding to *opt_str*, that "
"option is removed.  If that option provided any other option strings, all of "
"those option strings become invalid. If *opt_str* does not occur in any "
"option belonging to this :class:`OptionParser`, raises :exc:`ValueError`."
msgstr ""
"Si :class:`OptionParser` tiene una opción correspondiente a *opt_str*, esa "
"opción es eliminada. Si esa opción proporcionó cualquier otra cadena de "
"opción, todas esas cadenas de opción quedan invalidadas. Si *opt_str* no "
"aparece en ninguna opción que pertenezca a este :class:`OptionParser`, se "
"lanza una excepción :exc:`ValueError`."

#: ../Doc/library/optparse.rst:1413
msgid "Conflicts between options"
msgstr "Conflictos entre opciones"

#: ../Doc/library/optparse.rst:1415
msgid ""
"If you're not careful, it's easy to define options with conflicting option "
"strings::"
msgstr ""
"Si no se tiene cuidado, es fácil definir opciones con cadenas de opción en "
"conflicto entre si::"

#: ../Doc/library/optparse.rst:1422
msgid ""
"(This is particularly true if you've defined your own OptionParser subclass "
"with some standard options.)"
msgstr ""
"(Esto es particularmente cierto si se ha definido una subclase propia de "
"OptionParser con algunas opciones estándar.)"

#: ../Doc/library/optparse.rst:1425
msgid ""
"Every time you add an option, :mod:`optparse` checks for conflicts with "
"existing options.  If it finds any, it invokes the current conflict-handling "
"mechanism. You can set the conflict-handling mechanism either in the "
"constructor::"
msgstr ""
"Cada vez que se agrega una opción, :mod:`optparse` comprueba si existen "
"conflictos con las opciones ya existentes. Si encuentra alguno, invoca el "
"mecanismo de manejo de conflictos actualmente establecido. Se puede "
"establecer el mecanismo de manejo de conflictos desde el propio constructor::"

#: ../Doc/library/optparse.rst:1431
msgid "or with a separate call::"
msgstr "o mediante una llamada separada::"

#: ../Doc/library/optparse.rst:1435
msgid "The available conflict handlers are:"
msgstr "Los administradores de conflictos disponibles son:"

#: ../Doc/library/optparse.rst:1439
msgid "``\"error\"`` (default)"
msgstr "``\"error\"`` (por defecto)"

#: ../Doc/library/optparse.rst:1438
msgid ""
"assume option conflicts are a programming error and raise :exc:"
"`OptionConflictError`"
msgstr ""
"se asume que los conflictos entre opciones son un error de programación y, "
"por tanto, generarán una excepción :exc:`OptionConflictError`"

#: ../Doc/library/optparse.rst:1443
msgid "``\"resolve\"``"
msgstr "``\"resolve\"``"

#: ../Doc/library/optparse.rst:1442
msgid "resolve option conflicts intelligently (see below)"
msgstr "resuelve conflictos de opciones de forma inteligente (ver más abajo)"

#: ../Doc/library/optparse.rst:1445
msgid ""
"As an example, let's define an :class:`OptionParser` that resolves conflicts "
"intelligently and add conflicting options to it::"
msgstr ""
"Como ejemplo, vamos a definir un :class:`OptionParser` que resuelva "
"conflictos de manera inteligente y agregaremos algunas opciones "
"conflictivas::"

#: ../Doc/library/optparse.rst:1452
#, fuzzy
msgid ""
"At this point, :mod:`optparse` detects that a previously added option is "
"already using the ``-n`` option string.  Since ``conflict_handler`` is "
"``\"resolve\"``, it resolves the situation by removing ``-n`` from the "
"earlier option's list of option strings.  Now ``--dry-run`` is the only way "
"for the user to activate that option.  If the user asks for help, the help "
"message will reflect that::"
msgstr ""
"En este punto, :mod:`optparse` detecta que una opción agregada anteriormente "
"ya está usando la cadena de opción ``-n``. Dado que ``conflict_handler`` es "
"``\"resolve\"``, resuelve la situación eliminando ``-n`` de la lista de "
"cadenas de opción de la opción previa. Ahora ``--dry-run`` es la única forma "
"que el usuario tiene para poder activar esa opción. Si el usuario solicita "
"ayuda, el mensaje de ayuda reflejará la nueva situación::"

#: ../Doc/library/optparse.rst:1463
#, fuzzy
msgid ""
"It's possible to whittle away the option strings for a previously added "
"option until there are none left, and the user has no way of invoking that "
"option from the command-line.  In that case, :mod:`optparse` removes that "
"option completely, so it doesn't show up in help text or anywhere else. "
"Carrying on with our existing OptionParser::"
msgstr ""
"Es posible reducir las cadenas de opción para una opción agregada "
"previamente hasta que no quede ninguna, de forma que el usuario no tenga "
"forma de invocar esa opción desde la línea de comandos. En ese caso, :mod:"
"`optparse` eliminará esa opción por completo, por lo que no aparecerá en el "
"texto de ayuda ni en ningún otro lugar. Continuando con nuestro analizador "
"de opciones previo::"

#: ../Doc/library/optparse.rst:1471
msgid ""
"At this point, the original ``-n``/``--dry-run`` option is no longer "
"accessible, so :mod:`optparse` removes it, leaving this help text::"
msgstr ""
"En este punto, la opción original ``-n``/``--dry-run`` ya no es accesible, "
"por lo que :mod:`optparse` la elimina, dejando el siguiente texto de ayuda::"

#: ../Doc/library/optparse.rst:1483
msgid "Cleanup"
msgstr "Limpieza"

#: ../Doc/library/optparse.rst:1485
msgid ""
"OptionParser instances have several cyclic references.  This should not be a "
"problem for Python's garbage collector, but you may wish to break the cyclic "
"references explicitly by calling :meth:`~OptionParser.destroy` on your "
"OptionParser once you are done with it.  This is particularly useful in long-"
"running applications where large object graphs are reachable from your "
"OptionParser."
msgstr ""
"Las instancias de OptionParser tienen varias referencias cíclicas. Esto no "
"debería ser un problema para el recolector de basura de Python, pero es "
"posible que se desee romper las referencias cíclicas explícitamente llamando "
"al método :meth:`~OptionParser.destroy` de la instancia OptionParser una vez "
"que se haya terminado. Esto es particularmente útil en aplicaciones de larga "
"ejecución en las que OptionParser puede terminar accediendo a grafos de "
"objetos considerablemente grandes."

#: ../Doc/library/optparse.rst:1496
msgid "Other methods"
msgstr "Otros métodos"

#: ../Doc/library/optparse.rst:1498
msgid "OptionParser supports several other public methods:"
msgstr "OptionParser admite varios métodos públicos más:"

#: ../Doc/library/optparse.rst:1502
msgid ""
"Set the usage string according to the rules described above for the "
"``usage`` constructor keyword argument.  Passing ``None`` sets the default "
"usage string; use :data:`optparse.SUPPRESS_USAGE` to suppress a usage "
"message."
msgstr ""
"Establece la cadena de caracteres de uso de acuerdo a las reglas descritas "
"anteriormente para el argumento por palabra clave ``usage`` del constructor. "
"Si se pasa ``None`` se establece la cadena de uso por defecto. Para suprimir "
"el mensaje de uso totalmente, se debe pasar el valor especial :data:"
"`optparse.SUPPRESS_USAGE`."

#: ../Doc/library/optparse.rst:1508
msgid ""
"Print the usage message for the current program (``self.usage``) to *file* "
"(default stdout).  Any occurrence of the string ``%prog`` in ``self.usage`` "
"is replaced with the name of the current program.  Does nothing if ``self."
"usage`` is empty or not defined."
msgstr ""
"Imprime el mensaje de uso del programa actual (``self.usage``) en *file* "
"(que por defecto es la salida estándar). Cualquier aparición de la cadena de "
"caracteres ``%prog`` en ``self.usage`` es reemplazada con el nombre del "
"programa actual. No hace nada si ``self.usage`` está vacío o no ha sido "
"definido."

#: ../Doc/library/optparse.rst:1515
msgid ""
"Same as :meth:`print_usage` but returns the usage string instead of printing "
"it."
msgstr ""
"Igual que :meth:`print_usage` pero retorna la cadena de uso en vez de "
"imprimirla."

#: ../Doc/library/optparse.rst:1520
msgid ""
"Set default values for several option destinations at once.  Using :meth:"
"`set_defaults` is the preferred way to set default values for options, since "
"multiple options can share the same destination.  For example, if several "
"\"mode\" options all set the same destination, any one of them can set the "
"default, and the last one wins::"
msgstr ""
"Establece valores por defecto para varios destinos de opción a la vez. Usar "
"el método :meth:`set_defaults` es la forma preferida de establecer valores "
"por defecto para las opciones, ya que varias opciones pueden compartir el "
"mismo destino. Por ejemplo, si varias opciones de ``mode`` tienen el mismo "
"destino, cualquiera de ellas puede establecer el valor por defecto, pero el "
"último establecido es el que finalmente queda establecido::"

#: ../Doc/library/optparse.rst:1533
msgid "To avoid this confusion, use :meth:`set_defaults`::"
msgstr "Para evitar esta confusión, usa el método :meth:`set_defaults`::"

#: ../Doc/library/optparse.rst:1545
msgid "Option Callbacks"
msgstr "Retrollamadas de opción"

#: ../Doc/library/optparse.rst:1547
msgid ""
"When :mod:`optparse`'s built-in actions and types aren't quite enough for "
"your needs, you have two choices: extend :mod:`optparse` or define a "
"callback option. Extending :mod:`optparse` is more general, but overkill for "
"a lot of simple cases.  Quite often a simple callback is all you need."
msgstr ""
"Cuando las acciones y tipos incorporados de :mod:`optparse` no son "
"suficientes para tus necesidades, tienes dos opciones: extender :mod:"
"`optparse` o definir una opción con una retrollamada asociada. Extender :mod:"
"`optparse` es más general, pero algo exagerado para muchos casos simples. Es "
"frecuente que una simple retrollamada sea todo lo que necesitas."

#: ../Doc/library/optparse.rst:1552
msgid "There are two steps to defining a callback option:"
msgstr "Hay dos pasos a seguir para definir una opción con retrollamada:"

#: ../Doc/library/optparse.rst:1554
msgid "define the option itself using the ``\"callback\"`` action"
msgstr "definir la opción en sí usando la acción ``\"callback\"``"

#: ../Doc/library/optparse.rst:1556
msgid ""
"write the callback; this is a function (or method) that takes at least four "
"arguments, as described below"
msgstr ""
"escribir la retrollamada. Esta es una función (o método) que toma al menos "
"cuatro argumentos, los cuales son descritos a continuación"

#: ../Doc/library/optparse.rst:1563
msgid "Defining a callback option"
msgstr "Definición de una opción con retrollamada"

#: ../Doc/library/optparse.rst:1565
msgid ""
"As always, the easiest way to define a callback option is by using the :meth:"
"`OptionParser.add_option` method.  Apart from :attr:`~Option.action`, the "
"only option attribute you must specify is ``callback``, the function to "
"call::"
msgstr ""
"Generalmente, la forma más sencilla de definir una opción con retrollamada "
"es mediante el método :meth:`OptionParser.add_option`. Aparte de :attr:"
"`~Option.action`, el único atributo de opción que debes especificar es "
"``callback``, que es la función a llamar::"

#: ../Doc/library/optparse.rst:1571
msgid ""
"``callback`` is a function (or other callable object), so you must have "
"already defined ``my_callback()`` when you create this callback option. In "
"this simple case, :mod:`optparse` doesn't even know if ``-c`` takes any "
"arguments, which usually means that the option takes no arguments---the mere "
"presence of ``-c`` on the command-line is all it needs to know.  In some "
"circumstances, though, you might want your callback to consume an arbitrary "
"number of command-line arguments.  This is where writing callbacks gets "
"tricky; it's covered later in this section."
msgstr ""
"``callback`` es una función (u otro objeto invocable), lo que implica que "
"``my_callback()`` debe haber sido definida antes de la la creación de esta "
"opción con retrollamada. En este caso simple, :mod:`optparse` ni siquiera "
"sabe si ``-c`` toma algún argumento, lo que generalmente significa que la "
"opción no toma argumentos\\ ---la mera presencia de ``-c`` en la línea de "
"comandos es todo lo que necesita saber. Sin embargo, en algunas "
"circunstancias, es posible que se desee que la retrollamada consuma una "
"cantidad arbitraria de argumentos de la propia línea de comandos. Es aquí "
"donde escribir retrollamadas se vuelve complicado; se tratará más adelante "
"en esta sección."

#: ../Doc/library/optparse.rst:1580
msgid ""
":mod:`optparse` always passes four particular arguments to your callback, "
"and it will only pass additional arguments if you specify them via :attr:"
"`~Option.callback_args` and :attr:`~Option.callback_kwargs`.  Thus, the "
"minimal callback function signature is::"
msgstr ""
":mod:`optparse` siempre pasa cuatro argumentos concretos a la retrollamada. "
"El método solo pasará argumentos adicionales si se especifica explícitamente "
"a través de :attr:`~Option.callback_args` y :attr:`~Option.callback_kwargs`. "
"Por lo tanto, la firma mínima de la retrollamada es:"

#: ../Doc/library/optparse.rst:1587
msgid "The four arguments to a callback are described below."
msgstr ""
"Los cuatro argumentos para la retrollamada se describen a continuación."

#: ../Doc/library/optparse.rst:1589
msgid ""
"There are several other option attributes that you can supply when you "
"define a callback option:"
msgstr ""
"Hay varios atributos de opción adicionales que se pueden proporcionar cuando "
"se define una opción con retrollamada:"

#: ../Doc/library/optparse.rst:1596
msgid ":attr:`~Option.type`"
msgstr ":attr:`~Option.type`"

#: ../Doc/library/optparse.rst:1593
msgid ""
"has its usual meaning: as with the ``\"store\"`` or ``\"append\"`` actions, "
"it instructs :mod:`optparse` to consume one argument and convert it to :attr:"
"`~Option.type`.  Rather than storing the converted value(s) anywhere, "
"though, :mod:`optparse` passes it to your callback function."
msgstr ""
"tiene su significado habitual: al igual que en las acciones ``\"store\"`` o "
"``\"append\"``, indica a :mod:`optparse` que debe consumir un argumento y "
"convertirlo a :attr:`~Option.type` . Sin embargo, en lugar de almacenar el "
"valor (o valores) convertido en algún lugar, :mod:`optparse` lo pasa a la "
"retrollamada."

#: ../Doc/library/optparse.rst:1602
msgid ":attr:`~Option.nargs`"
msgstr ":attr:`~Option.nargs`"

#: ../Doc/library/optparse.rst:1599
msgid ""
"also has its usual meaning: if it is supplied and > 1, :mod:`optparse` will "
"consume :attr:`~Option.nargs` arguments, each of which must be convertible "
"to :attr:`~Option.type`.  It then passes a tuple of converted values to your "
"callback."
msgstr ""
"también tiene su significado habitual: si se proporciona y es mayor que 1, :"
"mod:`optparse` consumirá :attr:`~Option.nargs` argumentos de la línea de "
"comandos, cada uno de los cuales debe ser convertible a :attr:`~Option."
"type`. Hecho esto, se pasa una tupla con los valores convertidos a la "
"retrollamada."

#: ../Doc/library/optparse.rst:1605
msgid ":attr:`~Option.callback_args`"
msgstr ":attr:`~Option.callback_args`"

#: ../Doc/library/optparse.rst:1605
msgid "a tuple of extra positional arguments to pass to the callback"
msgstr ""
"una tupla con los argumentos posicionales adicionales para pasar a la "
"retrollamada"

#: ../Doc/library/optparse.rst:1609
msgid ":attr:`~Option.callback_kwargs`"
msgstr ":attr:`~Option.callback_kwargs`"

#: ../Doc/library/optparse.rst:1608
msgid "a dictionary of extra keyword arguments to pass to the callback"
msgstr ""
"un diccionario con los argumentos por palabra clave para pasar a la "
"retrollamada"

#: ../Doc/library/optparse.rst:1614
msgid "How callbacks are called"
msgstr "Cómo son invocadas las retrollamadas"

#: ../Doc/library/optparse.rst:1616
msgid "All callbacks are called as follows::"
msgstr "Todas las retrollamadas son invocadas de la siguiente forma::"

#: ../Doc/library/optparse.rst:1623
msgid "``option``"
msgstr "``option``"

#: ../Doc/library/optparse.rst:1623
msgid "is the Option instance that's calling the callback"
msgstr "es la instancia de Option que invoca a la retrollamada"

#: ../Doc/library/optparse.rst:1630
msgid "``opt_str``"
msgstr "``opt_str``"

#: ../Doc/library/optparse.rst:1626
msgid ""
"is the option string seen on the command-line that's triggering the "
"callback. (If an abbreviated long option was used, ``opt_str`` will be the "
"full, canonical option string---e.g. if the user puts ``--foo`` on the "
"command-line as an abbreviation for ``--foobar``, then ``opt_str`` will be "
"``\"--foobar\"``.)"
msgstr ""
"es la cadena de opción encontrada en la línea de comandos que activa la "
"retrollamada. (Si se utilizó una opción larga abreviada, ``opt_str`` será la "
"cadena de opción canónica completa\\ --- por ejemplo, si el usuario ingresa "
"``--foo`` en la línea de comandos como una abreviatura de ``--foobar``, "
"entonces ``opt_str`` será ``\"--foobar\"``.)"

#: ../Doc/library/optparse.rst:1637
msgid "``value``"
msgstr "``value``"

#: ../Doc/library/optparse.rst:1633
msgid ""
"is the argument to this option seen on the command-line.  :mod:`optparse` "
"will only expect an argument if :attr:`~Option.type` is set; the type of "
"``value`` will be the type implied by the option's type.  If :attr:`~Option."
"type` for this option is ``None`` (no argument expected), then ``value`` "
"will be ``None``.  If :attr:`~Option.nargs` > 1, ``value`` will be a tuple "
"of values of the appropriate type."
msgstr ""
"es el argumento de esta opción encontrado en la línea de comandos. :mod:"
"`optparse` solo esperará un argumento si :attr:`~Option.type` está "
"establecido. El tipo de ``value`` será el tipo implícito en el tipo de la "
"propia opción. Si :attr:`~Option.type` es ``None`` para esta opción (no se "
"espera ningún argumento), entonces ``value`` será también ``None``. Si :attr:"
"`~Option.nargs` es mayor que 1, ``value`` será una tupla con los valores del "
"tipo apropiado."

#: ../Doc/library/optparse.rst:1660
msgid "``parser``"
msgstr "``parser``"

#: ../Doc/library/optparse.rst:1640
msgid ""
"is the OptionParser instance driving the whole thing, mainly useful because "
"you can access some other interesting data through its instance attributes:"
msgstr ""
"es la instancia de OptionParser que controla todo. Su utilidad principal "
"radica en que permite acceder a otros datos de interés a través de sus "
"atributos de instancia:"

#: ../Doc/library/optparse.rst:1647
msgid "``parser.largs``"
msgstr "``parser.largs``"

#: ../Doc/library/optparse.rst:1644
msgid ""
"the current list of leftover arguments, ie. arguments that have been "
"consumed but are neither options nor option arguments. Feel free to modify "
"``parser.largs``, e.g. by adding more arguments to it.  (This list will "
"become ``args``, the second return value of :meth:`parse_args`.)"
msgstr ""
"la lista actual de argumentos que sobran, es decir, argumentos que se han "
"consumido pero que no son opciones ni argumentos de opción. Siéntete libre "
"de modificar ``parser.largs``, por ejemplo, agregando más argumentos. (Esta "
"lista se convertirá en ``args``, el segundo valor de retorno del método :"
"meth:`parse_args`.)"

#: ../Doc/library/optparse.rst:1653
msgid "``parser.rargs``"
msgstr "``parser.rargs``"

#: ../Doc/library/optparse.rst:1650
msgid ""
"the current list of remaining arguments, ie. with ``opt_str`` and ``value`` "
"(if applicable) removed, and only the arguments following them still there.  "
"Feel free to modify ``parser.rargs``, e.g. by consuming more arguments."
msgstr ""
"la lista actual de argumentos restantes, es decir, los argumentos que quedan "
"a continuación de ``opt_str`` y ``value`` (si corresponde), una vez "
"eliminados ambos. Siéntete libre de modificar ``parser.rargs``, por ejemplo, "
"consumiendo más argumentos."

#: ../Doc/library/optparse.rst:1660
msgid "``parser.values``"
msgstr "``parser.values``"

#: ../Doc/library/optparse.rst:1656
msgid ""
"the object where option values are by default stored (an instance of "
"optparse.OptionValues).  This lets callbacks use the same mechanism as the "
"rest of :mod:`optparse` for storing option values; you don't need to mess "
"around with globals or closures.  You can also access or modify the value(s) "
"of any options already encountered on the command-line."
msgstr ""
"el objeto donde los valores de las opciones son almacenados por defecto (una "
"instancia de *optparse.OptionValues*). Esto permite que las retrollamadas "
"utilicen el mismo mecanismo que el resto de :mod:`optparse` para almacenar "
"valores de las opciones; no es necesario perder el tiempo con globales o "
"clausuras. También se puede acceder a los valores de las opciones o "
"modificarlos si ya se encuentran en la línea de comandos."

#: ../Doc/library/optparse.rst:1663
msgid ""
"is a tuple of arbitrary positional arguments supplied via the :attr:`~Option."
"callback_args` option attribute."
msgstr ""
"es una tupla de argumentos posicionales arbitrarios suministrados a través "
"del atributo de opción :attr:`~Option.callback_args`."

#: ../Doc/library/optparse.rst:1669
msgid "``kwargs``"
msgstr "``kwargs``"

#: ../Doc/library/optparse.rst:1667
msgid ""
"is a dictionary of arbitrary keyword arguments supplied via :attr:`~Option."
"callback_kwargs`."
msgstr ""
"es un diccionario con argumentos por palabra clave arbitrarios "
"proporcionados por :attr:`~Option.callback_kwargs`."

#: ../Doc/library/optparse.rst:1674
msgid "Raising errors in a callback"
msgstr "Lanzando errores en una retrollamada"

#: ../Doc/library/optparse.rst:1676
msgid ""
"The callback function should raise :exc:`OptionValueError` if there are any "
"problems with the option or its argument(s).  :mod:`optparse` catches this "
"and terminates the program, printing the error message you supply to "
"stderr.  Your message should be clear, concise, accurate, and mention the "
"option at fault. Otherwise, the user will have a hard time figuring out what "
"they did wrong."
msgstr ""
"La retrollamada debería lanzar una excepción :exc:`OptionValueError` si hay "
"algún problema con la opción o su(s) argumento(s). Esto permite a :mod:"
"`optparse` detectar el problema y finalizar el programa, imprimiendo el "
"mensaje de error que hayas proporciones en la salida de error estándar. El "
"mensaje debe ser claro, conciso, preciso y mencionar la opción que causa la "
"excepción. De lo contrario, el usuario tendrá dificultades para descubrir "
"qué hizo mal."

#: ../Doc/library/optparse.rst:1686
msgid "Callback example 1: trivial callback"
msgstr "Ejemplo de retrollamada 1: una retrollamada trivial"

#: ../Doc/library/optparse.rst:1688
msgid ""
"Here's an example of a callback option that takes no arguments, and simply "
"records that the option was seen::"
msgstr ""
"Aquí hay un ejemplo de una opción con retrollamada que no tiene argumentos y "
"simplemente registra que se encontró la opción en la línea de comandos:"

#: ../Doc/library/optparse.rst:1696
msgid "Of course, you could do that with the ``\"store_true\"`` action."
msgstr ""
"Ciertamente, se puede hacer lo mismo simplemente con la acción "
"``\"store_true\"``."

#: ../Doc/library/optparse.rst:1702
msgid "Callback example 2: check option order"
msgstr "Ejemplo de retrollamada 2: comprobar el orden de las opciones"

#: ../Doc/library/optparse.rst:1704
msgid ""
"Here's a slightly more interesting example: record the fact that ``-a`` is "
"seen, but blow up if it comes after ``-b`` in the command-line.  ::"
msgstr ""
"Aquí tenemos un ejemplo un poco más interesante: registra el hecho de que se "
"ha encontrado ``-a``, pero lanza un error si viene después de ``-b`` en la "
"línea de comandos ::"

#: ../Doc/library/optparse.rst:1719
msgid "Callback example 3: check option order (generalized)"
msgstr ""
"Ejemplo de retrollamada 3: comprobar el orden de las opciones (generalizado)"

#: ../Doc/library/optparse.rst:1721
msgid ""
"If you want to re-use this callback for several similar options (set a flag, "
"but blow up if ``-b`` has already been seen), it needs a bit of work: the "
"error message and the flag that it sets must be generalized.  ::"
msgstr ""
"Si deseas reutilizar esta misma retrollamada para varias opciones similares "
"(establecer un flag, pero lanzar un error si ya se ha encontrado ``-b``), "
"necesitas un poco más de trabajo: tanto el mensaje de error como el flag que "
"estableces deben generalizarse::"

#: ../Doc/library/optparse.rst:1738
msgid "Callback example 4: check arbitrary condition"
msgstr "Ejemplo de retrollamada 4: comprobar una condición arbitraria"

#: ../Doc/library/optparse.rst:1740
msgid ""
"Of course, you could put any condition in there---you're not limited to "
"checking the values of already-defined options.  For example, if you have "
"options that should not be called when the moon is full, all you have to do "
"is this::"
msgstr ""
"Por supuesto, puedes poner cualquier condición aquí, no estás limitado a "
"verificar los valores de las opciones previamente definidas. Por ejemplo, si "
"tienes opciones que no deberían llamarse cuando hay luna llena, todo lo que "
"tienes que hacer es lo siguiente::"

#: ../Doc/library/optparse.rst:1753
msgid ""
"(The definition of ``is_moon_full()`` is left as an exercise for the reader.)"
msgstr ""
"(La definición de ``is_moon_full()`` se deja como ejercicio para el lector)."

#: ../Doc/library/optparse.rst:1759
msgid "Callback example 5: fixed arguments"
msgstr "Ejemplo de retrollamada 5: argumentos fijos"

#: ../Doc/library/optparse.rst:1761
msgid ""
"Things get slightly more interesting when you define callback options that "
"take a fixed number of arguments.  Specifying that a callback option takes "
"arguments is similar to defining a ``\"store\"`` or ``\"append\"`` option: "
"if you define :attr:`~Option.type`, then the option takes one argument that "
"must be convertible to that type; if you further define :attr:`~Option."
"nargs`, then the option takes :attr:`~Option.nargs` arguments."
msgstr ""
"Las cosas se ponen un poco más interesantes cuando se definen opciones con "
"retrollamada que toman un número fijo de argumentos. Especificar que una "
"opción con retrollamada toma argumentos es similar a definir una opción "
"``\"store\"`` o ``\"append\"``: si se define :attr:`~Option.type`, entonces "
"la opción toma un argumento que debe poder convertirse a ese tipo; si además "
"se define :attr:`~Option.nargs`, entonces la opción toma :attr:`~Option."
"nargs` argumentos."

#: ../Doc/library/optparse.rst:1768
msgid ""
"Here's an example that just emulates the standard ``\"store\"`` action::"
msgstr ""
"Aquí hay un ejemplo que simplemente emula la acción ``\"store\"`` estándar::"

#: ../Doc/library/optparse.rst:1777
msgid ""
"Note that :mod:`optparse` takes care of consuming 3 arguments and converting "
"them to integers for you; all you have to do is store them.  (Or whatever; "
"obviously you don't need a callback for this example.)"
msgstr ""
"Ten en cuenta que :mod:`optparse` se encarga de consumir 3 argumentos y "
"convertirlos a números enteros por ti; todo lo que tienes que hacer es "
"almacenarlos. (En cualquier caso, obviamente no necesitas hacer uso de una "
"retrollamada para este ejemplo)."

#: ../Doc/library/optparse.rst:1785
msgid "Callback example 6: variable arguments"
msgstr "Ejemplo de retrollamada 6: argumentos variables"

#: ../Doc/library/optparse.rst:1787
msgid ""
"Things get hairy when you want an option to take a variable number of "
"arguments. For this case, you must write a callback, as :mod:`optparse` "
"doesn't provide any built-in capabilities for it.  And you have to deal with "
"certain intricacies of conventional Unix command-line parsing that :mod:"
"`optparse` normally handles for you.  In particular, callbacks should "
"implement the conventional rules for bare ``--`` and ``-`` arguments:"
msgstr ""
"Las cosas se complican si quieres que una opción pueda tomar un número "
"variable de argumentos. En este caso, si que deberás escribir una "
"retrollamada, ya que el módulo :mod:`optparse` no proporciona ninguna "
"capacidad incorporada para ello. Además, tienes que lidiar con ciertos "
"entresijos del análisis convencional de la línea de comandos de Unix, que :"
"mod:`optparse` normalmente maneja por ti. En concreto, las retrollamadas "
"deben implementar las reglas convencionales para los argumentos ``--`` y ``-"
"`` desnudos:"

#: ../Doc/library/optparse.rst:1794
msgid "either ``--`` or ``-`` can be option arguments"
msgstr "tanto ``--`` como ``-`` pueden ser argumentos de opción"

#: ../Doc/library/optparse.rst:1796
msgid ""
"bare ``--`` (if not the argument to some option): halt command-line "
"processing and discard the ``--``"
msgstr ""
"``--`` desnudo (si no es el argumento de alguna opción): detener el "
"procesamiento de la línea de comandos y descartar el ``--``"

#: ../Doc/library/optparse.rst:1799
msgid ""
"bare ``-`` (if not the argument to some option): halt command-line "
"processing but keep the ``-`` (append it to ``parser.largs``)"
msgstr ""
"``-`` desnudo (si no es el argumento de alguna opción): detener el "
"procesamiento de la línea de comandos pero mantener el ``-`` (añadiéndolo a "
"``parser.largs``)"

#: ../Doc/library/optparse.rst:1802
msgid ""
"If you want an option that takes a variable number of arguments, there are "
"several subtle, tricky issues to worry about.  The exact implementation you "
"choose will be based on which trade-offs you're willing to make for your "
"application (which is why :mod:`optparse` doesn't support this sort of thing "
"directly)."
msgstr ""
"Si deseas que una opción tenga un número variable de argumentos, hay varios "
"problemas sutiles y complicados de los que deberás preocuparte. La "
"implementación exacta que elijas dependerá de los sacrificios que estés "
"dispuesto a hacer en tu aplicación (razón por la cual, el módulo :mod:"
"`optparse` no admite directamente este tipo de cosas)."

#: ../Doc/library/optparse.rst:1808
msgid ""
"Nevertheless, here's a stab at a callback for an option with variable "
"arguments::"
msgstr ""
"En cualquier caso, aquí hay un intento de una retrollamada para una opción "
"con un número de argumentos variable::"

#: ../Doc/library/optparse.rst:1842
msgid "Extending :mod:`optparse`"
msgstr "Extendiendo el módulo :mod:`optparse`"

#: ../Doc/library/optparse.rst:1844
msgid ""
"Since the two major controlling factors in how :mod:`optparse` interprets "
"command-line options are the action and type of each option, the most likely "
"direction of extension is to add new actions and new types."
msgstr ""
"Dado que los dos factores principales que controlan como el módulo :mod:"
"`optparse` interpreta las opciones de la línea de comandos son la acción y "
"el tipo de cada opción, los objetivos más probables de extensión son agregar "
"nuevas acciones y nuevos tipos."

#: ../Doc/library/optparse.rst:1852
msgid "Adding new types"
msgstr "Agregando nuevos tipos"

#: ../Doc/library/optparse.rst:1854
msgid ""
"To add new types, you need to define your own subclass of :mod:`optparse`'s :"
"class:`Option` class.  This class has a couple of attributes that define :"
"mod:`optparse`'s types: :attr:`~Option.TYPES` and :attr:`~Option."
"TYPE_CHECKER`."
msgstr ""
"Para añadir nuevos tipos, necesitas definir tu propia subclase de la clase :"
"class:`Option` de :mod:`optparse`. Esta clase tiene un par de atributos que "
"definen los tipos de :mod:`optparse`: :attr:`~Option.TYPES` y :attr:`~Option."
"TYPE_CHECKER`."

#: ../Doc/library/optparse.rst:1860
msgid ""
"A tuple of type names; in your subclass, simply define a new tuple :attr:"
"`TYPES` that builds on the standard one."
msgstr ""
"Una tupla con nombres de tipos. En tu subclase, simplemente define una nueva "
"tupla :attr:`TYPES` que se base en la estándar."

#: ../Doc/library/optparse.rst:1865
msgid ""
"A dictionary mapping type names to type-checking functions.  A type-checking "
"function has the following signature::"
msgstr ""
"Un diccionario que asigna nombres de tipos a funciones de verificación de "
"tipo. Una función de verificación de tipo tiene la siguiente firma:"

#: ../Doc/library/optparse.rst:1870
msgid ""
"where ``option`` is an :class:`Option` instance, ``opt`` is an option string "
"(e.g., ``-f``), and ``value`` is the string from the command line that must "
"be checked and converted to your desired type.  ``check_mytype()`` should "
"return an object of the hypothetical type ``mytype``.  The value returned by "
"a type-checking function will wind up in the OptionValues instance returned "
"by :meth:`OptionParser.parse_args`, or be passed to a callback as the "
"``value`` parameter."
msgstr ""
"donde ``option`` es una instancia de :class:`Option`, ``opt`` es una cadena "
"de opción (por ejemplo, ``-f``) y ``value`` es la cadena de caracteres de la "
"línea de comandos que debe comprobarse y convertirse al tipo deseado. "
"``check_mytype()`` debería retornar un objeto del tipo hipotético "
"``mytype``. El valor retornado por una función de verificación de tipo "
"terminará formando parte de la instancia de OptionValues retornada por el "
"método :meth:`OptionParser.parse_args` o será pasada a una retrollamada como "
"parámetro ``value``."

#: ../Doc/library/optparse.rst:1878
msgid ""
"Your type-checking function should raise :exc:`OptionValueError` if it "
"encounters any problems.  :exc:`OptionValueError` takes a single string "
"argument, which is passed as-is to :class:`OptionParser`'s :meth:`error` "
"method, which in turn prepends the program name and the string ``\"error:"
"\"`` and prints everything to stderr before terminating the process."
msgstr ""
"Tu función de verificación de tipo debería lanzar una excepción :exc:"
"`OptionValueError` si encuentra algún problema. :exc:`OptionValueError` toma "
"una cadena de caracteres como único argumento, que es pasada tal cual al "
"método :meth:`error` de la clase :class:`OptionParser`, que a su vez "
"antepone a la misma el nombre del programa y la cadena ``\"error:\"`` e "
"imprime todo en la salida de error estándar antes de finalizar el proceso."

#: ../Doc/library/optparse.rst:1884
msgid ""
"Here's a silly example that demonstrates adding a ``\"complex\"`` option "
"type to parse Python-style complex numbers on the command line.  (This is "
"even sillier than it used to be, because :mod:`optparse` 1.3 added built-in "
"support for complex numbers, but never mind.)"
msgstr ""
"Aquí hay un ejemplo absurdo que demuestra cómo agregar un tipo de opción "
"``\"complex\"`` para analizar números complejos al estilo Python en la línea "
"de comandos. (Esto es aún más absurdo de lo que en principio parece, porque "
"en al versión 1.3 de :mod:`optparse` se agregó soporte incorporado para "
"números complejos, pero no importa)."

#: ../Doc/library/optparse.rst:1889
msgid "First, the necessary imports::"
msgstr "Primero, las importaciones necesarias::"

#: ../Doc/library/optparse.rst:1894
msgid ""
"You need to define your type-checker first, since it's referred to later (in "
"the :attr:`~Option.TYPE_CHECKER` class attribute of your Option subclass)::"
msgstr ""
"En primer lugar, debes definir tu verificador de tipo, ya que se hace "
"referencia a él más adelante (en el atributo de clase :attr:`~Option."
"TYPE_CHECKER` de tu subclase de Option)::"

#: ../Doc/library/optparse.rst:1904
msgid "Finally, the Option subclass::"
msgstr "Finalmente, la subclase de Option::"

#: ../Doc/library/optparse.rst:1911
msgid ""
"(If we didn't make a :func:`copy` of :attr:`Option.TYPE_CHECKER`, we would "
"end up modifying the :attr:`~Option.TYPE_CHECKER` attribute of :mod:"
"`optparse`'s Option class.  This being Python, nothing stops you from doing "
"that except good manners and common sense.)"
msgstr ""
"(Si no hacemos una copia (mediante :func:`copy`), de :attr:`Option."
"TYPE_CHECKER`, terminaríamos modificando el atributo :attr:`~Option."
"TYPE_CHECKER` de la clase Option de :mod:`optparse`. Tratándose de Python, "
"nada te impide hacer eso, excepto los buenos modales y el sentido común.)"

#: ../Doc/library/optparse.rst:1916
msgid ""
"That's it!  Now you can write a script that uses the new option type just "
"like any other :mod:`optparse`\\ -based script, except you have to instruct "
"your OptionParser to use MyOption instead of Option::"
msgstr ""
"¡Y eso es todo! Ahora puedes escribir un script que use tu nuevo tipo de "
"opción como cualquier otro script basado en :mod:`optparse`, excepto que "
"debes indicarle a tu OptionParser que use MyOption en lugar de Option::"

#: ../Doc/library/optparse.rst:1923
msgid ""
"Alternately, you can build your own option list and pass it to OptionParser; "
"if you don't use :meth:`add_option` in the above way, you don't need to tell "
"OptionParser which option class to use::"
msgstr ""
"Alternativamente, puedes crear tu propia lista de opciones y pasarla a "
"OptionParser; si no usas :meth:`add_option` de la manera anterior, no "
"necesitas decirle a OptionParser qué clase de opción usar::"

#: ../Doc/library/optparse.rst:1934
msgid "Adding new actions"
msgstr "Agregando nuevas acciones"

#: ../Doc/library/optparse.rst:1936
msgid ""
"Adding new actions is a bit trickier, because you have to understand that :"
"mod:`optparse` has a couple of classifications for actions:"
msgstr ""
"Agregar nuevas acciones es un poco más complicado, dado que hay que "
"comprender que :mod:`optparse` establece un par de categorías para las "
"acciones:"

#: ../Doc/library/optparse.rst:1942
msgid "\"store\" actions"
msgstr "Acciones \"store\""

#: ../Doc/library/optparse.rst:1940
msgid ""
"actions that result in :mod:`optparse` storing a value to an attribute of "
"the current OptionValues instance; these options require a :attr:`~Option."
"dest` attribute to be supplied to the Option constructor."
msgstr ""
"acciones que dan como resultado que :mod:`optparse` almacene un valor en un "
"atributo de la instancia actual de OptionValues. Estas opciones requieren un "
"atributo :attr:`~Option.dest` para que pueda ser proporcionado al "
"constructor de Option."

#: ../Doc/library/optparse.rst:1948
msgid "\"typed\" actions"
msgstr "Acciones \"typed\""

#: ../Doc/library/optparse.rst:1945
msgid ""
"actions that take a value from the command line and expect it to be of a "
"certain type; or rather, a string that can be converted to a certain type. "
"These options require a :attr:`~Option.type` attribute to the Option "
"constructor."
msgstr ""
"acciones que toman un valor de la línea de comandos, esperando que sea de "
"cierto tipo; o mejor dicho, una cadena de caracteres que se pueda convertir "
"a un determinado tipo. Estas opciones requieren un atributo :attr:`~Option."
"type` para el constructor de Option."

#: ../Doc/library/optparse.rst:1950
msgid ""
"These are overlapping sets: some default \"store\" actions are "
"``\"store\"``, ``\"store_const\"``, ``\"append\"``, and ``\"count\"``, while "
"the default \"typed\" actions are ``\"store\"``, ``\"append\"``, and "
"``\"callback\"``."
msgstr ""
"Ambas categorías se solapan entre si: algunas acciones ``store`` "
"predeterminadas son ``\"store\"``, ``\"store_const\"``, ``\"append\"`` y "
"``\"count\"``, mientras que las acciones \"typed\" predeterminadas son "
"``\"store\"``, ``\"append\"`` y ``\"callback\"``."

#: ../Doc/library/optparse.rst:1954
msgid ""
"When you add an action, you need to categorize it by listing it in at least "
"one of the following class attributes of Option (all are lists of strings):"
msgstr ""
"Cuando agregas una acción, debes categorizarla enumerándola en al menos uno "
"de los siguientes atributos de clase de la clase Option (todos ellos son "
"listas de cadenas de caracteres):"

#: ../Doc/library/optparse.rst:1959
msgid "All actions must be listed in ACTIONS."
msgstr "Todas las acciones deben aparecer en ACTIONS."

#: ../Doc/library/optparse.rst:1963
msgid "\"store\" actions are additionally listed here."
msgstr "Las acciones \"store\" también se enumeran aquí."

#: ../Doc/library/optparse.rst:1967
msgid "\"typed\" actions are additionally listed here."
msgstr "Las acciones \"typed\" también se enumeran aquí."

#: ../Doc/library/optparse.rst:1971
msgid ""
"Actions that always take a type (i.e. whose options always take a value) are "
"additionally listed here.  The only effect of this is that :mod:`optparse` "
"assigns the default type, ``\"string\"``, to options with no explicit type "
"whose action is listed in :attr:`ALWAYS_TYPED_ACTIONS`."
msgstr ""
"Las acciones que siempre toman un tipo (es decir, aquellas cuyas opciones "
"siempre toman un valor) también deben enumerarse aquí. La única consecuencia "
"de esto es que :mod:`optparse` asigna el tipo predeterminado, ``string``, a "
"las opciones cuya acción se enumera en :attr:`ALWAYS_TYPED_ACTIONS` pero que "
"no tienen asignado un tipo explícito."

#: ../Doc/library/optparse.rst:1976
msgid ""
"In order to actually implement your new action, you must override Option's :"
"meth:`take_action` method and add a case that recognizes your action."
msgstr ""
"Para implementar realmente tu nueva acción, debes redefinir el método :meth:"
"`take_action` de Option, implementando un nuevo método que reconozca tu "
"acción."

#: ../Doc/library/optparse.rst:1979
msgid ""
"For example, let's add an ``\"extend\"`` action.  This is similar to the "
"standard ``\"append\"`` action, but instead of taking a single value from "
"the command-line and appending it to an existing list, ``\"extend\"`` will "
"take multiple values in a single comma-delimited string, and extend an "
"existing list with them.  That is, if ``--names`` is an ``\"extend\"`` "
"option of type ``\"string\"``, the command line ::"
msgstr ""
"Por ejemplo, agreguemos una nueva acción ``\"extend\"``. Esta es similar a "
"la acción estándar ``\"append\"``, pero en lugar de tomar un solo valor de "
"la línea de comandos y agregarlo a una lista existente, ``\"extend\"`` "
"tomará múltiples valores en una sola cadena de caracteres delimitada por "
"comas y amplía una lista previamente existente con ellos. Es decir, si ``--"
"names`` es una opción ``\"extend\"`` de tipo ``\"string\"``, la línea de "
"comandos ::"

#: ../Doc/library/optparse.rst:1988
msgid "would result in a list  ::"
msgstr "daría como resultado una lista como la siguiente::"

#: ../Doc/library/optparse.rst:1992
msgid "Again we define a subclass of Option::"
msgstr "De nuevo, definimos una subclase de Option::"

#: ../Doc/library/optparse.rst:2009
msgid "Features of note:"
msgstr "Detalles a tener en cuenta:"

#: ../Doc/library/optparse.rst:2011
msgid ""
"``\"extend\"`` both expects a value on the command-line and stores that "
"value somewhere, so it goes in both :attr:`~Option.STORE_ACTIONS` and :attr:"
"`~Option.TYPED_ACTIONS`."
msgstr ""
"``\"extend\"`` espera un valor en la línea de comandos y también almacena "
"ese valor en algún lugar, por lo que lo agregamos tanto a :attr:`~Option."
"STORE_ACTIONS` como a :attr:`~Option.TYPED_ACTIONS`."

#: ../Doc/library/optparse.rst:2015
msgid ""
"to ensure that :mod:`optparse` assigns the default type of ``\"string\"`` to "
"``\"extend\"`` actions, we put the ``\"extend\"`` action in :attr:`~Option."
"ALWAYS_TYPED_ACTIONS` as well."
msgstr ""
"para asegurarnos de que :mod:`optparse` asigna el tipo predeterminado "
"``\"string\"`` a las acciones ``\"extend\"``, agregamos también la acción "
"``\"extend\"`` a :attr:`~Opción.ALWAYS_TYPED_ACTIONS`."

#: ../Doc/library/optparse.rst:2019
msgid ""
":meth:`MyOption.take_action` implements just this one new action, and passes "
"control back to :meth:`Option.take_action` for the standard :mod:`optparse` "
"actions."
msgstr ""
"el método :meth:`MyOption.take_action` solo se encarga de implementar esta "
"nueva acción y posteriormente le pasa el control al método :meth:`Option."
"take_action` para las acciones estándar de :mod:`optparse`."

#: ../Doc/library/optparse.rst:2023
msgid ""
"``values`` is an instance of the optparse_parser.Values class, which "
"provides the very useful :meth:`ensure_value` method. :meth:`ensure_value` "
"is essentially :func:`getattr` with a safety valve; it is called as ::"
msgstr ""
"``values`` es una instancia de la clase *optparse_parser.Values*, que "
"proporciona el útil método :meth:`ensure_value`. El método :meth:"
"`ensure_value` es en esencia lo mismo que :func:`getattr` pero con un "
"mecanismo de seguridad agregado. Es llamado como::"

#: ../Doc/library/optparse.rst:2029
msgid ""
"If the ``attr`` attribute of ``values`` doesn't exist or is ``None``, then "
"ensure_value() first sets it to ``value``, and then returns 'value. This is "
"very handy for actions like ``\"extend\"``, ``\"append\"``, and "
"``\"count\"``, all of which accumulate data in a variable and expect that "
"variable to be of a certain type (a list for the first two, an integer for "
"the latter).  Using :meth:`ensure_value` means that scripts using your "
"action don't have to worry about setting a default value for the option "
"destinations in question; they can just leave the default as ``None`` and :"
"meth:`ensure_value` will take care of getting it right when it's needed."
msgstr ""
"Si el atributo ``attr`` de ``values`` no existe o es ``None``, entonces "
"*ensure_value()* primero lo establece en ``value`` y luego retorna el "
"atributo actualizado. Esto es muy útil para acciones como ``\"extend\"``, "
"``\"append\"`` y ``\"count\"``, dado que todas ellas acumulan datos en una "
"variable y esperan que esa variable sea de cierto tipo (una lista para las "
"dos primeras, un número entero para la última). Usar el método :meth:"
"`ensure_value` significa que los scripts que usan tu acción no tienen que "
"preocuparse por establecer un valor predeterminado para los destinos de "
"opción en cuestión; simplemente pueden dejar el valor predeterminado como "
"``None`` y :meth:`secure_value` se encargará de que todo esté correcto "
"cuando sea necesario."