argparse
— Parser for command-line options, arguments and subcommands¶
Added in version 3.2.
Código fuente: Lib/argparse.py
The argparse
module makes it easy to write user-friendly command-line
interfaces. The program defines what arguments it requires, and argparse
will figure out how to parse those out of sys.argv
. The argparse
module also automatically generates help and usage messages. The module
will also issue errors when users give the program invalid arguments.
The argparse
module’s support for command-line interfaces is built
around an instance of argparse.ArgumentParser
. It is a container for
argument specifications and has options that apply to the parser as whole:
parser = argparse.ArgumentParser(
prog='ProgramName',
description='What the program does',
epilog='Text at the bottom of help')
El método ArgumentParser.add_argument()
adjunta especificaciones de argumentos individuales al analizador. Soporta argumentos posicionales, opciones que aceptan valores, y banderas de activación y desactivación:
parser.add_argument('filename') # positional argument
parser.add_argument('-c', '--count') # option that takes a value
parser.add_argument('-v', '--verbose',
action='store_true') # on/off flag
El método ArgumentParser.parse_args()
corre el analizador y coloca los datos extraídos en un objeto argparse.Namespace
:
args = parser.parse_args()
print(args.filename, args.count, args.verbose)
Nota
If you’re looking a guide about how to upgrade optparse code to argparse, see Upgrading Optparse Code.
Objetos ArgumentParser¶
- class argparse.ArgumentParser(prog=None, usage=None, description=None, epilog=None, parents=[], formatter_class=argparse.HelpFormatter, prefix_chars='-', fromfile_prefix_chars=None, argument_default=None, conflict_handler='error', add_help=True, allow_abbrev=True, exit_on_error=True)¶
Crea un nuevo objeto
ArgumentParser
. Todos los parámetros deben pasarse como argumentos de palabra clave. Cada parámetro tiene su propia descripción más detallada a continuación, pero en resumen son:prog - El nombre del programa (default:
os.path.basename(sys.argv[0])
)usage - La cadena de caracteres que describe el uso del programa (por defecto: generado a partir de los argumentos añadidos al analizador)
description - Text to display before the argument help (by default, no text)
epilog - Text to display after the argument help (by default, no text)
parents - Una lista de objetos
ArgumentParser
cuyos argumentos también deberían ser incluidosformatter_class - Una clase para personalizar la salida de la ayuda
prefix_chars - El conjunto de caracteres que preceden a los argumentos opcionales (por defecto: ‘-‘)
fromfile_prefix_chars - El conjunto de caracteres que preceden a los archivos de los cuales se deberían leer los argumentos adicionales (por defecto:
None
)argument_default - El valor global por defecto de los argumentos (por defecto:
None
)conflict_handler - La estrategia para resolver los opcionales conflictivos (normalmente es innecesaria)
add_help - Añade una opción
-h/--help
al analizador (por defecto:True
)allow_abbrev - Permite abreviar las opciones largas si la abreviatura es inequívoca. (por defecto:
True
)exit_on_error - Determina si ArgumentParser sale o no con información de error cuando se produce un error. (predeterminado:
True
)
Distinto en la versión 3.5: se añadió el parámetro allow_abbrev.
Distinto en la versión 3.8: En versiones anteriores, allow_abbrev también deshabilitaba la agrupación de banderas (flags) cortas como
-vv
para que sea-v -v
.Distinto en la versión 3.9: Se agregó el parámetro exit_on_error.
En las siguientes secciones se describe cómo se utiliza cada una de ellas.
prog¶
By default, ArgumentParser
calculates the name of the program
to display in help messages depending on the way the Python interpreter was run:
The
base name
ofsys.argv[0]
if a file was passed as argument.The Python interpreter name followed by
sys.argv[0]
if a directory or a zipfile was passed as argument.The Python interpreter name followed by
-m
followed by the module or package name if the-m
option was used.
This default is almost always desirable because it will make the help messages
match the string that was used to invoke the program on the command line.
However, to change this default behavior, another value can be supplied using
the prog=
argument to ArgumentParser
:
>>> parser = argparse.ArgumentParser(prog='myprogram')
>>> parser.print_help()
usage: myprogram [-h]
options:
-h, --help show this help message and exit
Ten en cuenta que el nombre del programa, ya sea determinado a partir de sys.argv[0]
o del argumento prog=
, está disponible para los mensajes de ayuda usando el especificador de formato %(prog)s
.
>>> parser = argparse.ArgumentParser(prog='myprogram')
>>> parser.add_argument('--foo', help='foo of the %(prog)s program')
>>> parser.print_help()
usage: myprogram [-h] [--foo FOO]
options:
-h, --help show this help message and exit
--foo FOO foo of the myprogram program
uso¶
By default, ArgumentParser
calculates the usage message from the
arguments it contains. The default message can be overridden with the
usage=
keyword argument:
>>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')
>>> parser.add_argument('--foo', nargs='?', help='foo help')
>>> parser.add_argument('bar', nargs='+', help='bar help')
>>> parser.print_help()
usage: PROG [options]
positional arguments:
bar bar help
options:
-h, --help show this help message and exit
--foo [FOO] foo help
El especificador de formato %(prog)s
está preparado para introducir el nombre del programa en los mensajes de ayuda.
description¶
Most calls to the ArgumentParser
constructor will use the
description=
keyword argument. This argument gives a brief description of
what the program does and how it works. In help messages, the description is
displayed between the command-line usage string and the help messages for the
various arguments.
Por defecto, la descripción será ajustada a una línea para que encaje en el espacio dado. Para cambiar este comportamiento, revisa el argumento formatter_class.
epilog¶
A algunos programas les gusta mostrar una descripción adicional del programa después de la descripción de los argumentos. Dicho texto puede ser especificado usando el argumento epilog=
para ArgumentParser
:
>>> parser = argparse.ArgumentParser(
... description='A foo that bars',
... epilog="And that's how you'd foo a bar")
>>> parser.print_help()
usage: argparse.py [-h]
A foo that bars
options:
-h, --help show this help message and exit
And that's how you'd foo a bar
Al igual que con el argumento description, el texto epilog=
está por defecto ajustado a una línea, pero este comportamiento puede ser modificado con el argumento formatter_class para ArgumentParser
.
parents¶
A veces, varios analizadores comparten un conjunto de argumentos comunes. En lugar de repetir las definiciones de estos argumentos, se puede usar un único analizador con todos los argumentos compartidos y pasarlo en el argumento parents=
a ArgumentParser
. El argumento parents=
toma una lista de objetos ArgumentParser
, recoge todas las acciones de posición y de opción de éstos, y añade estas acciones al objeto ArgumentParser
que se está construyendo:
>>> parent_parser = argparse.ArgumentParser(add_help=False)
>>> parent_parser.add_argument('--parent', type=int)
>>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])
>>> foo_parser.add_argument('foo')
>>> foo_parser.parse_args(['--parent', '2', 'XXX'])
Namespace(foo='XXX', parent=2)
>>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])
>>> bar_parser.add_argument('--bar')
>>> bar_parser.parse_args(['--bar', 'YYY'])
Namespace(bar='YYY', parent=None)
Ten en cuenta que la mayoría de los analizadores padre especificarán add_help=False
. De lo contrario, el ArgumentParser
verá dos opciones -h/—help
(una para el padre y otra para el hijo) y generará un error.
Nota
Debes inicializar completamente los analizadores antes de pasarlos a través de parents=
. Si cambias los analizadores padre después del analizador hijo, esos cambios no se reflejarán en el hijo.
formatter_class¶
Los objetos ArgumentParser
permiten personalizar el formato de la ayuda especificando una clase de formato alternativa. Actualmente, hay cuatro clases de este tipo:
- class argparse.RawDescriptionHelpFormatter¶
- class argparse.RawTextHelpFormatter¶
- class argparse.ArgumentDefaultsHelpFormatter¶
- class argparse.MetavarTypeHelpFormatter¶
RawDescriptionHelpFormatter
y RawTextHelpFormatter
dan más control sobre cómo se muestran las descripciones de texto. Por defecto, los objetos ArgumentParser
ajustan a la línea los textos de description y epilog en los mensajes de ayuda de la línea de comandos:
>>> parser = argparse.ArgumentParser(
... prog='PROG',
... description='''this description
... was indented weird
... but that is okay''',
... epilog='''
... likewise for this epilog whose whitespace will
... be cleaned up and whose words will be wrapped
... across a couple lines''')
>>> parser.print_help()
usage: PROG [-h]
this description was indented weird but that is okay
options:
-h, --help show this help message and exit
likewise for this epilog whose whitespace will be cleaned up and whose words
will be wrapped across a couple lines
Pasar RawDescriptionHelpFormatter
como formatter_class=
indica que description y epilog ya tienen el formato correcto y no deben ser ajustados a la línea:
>>> parser = argparse.ArgumentParser(
... prog='PROG',
... formatter_class=argparse.RawDescriptionHelpFormatter,
... description=textwrap.dedent('''\
... Please do not mess up this text!
... --------------------------------
... I have indented it
... exactly the way
... I want it
... '''))
>>> parser.print_help()
usage: PROG [-h]
Please do not mess up this text!
--------------------------------
I have indented it
exactly the way
I want it
options:
-h, --help show this help message and exit
RawTextHelpFormatter
maintains whitespace for all sorts of help text,
including argument descriptions. However, multiple newlines are replaced with
one. If you wish to preserve multiple blank lines, add spaces between the
newlines.
ArgumentDefaultsHelpFormatter
añade automáticamente información sobre los valores por defecto a cada uno de los mensajes de ayuda de los argumentos:
>>> parser = argparse.ArgumentParser(
... prog='PROG',
... formatter_class=argparse.ArgumentDefaultsHelpFormatter)
>>> parser.add_argument('--foo', type=int, default=42, help='FOO!')
>>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')
>>> parser.print_help()
usage: PROG [-h] [--foo FOO] [bar ...]
positional arguments:
bar BAR! (default: [1, 2, 3])
options:
-h, --help show this help message and exit
--foo FOO FOO! (default: 42)
MetavarTypeHelpFormatter
utiliza el nombre del parámetro type para cada argumento como el nombre a mostrar para sus valores (en lugar de utilizar dest como lo hace el formato habitual):
>>> parser = argparse.ArgumentParser(
... prog='PROG',
... formatter_class=argparse.MetavarTypeHelpFormatter)
>>> parser.add_argument('--foo', type=int)
>>> parser.add_argument('bar', type=float)
>>> parser.print_help()
usage: PROG [-h] [--foo int] float
positional arguments:
float
options:
-h, --help show this help message and exit
--foo int
prefix_chars¶
La mayoría de las opciones de la línea de comandos usarán -
como prefijo, por ejemplo -f/--foo
. Los analizadores que necesiten soportar caracteres prefijo diferentes o adicionales, por ejemplo, para opciones como +f
o /foo
, pueden especificarlos usando el argumento prefix_chars=
para el constructor ArgumentParser:
>>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')
>>> parser.add_argument('+f')
>>> parser.add_argument('++bar')
>>> parser.parse_args('+f X ++bar Y'.split())
Namespace(bar='Y', f='X')
El argumento prefix_chars=
tiene un valor por defecto de '-'
. Proporcionar un conjunto de caracteres que no incluya -
causará que las opciones -f/--foo
no sean inhabilitadas.
fromfile_prefix_chars¶
Algunas veces, cuando se trata de una lista de argumentos particularmente larga, puede tener sentido mantener la lista de argumentos en un archivo en lugar de escribirla en la línea de comandos. Si el argumento fromfile_prefix_chars=
se da al constructor ArgumentParser
, entonces los argumentos que empiezan con cualquiera de los caracteres especificados se tratarán como archivos, y serán reemplazados por los argumentos que contienen. Por ejemplo:
>>> with open('args.txt', 'w', encoding=sys.getfilesystemencoding()) as fp:
... fp.write('-f\nbar')
...
>>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')
>>> parser.add_argument('-f')
>>> parser.parse_args(['-f', 'foo', '@args.txt'])
Namespace(f='bar')
Los argumentos leídos de un archivo deben ser por defecto uno por línea (pero vea también convert_arg_line_to_args()
) y se tratan como si estuvieran en el mismo lugar que el argumento de referencia del archivo original en la línea de comandos. Así, en el ejemplo anterior, la expresión [‘-f’, ‘foo’, ‘@args.txt’]
se considera equivalente a la expresión [‘-f’, ‘foo’, ‘-f’, ‘bar’]
.
ArgumentParser
uses filesystem encoding and error handler
to read the file containing arguments.
El argumento fromfile_prefix_chars=
por defecto es None
, lo que significa que los argumentos nunca serán tratados como referencias de archivos.
Distinto en la versión 3.12: ArgumentParser
changed encoding and errors to read arguments files
from default (e.g. locale.getpreferredencoding(False)
and "strict"
) to the filesystem encoding and error handler.
Arguments file should be encoded in UTF-8 instead of ANSI Codepage on Windows.
argument_default¶
Generalmente, los valores por defecto de los argumentos se especifican ya sea pasando un valor por defecto a add_argument()
o llamando a los métodos set_defaults()
con un conjunto específico de pares nombre-valor. A veces, sin embargo, puede ser útil especificar un único valor por defecto para todos los argumentos del analizador. Esto se puede lograr pasando el argumento de palabra clave argument_default=
a ArgumentParser
. Por ejemplo, para suprimir globalmente la creación de atributos en las llamadas a parse_args()
, proporcionamos el argumento argument_default=SUPPRESS
:
>>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)
>>> parser.add_argument('--foo')
>>> parser.add_argument('bar', nargs='?')
>>> parser.parse_args(['--foo', '1', 'BAR'])
Namespace(bar='BAR', foo='1')
>>> parser.parse_args([])
Namespace()
allow_abbrev¶
Normalmente, cuando pasas una lista de argumentos al método parse_args()
de un ArgumentParser
, reconoce las abreviaturas de las opciones largas.
Esta característica puede ser desactivada poniendo allow_abbrev
a False
:
>>> parser = argparse.ArgumentParser(prog='PROG', allow_abbrev=False)
>>> parser.add_argument('--foobar', action='store_true')
>>> parser.add_argument('--foonley', action='store_false')
>>> parser.parse_args(['--foon'])
usage: PROG [-h] [--foobar] [--foonley]
PROG: error: unrecognized arguments: --foon
Added in version 3.5.
conflict_handler¶
Los objetos ArgumentParser
no permiten dos acciones con la misma cadena de caracteres de opción. Por defecto, los objetos ArgumentParser
lanzan una excepción si se intenta crear un argumento con una cadena de caracteres de opción que ya está en uso:
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-f', '--foo', help='old foo help')
>>> parser.add_argument('--foo', help='new foo help')
Traceback (most recent call last):
..
ArgumentError: argument --foo: conflicting option string(s): --foo
A veces (por ejemplo, cuando se utiliza parents) puede ser útil anular simplemente cualquier argumento antiguo con la misma cadena de caracteres de opción. Para lograr este comportamiento, se puede suministrar el valor 'resolve'
al argumento conflict_handler=
de ArgumentParser
:
>>> parser = argparse.ArgumentParser(prog='PROG', conflict_handler='resolve')
>>> parser.add_argument('-f', '--foo', help='old foo help')
>>> parser.add_argument('--foo', help='new foo help')
>>> parser.print_help()
usage: PROG [-h] [-f FOO] [--foo FOO]
options:
-h, --help show this help message and exit
-f FOO old foo help
--foo FOO new foo help
Ten en cuenta que los objetos ArgumentParser
sólo eliminan una acción si todas sus cadenas de caracteres de opción están anuladas. Así, en el ejemplo anterior, la antigua acción -f/--foo
se mantiene como la acción -f
, porque sólo la cadena de caracteres de opción --foo
fue anulada.
add_help¶
By default, ArgumentParser objects add an option which simply displays
the parser’s help message. If -h
or --help
is supplied at the command
line, the ArgumentParser help will be printed.
Ocasionalmente, puede ser útil desactivar la inclusión de esta opción de ayuda. Esto se puede lograr pasando False
como argumento de add_help=
a ArgumentParser
:
>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)
>>> parser.add_argument('--foo', help='foo help')
>>> parser.print_help()
usage: PROG [--foo FOO]
options:
--foo FOO foo help
La opción de ayuda es típicamente -h/--help
. La excepción a esto es si prefix_chars=
se especifica y no incluye -
, en cuyo caso -h
y --help
no son opciones válidas. En este caso, el primer carácter en prefix_chars
se utiliza para preceder a las opciones de ayuda:
>>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='+/')
>>> parser.print_help()
usage: PROG [+h]
options:
+h, ++help show this help message and exit
exit_on_error¶
Normally, when you pass an invalid argument list to the parse_args()
method of an ArgumentParser
, it will print a message to sys.stderr
and exit with a status
code of 2.
Si el usuario desea detectar errores manualmente, la función se puede habilitar configurando exit_on_error
en False
>>> parser = argparse.ArgumentParser(exit_on_error=False)
>>> parser.add_argument('--integers', type=int)
_StoreAction(option_strings=['--integers'], dest='integers', nargs=None, const=None, default=None, type=<class 'int'>, choices=None, help=None, metavar=None)
>>> try:
... parser.parse_args('--integers a'.split())
... except argparse.ArgumentError:
... print('Catching an argumentError')
...
Catching an argumentError
Added in version 3.9.
El método add_argument()¶
- ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest][, deprecated])¶
Define cómo se debe interpretar un determinado argumento de línea de comandos. Cada parámetro tiene su propia descripción más detallada a continuación, pero en resumen son:
name or flags - Ya sea un nombre o una lista de cadena de caracteres de opción, e.g.
foo
o-f, --foo
.action - El tipo básico de acción a tomar cuando este argumento se encuentra en la línea de comandos.
nargs - El número de argumentos de la línea de comandos que deben ser consumidos.
const - Un valor fijo requerido por algunas selecciones de action y nargs.
default - El valor producido si el argumento está ausente en la línea de comando y si está ausente en el objeto de espacio de nombres.
type - El tipo al que debe convertirse el argumento de la línea de comandos.
choices - A sequence of the allowable values for the argument.
required - Si se puede omitir o no la opción de la línea de comandos (sólo opcionales).
help - Una breve descripción de lo que hace el argumento.
metavar - Un nombre para el argumento en los mensajes de uso.
dest - El nombre del atributo que será añadido al objeto retornado por
parse_args()
.deprecated - Whether or not use of the argument is deprecated.
En las siguientes secciones se describe cómo se utiliza cada una de ellas.
name or flags¶
El método add_argument()
debe saber si espera un argumento opcional, como -f
o --foo
, o un argumento posicional, como una lista de nombres de archivos. Los primeros argumentos que se pasan a add_argument()
deben ser o bien una serie de banderas (flags), o un simple nombre de un argumento (name).
Por ejemplo, se puede crear un argumento opcional como:
>>> parser.add_argument('-f', '--foo')
mientras que un argumento posicional podría ser creado como:
>>> parser.add_argument('bar')
Cuando se llama a parse_args()
, los argumentos opcionales serán identificados por el prefijo -
, y el resto de los argumentos serán asumidos como posicionales:
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-f', '--foo')
>>> parser.add_argument('bar')
>>> parser.parse_args(['BAR'])
Namespace(bar='BAR', foo=None)
>>> parser.parse_args(['BAR', '--foo', 'FOO'])
Namespace(bar='BAR', foo='FOO')
>>> parser.parse_args(['--foo', 'FOO'])
usage: PROG [-h] [-f FOO] bar
PROG: error: the following arguments are required: bar
action¶
Los objetos ArgumentParser
asocian los argumentos de la línea de comandos con las acciones. Esta acciones pueden hacer casi cualquier cosa con los argumentos de línea de comandos asociados a ellas, aunque la mayoría de las acciones simplemente añaden un atributo al objeto retornado por parse_args()
. El argumento de palabra clave action
especifica cómo deben ser manejados los argumentos de la línea de comandos. Las acciones proporcionadas son:
'store'
- This just stores the argument’s value. This is the default action.'store_const'
- Esto almacena el valor especificado por el argumento de palabra clave const; nótese que el argumento de palabra clave const por defecto esNone
. La acción'store_const'
se usa comúnmente con argumentos opcionales que especifican algún tipo de indicador (flag). Por ejemplo:>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', action='store_const', const=42) >>> parser.parse_args(['--foo']) Namespace(foo=42)
'store_true'
and'store_false'
- These are special cases of'store_const'
used for storing the valuesTrue
andFalse
respectively. In addition, they create default values ofFalse
andTrue
respectively:>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', action='store_true') >>> parser.add_argument('--bar', action='store_false') >>> parser.add_argument('--baz', action='store_false') >>> parser.parse_args('--foo --bar'.split()) Namespace(foo=True, bar=False, baz=True)
'append'
- Esto almacena una lista, y añade cada valor del argumento a la lista. Es útil para permitir que una opción sea especificada varias veces. Si el valor por defecto es no vacío, los elementos por defecto estarán presentes en el valor analizado para la opción, con los valores de la línea de comandos añadidos después de los valores por defecto. Ejemplo de uso:>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', action='append') >>> parser.parse_args('--foo 1 --foo 2'.split()) Namespace(foo=['1', '2'])
'append_const'
- Esto almacena una lista, y añade los valores especificados por el argumento de palabra clave const; nótese que el argumento de palabra clave const por defecto esNone
. La acción'append_const'
es comúnmente útil cuando múltiples argumentos necesitan almacenar constantes en la misma lista. Por ejemplo:>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--str', dest='types', action='append_const', const=str) >>> parser.add_argument('--int', dest='types', action='append_const', const=int) >>> parser.parse_args('--str --int'.split()) Namespace(types=[<class 'str'>, <class 'int'>])
'extend'
- This stores a list and appends each item from the multi-value argument list to it. The'extend'
action is typically used with the nargs keyword argument value'+'
or'*'
. Note that when nargs isNone
(the default) or'?'
, each character of the argument string will be appended to the list. Example usage:>>> parser = argparse.ArgumentParser() >>> parser.add_argument("--foo", action="extend", nargs="+", type=str) >>> parser.parse_args(["--foo", "f1", "--foo", "f2", "f3", "f4"]) Namespace(foo=['f1', 'f2', 'f3', 'f4'])
Added in version 3.8.
'count'
- Esta cuenta el número de veces que un argumento de palabra clave aparece. Por ejemplo, esto es útil para incrementar los niveles de detalle:>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--verbose', '-v', action='count', default=0) >>> parser.parse_args(['-vvv']) Namespace(verbose=3)
Observa, default (el valor por defecto) será
None
a menos que explícitamente se establezca como 0.'help'
- Esta imprime un mensaje de ayuda completo para todas las opciones del analizador actual y luego termina. Por defecto, se añade una acción de ayuda automáticamente al analizador. VerArgumentParser
para detalles de cómo se genera la salida.’version’
- Esta espera un argumento de palabra claveversion=
en la llamadaadd_argument()
, e imprime la información de la versión y finaliza cuando es invocada:>>> import argparse >>> parser = argparse.ArgumentParser(prog='PROG') >>> parser.add_argument('--version', action='version', version='%(prog)s 2.0') >>> parser.parse_args(['--version']) PROG 2.0
Only actions that consume command-line arguments (e.g. 'store'
,
'append'
or 'extend'
) can be used with positional arguments.
También puede especificar una acción arbitraria pasando una subclase de Acción u otro objeto que implemente la misma interfaz. BooleanOptionalAction
está disponible en argparse
y agrega soporte para acciones booleanas como --foo
y --no-foo
:
>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action=argparse.BooleanOptionalAction)
>>> parser.parse_args(['--no-foo'])
Namespace(foo=False)
Added in version 3.9.
La forma recomendada de crear una acción personalizada es extender Action
, anulando el método __call__
y, opcionalmente, los métodos __init__
y format_usage
.
Un ejemplo de una acción personalizada:
>>> class FooAction(argparse.Action):
... def __init__(self, option_strings, dest, nargs=None, **kwargs):
... if nargs is not None:
... raise ValueError("nargs not allowed")
... super().__init__(option_strings, dest, **kwargs)
... def __call__(self, parser, namespace, values, option_string=None):
... print('%r %r %r' % (namespace, values, option_string))
... setattr(namespace, self.dest, values)
...
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action=FooAction)
>>> parser.add_argument('bar', action=FooAction)
>>> args = parser.parse_args('1 --foo 2'.split())
Namespace(bar=None, foo=None) '1' None
Namespace(bar='1', foo=None) '2' '--foo'
>>> args
Namespace(bar='1', foo='2')
Para más detalles, ver Action
.
nargs¶
ArgumentParser objects usually associate a single command-line argument with a
single action to be taken. The nargs
keyword argument associates a
different number of command-line arguments with a single action.
See also Especificando argumentos ambiguos. The supported values are:
N
(un entero).N
argumentos de la línea de comandos se agruparán en una lista. Por ejemplo:>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', nargs=2) >>> parser.add_argument('bar', nargs=1) >>> parser.parse_args('c --foo a b'.split()) Namespace(bar=['c'], foo=['a', 'b'])
Ten en cuenta que
nargs=1
produce una lista de un elemento. Esto es diferente del valor por defecto, en el que el elemento se produce por sí mismo.
’?’
. Un argumento se consumirá desde la línea de comandos si es posible, y se generará como un sólo elemento. Si no hay ningún argumento de línea de comandos, se obtendrá el valor de default. Ten en cuenta que para los argumentos opcionales, hay un caso adicional - la cadena de caracteres de opción está presente pero no va seguida de un argumento de línea de comandos. En este caso se obtendrá el valor de const. Algunos ejemplos para ilustrar esto:>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', nargs='?', const='c', default='d') >>> parser.add_argument('bar', nargs='?', default='d') >>> parser.parse_args(['XX', '--foo', 'YY']) Namespace(bar='XX', foo='YY') >>> parser.parse_args(['XX', '--foo']) Namespace(bar='XX', foo='c') >>> parser.parse_args([]) Namespace(bar='d', foo='d')
Uno de los usos más comunes de
nargs='?'
es permitir archivos de entrada y salida opcionales:>>> parser = argparse.ArgumentParser() >>> parser.add_argument('infile', nargs='?', type=argparse.FileType('r'), ... default=sys.stdin) >>> parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'), ... default=sys.stdout) >>> parser.parse_args(['input.txt', 'output.txt']) Namespace(infile=<_io.TextIOWrapper name='input.txt' encoding='UTF-8'>, outfile=<_io.TextIOWrapper name='output.txt' encoding='UTF-8'>) >>> parser.parse_args([]) Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>, outfile=<_io.TextIOWrapper name='<stdout>' encoding='UTF-8'>)
’*’
. Todos los argumentos presentes en la línea de comandos se recogen en una lista. Ten en cuenta que generalmente no tiene mucho sentido tener más de un argumento posicional connargs=‘*’
, pero es posible tener múltiples argumentos opcionales connargs=‘*’
. Por ejemplo:>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', nargs='*') >>> parser.add_argument('--bar', nargs='*') >>> parser.add_argument('baz', nargs='*') >>> parser.parse_args('a b --foo x y --bar 1 2'.split()) Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])
'+'
. Al igual que'*'
, todos los argumentos de la línea de comandos se recogen en una lista. Además, se generará un mensaje de error si no había al menos un argumento presente en la línea de comandos. Por ejemplo:>>> parser = argparse.ArgumentParser(prog='PROG') >>> parser.add_argument('foo', nargs='+') >>> parser.parse_args(['a', 'b']) Namespace(foo=['a', 'b']) >>> parser.parse_args([]) usage: PROG [-h] foo [foo ...] PROG: error: the following arguments are required: foo
If the nargs
keyword argument is not provided, the number of arguments consumed
is determined by the action. Generally this means a single command-line argument
will be consumed and a single item (not a list) will be produced.
Actions that do not consume command-line arguments (e.g.
'store_const'
) set nargs=0
.
const¶
El argumento const
de add_argument()
se usa para mantener valores constantes que no se leen desde la línea de comandos pero que son necesarios para las diversas acciones de ArgumentParser
. Los dos usos más comunes son:
Cuando
add_argument()
es llamado conaction='store_const'
oaction='append_const'
. Estas acciones añaden el valorconst
a uno de los atributos del objeto retornado porparse_args()
. Mira la descripción action para ver ejemplos. Siconst
no es proporcionado aadd_argument()
, este recibirá el valor por defectoNone
.Cuando
add_argument()
es llamado con las cadenas de opción (como-f
o—foo
) ynargs=‘?’
. Esto crea un argumento opcional que puede ir seguido de cero o un argumento de línea de comandos. Al analizar la línea de comandos, si la cadena de opciones se encuentra sin ningún argumento de línea de comandos que la siga, asumirá en su lugar el valor deconst
. Mira la descripción nargs para ejemplos.
Distinto en la versión 3.11: Por defecto const=None
, incluyendo cuando action='append_const'
o action='store_const'
.
default¶
Todos los argumentos opcionales y algunos argumentos posicionales pueden ser omitidos en la línea de comandos. El argumento de palabra clave default
de add_argument()
, cuyo valor por defecto es None
, especifica qué valor debe usarse si el argumento de línea de comandos no está presente. Para los argumentos opcionales, se usa el valor default
cuando la cadena de caracteres de opción no está presente en la línea de comandos:
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', default=42)
>>> parser.parse_args(['--foo', '2'])
Namespace(foo='2')
>>> parser.parse_args([])
Namespace(foo=42)
If the target namespace already has an attribute set, the action default will not overwrite it:
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', default=42)
>>> parser.parse_args([], namespace=argparse.Namespace(foo=101))
Namespace(foo=101)
Si el valor default
es una cadena de caracteres, el analizador procesa el valor como si fuera un argumento de la línea de comandos. En particular, el analizador aplica cualquier argumento de conversión type , si se proporciona, antes de establecer el atributo en el valor de retorno Namespace
. En caso contrario, el analizador utiliza el valor tal y como es:
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--length', default='10', type=int)
>>> parser.add_argument('--width', default=10.5, type=int)
>>> parser.parse_args()
Namespace(length=10, width=10.5)
Para argumentos posiciones con nargs igual a ?
o *
, el valor default
se utiliza cuando no hay ningún argumento de línea de comandos presente:
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('foo', nargs='?', default=42)
>>> parser.parse_args(['a'])
Namespace(foo='a')
>>> parser.parse_args([])
Namespace(foo=42)
For required arguments, the default
value is ignored. For example, this
applies to positional arguments with nargs values other than ?
or *
,
or optional arguments marked as required=True
.
Proporcionar default=argparse.SUPPRESS
causa que no se agregue ningún atributo si el argumento de la línea de comandos no está presente:
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', default=argparse.SUPPRESS)
>>> parser.parse_args([])
Namespace()
>>> parser.parse_args(['--foo', '1'])
Namespace(foo='1')
type¶
De forma predeterminada, el analizador lee los argumentos de la línea de comandos como cadenas simples. Sin embargo, a menudo, la cadena de la línea de comandos debe interpretarse como otro tipo, como float
o int
. La palabra clave type
para add_argument()
permite realizar cualquier verificación de tipo y conversión de tipo necesaria.
Si la palabra clave type se usa con la palabra clave default, el convertidor de tipos solo se aplica si el valor predeterminado es una cadena de caracteres.
El argumento para type
puede ser cualquier invocable que acepte una sola cadena de caracteres. Si la función lanza ArgumentTypeError
, TypeError
, o ValueError
, se detecta la excepción y se muestra un mensaje de error con un formato agradable. No se manejan otros tipos de excepciones.
Los tipos y funciones incorporados comunes se pueden utilizar como convertidores de tipos:
import argparse
import pathlib
parser = argparse.ArgumentParser()
parser.add_argument('count', type=int)
parser.add_argument('distance', type=float)
parser.add_argument('street', type=ascii)
parser.add_argument('code_point', type=ord)
parser.add_argument('dest_file', type=argparse.FileType('w', encoding='latin-1'))
parser.add_argument('datapath', type=pathlib.Path)
Las funciones definidas por el usuario también se pueden utilizar:
>>> def hyphenated(string):
... return '-'.join([word[:4] for word in string.casefold().split()])
...
>>> parser = argparse.ArgumentParser()
>>> _ = parser.add_argument('short_title', type=hyphenated)
>>> parser.parse_args(['"The Tale of Two Cities"'])
Namespace(short_title='"the-tale-of-two-citi')
La función bool()
no se recomienda como convertidor de tipos. Todo lo que hace es convertir cadenas de caracteres vacías en False
y cadenas de caracteres no vacías en True
. Por lo general, esto no es lo que se desea.
En general, la palabra clave type
es una conveniencia que solo debe usarse para conversiones simples que solo pueden generar una de las tres excepciones admitidas. Cualquier cosa con un manejo de errores o de recursos más interesante debe hacerse en sentido descendente después de analizar los argumentos.
For example, JSON or YAML conversions have complex error cases that require
better reporting than can be given by the type
keyword. A
JSONDecodeError
would not be well formatted and a
FileNotFoundError
exception would not be handled at all.
Even FileType
has its limitations for use with the type
keyword. If one argument uses FileType
and then a
subsequent argument fails, an error is reported but the file is not
automatically closed. In this case, it would be better to wait until after
the parser has run and then use the with
-statement to manage the
files.
Para los verificadores de tipo que simplemente verifican un conjunto fijo de valores, considere usar la palabra clave choices en su lugar.
choices¶
Some command-line arguments should be selected from a restricted set of values.
These can be handled by passing a sequence object as the choices keyword
argument to add_argument()
. When the command line is
parsed, argument values will be checked, and an error message will be displayed
if the argument was not one of the acceptable values:
>>> parser = argparse.ArgumentParser(prog='game.py')
>>> parser.add_argument('move', choices=['rock', 'paper', 'scissors'])
>>> parser.parse_args(['rock'])
Namespace(move='rock')
>>> parser.parse_args(['fire'])
usage: game.py [-h] {rock,paper,scissors}
game.py: error: argument move: invalid choice: 'fire' (choose from 'rock',
'paper', 'scissors')
Note that inclusion in the choices sequence is checked after any type conversions have been performed, so the type of the objects in the choices sequence should match the type specified.
Any sequence can be passed as the choices value, so list
objects,
tuple
objects, and custom sequences are all supported.
No se recomienda el uso de enum.Enum
porque es difícil controlar su apariencia en el uso, la ayuda y los mensajes de error.
Las opciones formateadas anulan el metavar predeterminado que normalmente se deriva de dest. Esto suele ser lo que se quiere porque el usuario nunca ve el parámetro dest. Si esta visualización no es deseable (quizás porque hay muchas opciones), simplemente especifique un metavar explícito.
required¶
En general, el módulo argparse
asume que los indicadores (flags) como -f
y --bar
señalan argumentos opcionales, que siempre pueden ser omitidos en la línea de comandos. Para hacer una opción requerida, se puede especificar True
para el argumento de palabra clave required=
en add_argument()
:
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', required=True)
>>> parser.parse_args(['--foo', 'BAR'])
Namespace(foo='BAR')
>>> parser.parse_args([])
usage: [-h] --foo FOO
: error: the following arguments are required: --foo
Como muestra el ejemplo, si una opción está marcada como required
, parse_args()
informará de un error si esa opción no está presente en la línea de comandos.
Nota
Las opciones requeridas están consideradas generalmente mala práctica porque los usuarios esperan que las opciones sean opcionales, y por lo tanto deberían ser evitadas cuando sea posible.
help¶
The help
value is a string containing a brief description of the argument.
When a user requests help (usually by using -h
or --help
at the
command line), these help
descriptions will be displayed with each
argument.
Las cadenas de texto help
pueden incluir varios descriptores de formato para evitar la repetición de cosas como el nombre del programa o el argumento default. Los descriptores disponibles incluyen el nombre del programa, %(prog)s
y la mayoría de los argumentos de palabra clave de add_argument()
, por ejemplo %(default)s
, %(type)s
, etc.:
>>> parser = argparse.ArgumentParser(prog='frobble')
>>> parser.add_argument('bar', nargs='?', type=int, default=42,
... help='the bar to %(prog)s (default: %(default)s)')
>>> parser.print_help()
usage: frobble [-h] [bar]
positional arguments:
bar the bar to frobble (default: 42)
options:
-h, --help show this help message and exit
Como la cadena de caracteres de ayuda soporta el formato-%, si quieres que aparezca un %
literal en la ayuda, debes escribirlo como %%
.
argparse
soporta el silenciar la ayuda para ciertas opciones, ajustando el valor help
a argparse.SUPPRESS
:
>>> parser = argparse.ArgumentParser(prog='frobble')
>>> parser.add_argument('--foo', help=argparse.SUPPRESS)
>>> parser.print_help()
usage: frobble [-h]
options:
-h, --help show this help message and exit
metavar¶
Cuando ArgumentParser
genera mensajes de ayuda, necesita alguna forma de referirse a cada argumento esperado. Por defecto, los objetos ArgumentParser utilizan el valor dest como «nombre» de cada objeto. Por defecto, para las acciones de argumento posicional, el valor dest se utiliza directamente, y para las acciones de argumento opcional, el valor dest está en mayúsculas. Así, un único argumento posicional con dest='bar'
se denominará bar
. Un único argumento opcional --foo
que debería seguirse por un único argumento de línea de comandos se denominará FOO
. Un ejemplo:
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> parser.add_argument('bar')
>>> parser.parse_args('X --foo Y'.split())
Namespace(bar='X', foo='Y')
>>> parser.print_help()
usage: [-h] [--foo FOO] bar
positional arguments:
bar
options:
-h, --help show this help message and exit
--foo FOO
Un nombre alternativo se puede especificar con metavar
:
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', metavar='YYY')
>>> parser.add_argument('bar', metavar='XXX')
>>> parser.parse_args('X --foo Y'.split())
Namespace(bar='X', foo='Y')
>>> parser.print_help()
usage: [-h] [--foo YYY] XXX
positional arguments:
XXX
options:
-h, --help show this help message and exit
--foo YYY
Ten en cuenta que metavar
sólo cambia el nombre mostrado - el nombre del atributo en el objeto parse_args()
sigue estando determinado por el valor dest.
Diferentes valores de nargs
pueden causar que metavar sea usado múltiples veces. Proporcionar una tupla a metavar
especifica una visualización diferente para cada uno de los argumentos:
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x', nargs=2)
>>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))
>>> parser.print_help()
usage: PROG [-h] [-x X X] [--foo bar baz]
options:
-h, --help show this help message and exit
-x X X
--foo bar baz
dest¶
La mayoría de las acciones ArgumentParser
añaden algún valor como atributo del objeto retornado por parse_args()
. El nombre de este atributo está determinado por el argumento de palabra clave dest
de add_argument()
. Para acciones de argumento posicional, se proporciona dest
normalmente como primer argumento de add_argument()
:
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('bar')
>>> parser.parse_args(['XXX'])
Namespace(bar='XXX')
Para las acciones de argumentos opcionales, el valor de dest
se infiere normalmente de las cadenas de caracteres de opción. ArgumentParser
genera el valor de dest
tomando la primera cadena de caracteres de opción larga y quitando la cadena inicial --
. Si no se proporcionaron cadenas de caracteres de opción largas, dest
se derivará de la primera cadena de caracteres de opción corta quitando el carácter -
. Cualquier carácter -
interno se convertirá a caracteres _
para asegurarse de que la cadena de caracteres es un nombre de atributo válido. Los ejemplos siguientes ilustran este comportamiento:
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('-f', '--foo-bar', '--foo')
>>> parser.add_argument('-x', '-y')
>>> parser.parse_args('-f 1 -x 2'.split())
Namespace(foo_bar='1', x='2')
>>> parser.parse_args('--foo 1 -y 2'.split())
Namespace(foo_bar='1', x='2')
dest
permite que se proporcione un nombre de atributo personalizado:
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', dest='bar')
>>> parser.parse_args('--foo XXX'.split())
Namespace(bar='XXX')
deprecated¶
During a project’s lifetime, some arguments may need to be removed from the
command line. Before removing them, you should inform
your users that the arguments are deprecated and will be removed.
The deprecated
keyword argument of
add_argument()
, which defaults to False
,
specifies if the argument is deprecated and will be removed
in the future.
For arguments, if deprecated
is True
, then a warning will be
printed to sys.stderr
when the argument is used:
>>> import argparse
>>> parser = argparse.ArgumentParser(prog='snake.py')
>>> parser.add_argument('--legs', default=0, type=int, deprecated=True)
>>> parser.parse_args([])
Namespace(legs=0)
>>> parser.parse_args(['--legs', '4'])
snake.py: warning: option '--legs' is deprecated
Namespace(legs=4)
Added in version 3.13.
Las clases Action¶
Action classes implement the Action API, a callable which returns a callable
which processes arguments from the command-line. Any object which follows
this API may be passed as the action
parameter to
add_argument()
.
- class argparse.Action(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)¶
Los objetos Action son utilizados por un ArgumentParser para representar la información necesaria para analizar un sólo argumento de una o más cadenas de caracteres de la línea de comandos. La clase Action debe aceptar los dos argumentos de posición más cualquier argumento de palabra clave pasado a
ArgumentParser.add_argument()
excepto para la propiaaction
.Las instancias de Action (o el valor de retorno de cualquier invocable al parámetro
action
) deben tener definidos los atributos ”dest”, ”option_strings”, ”default”, ”type”, ”required”, ”help”, etc. La forma más fácil de asegurar que estos atributos estén definidos es llamar aAction.__init__
.Las instancias de Action deben ser invocables, por lo que las subclases deben anular el método
__call__
, que debería aceptar cuatro parámetros:parser - The ArgumentParser object which contains this action.
- namespace - The
Namespace
object that will be returned by parse_args()
. Most actions add an attribute to this object usingsetattr()
.
- namespace - The
- values - The associated command-line arguments, with any type conversions
applied. Type conversions are specified with the type keyword argument to
add_argument()
.
- option_string - The option string that was used to invoke this action.
The
option_string
argument is optional, and will be absent if the action is associated with a positional argument.
El método
__call__
puede realizar acciones arbitrarias, pero típicamente estable atributos ennamespace
basados endest
yvalues
.Las subclases de acción pueden definir un método
format_usage
que no toma ningún argumento y devuelve una cadena que se utilizará al imprimir el uso del programa. Si no se proporciona dicho método, se utilizará un valor predeterminado razonable.
El método parse_args()¶
- ArgumentParser.parse_args(args=None, namespace=None)¶
Convierte las cadenas de caracteres de argumentos en objetos y los asigna como atributos del espacio de nombres (namespace). Retorna el espacio de nombres (namespace) ocupado.
Las llamadas previas a
add_argument()
determinan exactamente qué objetos se crean y cómo se asignan. Mira la documentación deadd_argument()
para más detalles.
Sintaxis del valor de la opción¶
El método parse_args()
soporta diversas formas de especificar el valor de una opción (si requiere uno). En el caso más simple, la opción y su valor se pasan como dos argumentos separados:
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x')
>>> parser.add_argument('--foo')
>>> parser.parse_args(['-x', 'X'])
Namespace(foo=None, x='X')
>>> parser.parse_args(['--foo', 'FOO'])
Namespace(foo='FOO', x=None)
En el caso de opciones largas (opciones con nombres más largos que un sólo carácter), la opción y el valor también se pueden pasar como un sólo argumento de línea de comandos, utilizando =
para separarlos:
>>> parser.parse_args(['--foo=FOO'])
Namespace(foo='FOO', x=None)
Para las opciones cortas (opciones de un sólo carácter de largo), la opción y su valor pueden ser concatenados:
>>> parser.parse_args(['-xX'])
Namespace(foo=None, x='X')
Se pueden unir varias opciones cortas, usando un sólo prefijo -
, siempre y cuando sólo la última opción (o ninguna de ellas) requiera un valor:
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x', action='store_true')
>>> parser.add_argument('-y', action='store_true')
>>> parser.add_argument('-z')
>>> parser.parse_args(['-xyzZ'])
Namespace(x=True, y=True, z='Z')
Argumentos no válidos¶
Mientras analiza la línea de comandos, parse_args()
comprueba una variedad de errores, incluyendo opciones ambiguas, tipos no válidos, opciones no válidas, número incorrecto de argumentos de posición, etc. Cuando encuentra un error de este tipo, termina y muestra el error junto con un mensaje de uso:
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--foo', type=int)
>>> parser.add_argument('bar', nargs='?')
>>> # invalid type
>>> parser.parse_args(['--foo', 'spam'])
usage: PROG [-h] [--foo FOO] [bar]
PROG: error: argument --foo: invalid int value: 'spam'
>>> # invalid option
>>> parser.parse_args(['--bar'])
usage: PROG [-h] [--foo FOO] [bar]
PROG: error: no such option: --bar
>>> # wrong number of arguments
>>> parser.parse_args(['spam', 'badger'])
usage: PROG [-h] [--foo FOO] [bar]
PROG: error: extra arguments found: badger
Argumentos conteniendo -
¶
El método parse_args()
busca generar errores cuando el usuario ha cometido claramente una equivocación, pero algunas situaciones son inherentemente ambiguas. Por ejemplo, el argumento de línea de comandos -1
podría ser un intento de especificar una opción o un intento de proporcionar un argumento de posición. El método parse_args()
es cauteloso aquí: los argumentos de posición sólo pueden comenzar con -
si se ven como números negativos y no hay opciones en el analizador que se puedan ver como números negativos
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x')
>>> parser.add_argument('foo', nargs='?')
>>> # no negative number options, so -1 is a positional argument
>>> parser.parse_args(['-x', '-1'])
Namespace(foo=None, x='-1')
>>> # no negative number options, so -1 and -5 are positional arguments
>>> parser.parse_args(['-x', '-1', '-5'])
Namespace(foo='-5', x='-1')
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-1', dest='one')
>>> parser.add_argument('foo', nargs='?')
>>> # negative number options present, so -1 is an option
>>> parser.parse_args(['-1', 'X'])
Namespace(foo=None, one='X')
>>> # negative number options present, so -2 is an option
>>> parser.parse_args(['-2'])
usage: PROG [-h] [-1 ONE] [foo]
PROG: error: no such option: -2
>>> # negative number options present, so both -1s are options
>>> parser.parse_args(['-1', '-1'])
usage: PROG [-h] [-1 ONE] [foo]
PROG: error: argument -1: expected one argument
Si tienes argumentos de posición que deben comenzar con -
y no parecen números negativos, puedes insertar el pseudo-argumento '--'
que indica a parse_args()
que todo lo que sigue es un argumento de posición:
>>> parser.parse_args(['--', '-f'])
Namespace(foo='-f', one=None)
See also the argparse howto on ambiguous arguments for more details.
Abreviaturas de los argumentos (coincidencia de prefijos)¶
El método parse_args()
por defecto permite abreviar las opciones largas a un prefijo, si la abreviatura es inequívoca (el prefijo coincide con una opción única):
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-bacon')
>>> parser.add_argument('-badger')
>>> parser.parse_args('-bac MMM'.split())
Namespace(bacon='MMM', badger=None)
>>> parser.parse_args('-bad WOOD'.split())
Namespace(bacon=None, badger='WOOD')
>>> parser.parse_args('-ba BA'.split())
usage: PROG [-h] [-bacon BACON] [-badger BADGER]
PROG: error: ambiguous option: -ba could match -badger, -bacon
Se incurre en un error por argumentos que podrían derivar en más de una opción. Esta característica puede ser desactivada poniendo allow_abbrev a False
.
Más allá de sys.argv
¶
A veces puede ser útil tener un ArgumentParser analizando argumentos que no sean los de sys.argv
. Esto se puede lograr pasando una lista de cadenas de caracteres a parse_args()
. Esto es útil para probar en el prompt interactivo:
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument(
... 'integers', metavar='int', type=int, choices=range(10),
... nargs='+', help='an integer in the range 0..9')
>>> parser.add_argument(
... '--sum', dest='accumulate', action='store_const', const=sum,
... default=max, help='sum the integers (default: find the max)')
>>> parser.parse_args(['1', '2', '3', '4'])
Namespace(accumulate=<built-in function max>, integers=[1, 2, 3, 4])
>>> parser.parse_args(['1', '2', '3', '4', '--sum'])
Namespace(accumulate=<built-in function sum>, integers=[1, 2, 3, 4])
El objeto Namespace¶
- class argparse.Namespace¶
Clase simple utilizada por defecto por
parse_args()
para crear un objeto que contenga atributos y retornarlo.Esta clase es deliberadamente simple, sólo una subclase
object
con una representación de cadena de texto legible. Si prefieres tener una vista en forma de diccionario de los atributos, puedes usar el lenguaje estándar de Python,vars()
:>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo') >>> args = parser.parse_args(['--foo', 'BAR']) >>> vars(args) {'foo': 'BAR'}
También puede ser útil tener un
ArgumentParser
que asigne atributos a un objeto ya existente, en lugar de un nuevo objetoNamespace
. Esto se puede lograr especificando el argumento de palabra clavenamespace=
:>>> class C: ... pass ... >>> c = C() >>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo') >>> parser.parse_args(args=['--foo', 'BAR'], namespace=c) >>> c.foo 'BAR'
Otras utilidades¶
Sub-comandos¶
- ArgumentParser.add_subparsers([title][, description][, prog][, parser_class][, action][, option_strings][, dest][, required][, help][, metavar])¶
Many programs split up their functionality into a number of subcommands, for example, the
svn
program can invoke subcommands likesvn checkout
,svn update
, andsvn commit
. Splitting up functionality this way can be a particularly good idea when a program performs several different functions which require different kinds of command-line arguments.ArgumentParser
supports the creation of such subcommands with theadd_subparsers()
method. Theadd_subparsers()
method is normally called with no arguments and returns a special action object. This object has a single method,add_parser()
, which takes a command name and anyArgumentParser
constructor arguments, and returns anArgumentParser
object that can be modified as usual.Descripción de los parámetros:
title - title for the sub-parser group in help output; by default «subcommands» if description is provided, otherwise uses title for positional arguments
description - description for the sub-parser group in help output, by default
None
prog - usage information that will be displayed with sub-command help, by default the name of the program and any positional arguments before the subparser argument
parser_class - class which will be used to create sub-parser instances, by default the class of the current parser (e.g. ArgumentParser)
action - el tipo básico de acción a tomar cuando este argumento se encuentre en la línea de comandos
dest - nombre del atributo en el que se almacenará el nombre del sub-comando; por defecto
None
y no se almacena ningún valorrequired - Si se debe proporcionar o no un sub-comando, por defecto
False
(añadido en 3.7)help - ayuda para el grupo de análisis secundario en la salida de la ayuda, por defecto
None
metavar - string presenting available subcommands in help; by default it is
None
and presents subcommands in form {cmd1, cmd2, ..}
Algún ejemplo de uso:
>>> # create the top-level parser >>> parser = argparse.ArgumentParser(prog='PROG') >>> parser.add_argument('--foo', action='store_true', help='foo help') >>> subparsers = parser.add_subparsers(help='subcommand help') >>> >>> # create the parser for the "a" command >>> parser_a = subparsers.add_parser('a', help='a help') >>> parser_a.add_argument('bar', type=int, help='bar help') >>> >>> # create the parser for the "b" command >>> parser_b = subparsers.add_parser('b', help='b help') >>> parser_b.add_argument('--baz', choices=('X', 'Y', 'Z'), help='baz help') >>> >>> # parse some argument lists >>> parser.parse_args(['a', '12']) Namespace(bar=12, foo=False) >>> parser.parse_args(['--foo', 'b', '--baz', 'Z']) Namespace(baz='Z', foo=True)
Ten en cuenta que el objeto retornado por
parse_args()
sólo contendrá atributos para el analizador principal y el analizador secundario que fue seleccionado por la línea de comandos (y no cualquier otro analizador secundario). Así que en el ejemplo anterior, cuando se especifica el comandoa
, sólo están presentes los atributosfoo
ybar
, y cuando se especifica el comandob
, sólo están presentes los atributosfoo
ybaz
.Similarly, when a help message is requested from a subparser, only the help for that particular parser will be printed. The help message will not include parent parser or sibling parser messages. (A help message for each subparser command, however, can be given by supplying the
help=
argument toadd_parser()
as above.)>>> parser.parse_args(['--help']) usage: PROG [-h] [--foo] {a,b} ... positional arguments: {a,b} subcommand help a a help b b help options: -h, --help show this help message and exit --foo foo help >>> parser.parse_args(['a', '--help']) usage: PROG a [-h] bar positional arguments: bar bar help options: -h, --help show this help message and exit >>> parser.parse_args(['b', '--help']) usage: PROG b [-h] [--baz {X,Y,Z}] options: -h, --help show this help message and exit --baz {X,Y,Z} baz help
El método
add_subparsers()
también soporta los argumentos de palabra clavetitle
ydescription
. Cuando cualquiera de los dos esté presente, los comandos del analizador secundario aparecerán en su propio grupo en la salida de la ayuda. Por ejemplo:>>> parser = argparse.ArgumentParser() >>> subparsers = parser.add_subparsers(title='subcommands', ... description='valid subcommands', ... help='additional help') >>> subparsers.add_parser('foo') >>> subparsers.add_parser('bar') >>> parser.parse_args(['-h']) usage: [-h] {foo,bar} ... options: -h, --help show this help message and exit subcommands: valid subcommands {foo,bar} additional help
Furthermore,
add_parser()
supports an additional aliases argument, which allows multiple strings to refer to the same subparser. This example, likesvn
, aliasesco
as a shorthand forcheckout
:>>> parser = argparse.ArgumentParser() >>> subparsers = parser.add_subparsers() >>> checkout = subparsers.add_parser('checkout', aliases=['co']) >>> checkout.add_argument('foo') >>> parser.parse_args(['co', 'bar']) Namespace(foo='bar')
add_parser()
supports also an additional deprecated argument, which allows to deprecate the subparser.>>> import argparse >>> parser = argparse.ArgumentParser(prog='chicken.py') >>> subparsers = parser.add_subparsers() >>> run = subparsers.add_parser('run') >>> fly = subparsers.add_parser('fly', deprecated=True) >>> parser.parse_args(['fly']) chicken.py: warning: command 'fly' is deprecated Namespace()
Added in version 3.13.
One particularly effective way of handling subcommands is to combine the use of the
add_subparsers()
method with calls toset_defaults()
so that each subparser knows which Python function it should execute. For example:>>> # subcommand functions >>> def foo(args): ... print(args.x * args.y) ... >>> def bar(args): ... print('((%s))' % args.z) ... >>> # create the top-level parser >>> parser = argparse.ArgumentParser() >>> subparsers = parser.add_subparsers(required=True) >>> >>> # create the parser for the "foo" command >>> parser_foo = subparsers.add_parser('foo') >>> parser_foo.add_argument('-x', type=int, default=1) >>> parser_foo.add_argument('y', type=float) >>> parser_foo.set_defaults(func=foo) >>> >>> # create the parser for the "bar" command >>> parser_bar = subparsers.add_parser('bar') >>> parser_bar.add_argument('z') >>> parser_bar.set_defaults(func=bar) >>> >>> # parse the args and call whatever function was selected >>> args = parser.parse_args('foo 1 -x 2'.split()) >>> args.func(args) 2.0 >>> >>> # parse the args and call whatever function was selected >>> args = parser.parse_args('bar XYZYX'.split()) >>> args.func(args) ((XYZYX))
De esta manera, puedes dejar que
parse_args()
haga el trabajo de llamar a la función apropiada después de que el análisis de los argumentos se haya completado. Asociar funciones con acciones como esta es típicamente la forma más fácil de manejar las diferentes acciones para cada uno de tus analizadores secundarios. Sin embargo, si es necesario comprobar el nombre del analizador secundario que se ha invocado, el argumento de palabra clavedest
a la llamadaadd_subparsers()
hará el trabajo:>>> parser = argparse.ArgumentParser() >>> subparsers = parser.add_subparsers(dest='subparser_name') >>> subparser1 = subparsers.add_parser('1') >>> subparser1.add_argument('-x') >>> subparser2 = subparsers.add_parser('2') >>> subparser2.add_argument('y') >>> parser.parse_args(['2', 'frobble']) Namespace(subparser_name='2', y='frobble')
Distinto en la versión 3.7: Nuevo argumento de palabra clave required.
Objetos FileType¶
- class argparse.FileType(mode='r', bufsize=-1, encoding=None, errors=None)¶
El generador
FileType
crea objetos que pueden ser transferidos al argumento tipo deArgumentParser.add_argument()
. Los argumentos que tienen objetosFileType
como su tipo abrirán los argumentos de líneas de comandos como archivos con los modos, tamaños de búfer, codificaciones y manejo de errores solicitados (véase la funciónopen()
para más detalles):>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--raw', type=argparse.FileType('wb', 0)) >>> parser.add_argument('out', type=argparse.FileType('w', encoding='UTF-8')) >>> parser.parse_args(['--raw', 'raw.dat', 'file.txt']) Namespace(out=<_io.TextIOWrapper name='file.txt' mode='w' encoding='UTF-8'>, raw=<_io.FileIO name='raw.dat' mode='wb'>)
FileType objects understand the pseudo-argument
'-'
and automatically convert this intosys.stdin
for readableFileType
objects andsys.stdout
for writableFileType
objects:>>> parser = argparse.ArgumentParser() >>> parser.add_argument('infile', type=argparse.FileType('r')) >>> parser.parse_args(['-']) Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>)
Distinto en la versión 3.4: Added the encodings and errors parameters.
Grupos de argumentos¶
- ArgumentParser.add_argument_group(title=None, description=None, *[, argument_default][, conflict_handler])¶
By default,
ArgumentParser
groups command-line arguments into «positional arguments» and «options» when displaying help messages. When there is a better conceptual grouping of arguments than this default one, appropriate groups can be created using theadd_argument_group()
method:>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False) >>> group = parser.add_argument_group('group') >>> group.add_argument('--foo', help='foo help') >>> group.add_argument('bar', help='bar help') >>> parser.print_help() usage: PROG [--foo FOO] bar group: bar bar help --foo FOO foo help
El método
add_argument_group()
retorna un objeto de grupo de argumentos que tiene un métodoadd_argument()
igual que unArgumentParser
convencional. Cuando se añade un argumento al grupo, el analizador lo trata como un argumento cualquiera, pero presenta el argumento en un grupo aparte para los mensajes de ayuda. El métodoadd_argument_group()
acepta los argumentos title y description que pueden ser usados para personalizar esta presentación:>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False) >>> group1 = parser.add_argument_group('group1', 'group1 description') >>> group1.add_argument('foo', help='foo help') >>> group2 = parser.add_argument_group('group2', 'group2 description') >>> group2.add_argument('--bar', help='bar help') >>> parser.print_help() usage: PROG [--bar BAR] foo group1: group1 description foo foo help group2: group2 description --bar BAR bar help
The optional, keyword-only parameters argument_default and conflict_handler allow for finer-grained control of the behavior of the argument group. These parameters have the same meaning as in the
ArgumentParser
constructor, but apply specifically to the argument group rather than the entire parser.Ten en cuenta que cualquier argumento que no esté en los grupos definidos por el usuario terminará en las secciones habituales de «argumentos de posición» y «argumentos opcionales».
Distinto en la versión 3.11: Llamando
add_argument_group()
en grupos de argumentos está obsoleto. Esta característica nunca fue soportada y no siempre funciona correctamente. La función existe en la API por accidente a través de la herencia y será eliminada en el futuro.
Exclusión mutua¶
- ArgumentParser.add_mutually_exclusive_group(required=False)¶
Crear un grupo de exclusividad mutua.
argparse
se asegurará de que sólo uno de los argumentos del grupo de exclusividad mutua esté presente en la línea de comandos:>>> parser = argparse.ArgumentParser(prog='PROG') >>> group = parser.add_mutually_exclusive_group() >>> group.add_argument('--foo', action='store_true') >>> group.add_argument('--bar', action='store_false') >>> parser.parse_args(['--foo']) Namespace(bar=True, foo=True) >>> parser.parse_args(['--bar']) Namespace(bar=False, foo=False) >>> parser.parse_args(['--foo', '--bar']) usage: PROG [-h] [--foo | --bar] PROG: error: argument --bar: not allowed with argument --foo
El método
add_mutually_exclusive_group()
también acepta un argumento required, para indicar que se requiere al menos uno de los argumentos mutuamente exclusivos:>>> parser = argparse.ArgumentParser(prog='PROG') >>> group = parser.add_mutually_exclusive_group(required=True) >>> group.add_argument('--foo', action='store_true') >>> group.add_argument('--bar', action='store_false') >>> parser.parse_args([]) usage: PROG [-h] (--foo | --bar) PROG: error: one of the arguments --foo --bar is required
Note that currently mutually exclusive argument groups do not support the title and description arguments of
add_argument_group()
. However, a mutually exclusive group can be added to an argument group that has a title and description. For example:>>> parser = argparse.ArgumentParser(prog='PROG') >>> group = parser.add_argument_group('Group title', 'Group description') >>> exclusive_group = group.add_mutually_exclusive_group(required=True) >>> exclusive_group.add_argument('--foo', help='foo help') >>> exclusive_group.add_argument('--bar', help='bar help') >>> parser.print_help() usage: PROG [-h] (--foo FOO | --bar BAR) options: -h, --help show this help message and exit Group title: Group description --foo FOO foo help --bar BAR bar help
Distinto en la versión 3.11: Llamando
add_argument_group()
oadd_mutually_exclusive_group()
en un grupo mutuamente exclusivo está obsoleto. Estás características nunca fueron soportadas y no siempre funcionan correctamente. La función existe en la API por accidente a través de la herencia y será eliminada en el futuro.
Valores por defecto del analizador¶
- ArgumentParser.set_defaults(**kwargs)¶
La mayoría de las veces, los atributos del objeto retornado por
parse_args()
se determinarán completamente inspeccionando los argumentos de la línea de comandos y las acciones de los argumentos.set_defaults()
permite que se añadan algunos atributos adicionales que se determinan sin ninguna inspección de la línea de comandos:>>> parser = argparse.ArgumentParser() >>> parser.add_argument('foo', type=int) >>> parser.set_defaults(bar=42, baz='badger') >>> parser.parse_args(['736']) Namespace(bar=42, baz='badger', foo=736)
Ten en cuenta que los valores por defecto a nivel analizador siempre prevalecen sobre los valores por defecto a nivel argumento:
>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', default='bar') >>> parser.set_defaults(foo='spam') >>> parser.parse_args([]) Namespace(foo='spam')
Los valores por defecto a nivel analizador pueden ser muy útiles cuando se trabaja con varios analizadores. Consulta el método
add_subparsers()
para ver un ejemplo de este tipo.
- ArgumentParser.get_default(dest)¶
Obtiene el valor por defecto para un atributo del espacio de nombres (namespace), establecido ya sea por
add_argument()
o porset_defaults()
:>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', default='badger') >>> parser.get_default('foo') 'badger'
Mostrando la ayuda¶
En la mayoría de las aplicaciones típicas, parse_args()
se encargará de dar formato y mostrar cualquier mensaje de uso o de error. Sin embargo, hay varios métodos para dar formato disponibles:
- ArgumentParser.print_usage(file=None)¶
Muestra una breve descripción de cómo se debe invocar el
ArgumentParser
en la línea de comandos. Si file esNone
, se asumesys.stdout
.
- ArgumentParser.print_help(file=None)¶
Muestra un mensaje de ayuda, incluyendo el uso del programa e información sobre los argumentos registrados en el
ArgumentParser
. Si file esNone
, se asumesys.stdout
.
También hay variantes de estos métodos que simplemente retornan una cadena de caracteres en lugar de mostrarla:
- ArgumentParser.format_usage()¶
Retorna una cadena de caracteres que contiene una breve descripción de cómo se debe invocar el
ArgumentParser
en la línea de comandos.
- ArgumentParser.format_help()¶
Retorna una cadena de caracteres que contiene un mensaje de ayuda, incluyendo el uso del programa e información sobre los argumentos registrados en el
ArgumentParser
.
Análisis parcial¶
- ArgumentParser.parse_known_args(args=None, namespace=None)¶
A veces una secuencia de comandos (script) sólo puede analizar algunos de los argumentos de la línea de comandos, pasando el resto de los argumentos a otra secuencia o programa. En estos casos, el método
parse_known_args()
puede ser útil. Funciona de forma muy parecida aparse_args()
excepto que no produce un error cuando hay argumentos extra presentes. En lugar de ello, retorna una tupla de dos elementos que contiene el espacio de nombres ocupado y la lista de argumentos de cadena de caracteres restantes.>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', action='store_true') >>> parser.add_argument('bar') >>> parser.parse_known_args(['--foo', '--badger', 'BAR', 'spam']) (Namespace(bar='BAR', foo=True), ['--badger', 'spam'])
Advertencia
Prefix matching rules apply to
parse_known_args()
. The parser may consume an option even if it’s just
a prefix of one of its known options, instead of leaving it in the remaining
arguments list.
Personalizando el análisis de archivos¶
- ArgumentParser.convert_arg_line_to_args(arg_line)¶
Los argumentos que se leen de un archivo (mira el argumento de palabra clave fromfile_prefix_chars para el constructor
ArgumentParser
) se leen uno por línea.convert_arg_line_to_args()
puede ser invalidado para una lectura más elegante.Este método utiliza un sólo argumento arg_line que es una cadena de caracteres leída desde el archivo de argumentos. Retorna una lista de argumentos analizados a partir de esta cadena de caracteres. El método se llama una vez por línea leída del fichero de argumentos, en orden.
Una alternativa útil de este método es la que trata cada palabra separada por un espacio como un argumento. El siguiente ejemplo demuestra cómo hacerlo:
class MyArgumentParser(argparse.ArgumentParser): def convert_arg_line_to_args(self, arg_line): return arg_line.split()
Métodos de salida¶
- ArgumentParser.exit(status=0, message=None)¶
This method terminates the program, exiting with the specified status and, if given, it prints a message to
sys.stderr
before that. The user can override this method to handle these steps differently:class ErrorCatchingArgumentParser(argparse.ArgumentParser): def exit(self, status=0, message=None): if status: raise Exception(f'Exiting because of an error: {message}') exit(status)
- ArgumentParser.error(message)¶
This method prints a usage message, including the message, to
sys.stderr
and terminates the program with a status code of 2.
Análisis entremezclado¶
- ArgumentParser.parse_intermixed_args(args=None, namespace=None)¶
- ArgumentParser.parse_known_intermixed_args(args=None, namespace=None)¶
Una serie de comandos Unix permiten al usuario mezclar argumentos opcionales con argumentos de posición. Los métodos
parse_intermixed_args()
yparse_known_intermixed_args()
soportan este modo de análisis.These parsers do not support all the argparse features, and will raise exceptions if unsupported features are used. In particular, subparsers, and mutually exclusive groups that include both optionals and positionals are not supported.
El siguiente ejemplo muestra la diferencia entre
parse_known_args()
yparse_intermixed_args()
: el primero retorna['2', '3']
como argumentos sin procesar, mientras que el segundo recoge todos los de posición enrest
.>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo') >>> parser.add_argument('cmd') >>> parser.add_argument('rest', nargs='*', type=int) >>> parser.parse_known_args('doit 1 --foo bar 2 3'.split()) (Namespace(cmd='doit', foo='bar', rest=[1]), ['2', '3']) >>> parser.parse_intermixed_args('doit 1 --foo bar 2 3'.split()) Namespace(cmd='doit', foo='bar', rest=[1, 2, 3])
parse_known_intermixed_args()
retorna una tupla de dos elementos que contiene el espacio de nombres poblado y la lista de los restantes argumentos de cadenas de caracteres.parse_intermixed_args()
arroja un error si quedan argumentos de cadenas de caracteres sin procesar.Added in version 3.7.
Exceptions¶
- exception argparse.ArgumentError¶
An error from creating or using an argument (optional or positional).
The string value of this exception is the message, augmented with information about the argument that caused it.
- exception argparse.ArgumentTypeError¶
Raised when something goes wrong converting a command line string to a type.
Guides and Tutorials