`argparse` — Analizador sintáctico (Parser) para las opciones, argumentos y sub-comandos de la línea de comandos¶

Nuevo en la versión 3.2.

El módulo argparse facilita la escritura de interfaces de línea de comandos amigables. El programa define qué argumentos requiere, y argparse averiguará cómo analizar los de sys.argv. El módulo argparse también genera automáticamente mensajes de ayuda y de uso y muestra errores cuando los usuarios dan parámetros incorrectos al programa.

Ejemplo¶

El siguiente código es un programa Python que toma una lista de números enteros y obtiene la suma o el máximo:

import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                    help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',
                    const=sum, default=max,
                    help='sum the integers (default: find the max)')

args = parser.parse_args()
print(args.accumulate(args.integers))

Asumiendo que el código Python anterior se guarda en un archivo llamado prog.py, se puede ejecutar en la línea de comandos y proporciona mensajes de ayuda útiles:

$ python prog.py -h
usage: prog.py [-h] [--sum] N [N ...]

Process some integers.

positional arguments:
 N           an integer for the accumulator

optional arguments:
 -h, --help  show this help message and exit
 --sum       sum the integers (default: find the max)

Cuando se ejecuta con los parámetros apropiados, muestra la suma o el máximo de los números enteros de la línea de comandos:

$ python prog.py 1 2 3 4
4

$ python prog.py 1 2 3 4 --sum
10

Si se pasan argumentos incorrectos, se mostrará un error:

$ python prog.py a b c
usage: prog.py [-h] [--sum] N [N ...]
prog.py: error: argument N: invalid int value: 'a'

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

Creando un analizador sintáctico (parser)¶

El primer paso para usar argparse es crear un objeto ArgumentParser

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

El objeto ArgumentParser contendrá toda la información necesaria para analizar la línea de comandos con los tipos de datos de Python.

Añadiendo argumentos¶

Completar un ArgumentParser con información sobre los argumentos del programa se hace realizando llamadas al método add_argument(). Generalmente, estas llamadas le dicen a ArgumentParser cómo capturar las cadenas de caracteres de la línea de comandos y convertirlas en objetos. Esta información se almacena y se usa cuando se llama a parse_args(). Por ejemplo:

>>> parser.add_argument('integers', metavar='N', type=int, nargs='+',
...                     help='an integer for the accumulator')
>>> parser.add_argument('--sum', dest='accumulate', action='store_const',
...                     const=sum, default=max,
...                     help='sum the integers (default: find the max)')

Más tarde, llamando a parse_args() retornará un objeto con dos atributos, integers y accumulate. El atributo integers será una lista de uno o más enteros, y el atributo accumulate será la función sum(), si se especificó --sum en la línea de comandos, o la función max() si no.

Analizando argumentos¶

ArgumentParser analiza los argumentos mediante el método parse_args(). Éste inspeccionará la línea de comandos, convertirá cada argumento al tipo apropiado y luego invocará la acción correspondiente. En la mayoría de los casos, esto significa que un simple objeto Namespace se construirá a partir de los atributos analizados en la línea de comandos:

>>> parser.parse_args(['--sum', '7', '-1', '42'])
Namespace(accumulate=<built-in function sum>, integers=[7, -1, 42])

En un script, parse_args() será llamado típicamente sin argumentos, y la ArgumentParser determinará automáticamente los argumentos de la línea de comandos de sys.argv.

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: 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 - Texto a mostrar antes del argumento ayuda (por defecto: ninguno)
epilog - Texto a mostrar después del argumento ayuda (por defecto: ninguno)
parents - Una lista de objetos ArgumentParser cuyos argumentos también deberían ser incluidos
formatter_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¶

Por defecto, los objetos ArgumentParser utilizan sys.argv[0] para determinar cómo mostrar el nombre del programa en los mensajes de ayuda. Este valor por defecto es casi siempre deseable porque hará que los mensajes de ayuda coincidan con la forma en que el programa fue invocado en la línea de comandos. Por ejemplo, considera un archivo llamado myprogram.py con el siguiente código:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo', help='foo help')
args = parser.parse_args()

La ayuda para este programa mostrará myprogram.py como el nombre del programa (sin importar desde dónde se haya invocado el programa):

$ python myprogram.py --help
usage: myprogram.py [-h] [--foo FOO]

optional arguments:
 -h, --help  show this help message and exit
 --foo FOO   foo help
$ cd ..
$ python subdir/myprogram.py --help
usage: myprogram.py [-h] [--foo FOO]

optional arguments:
 -h, --help  show this help message and exit
 --foo FOO   foo help

Para cambiar este comportamiento por defecto, se puede proporcionar otro valor usando el argumento``prog=`` para ArgumentParser:

>>> parser = argparse.ArgumentParser(prog='myprogram')
>>> parser.print_help()
usage: myprogram [-h]

optional arguments:
 -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]

optional arguments:
 -h, --help  show this help message and exit
 --foo FOO   foo of the myprogram program

uso¶

Por defecto, ArgumentParser determina el mensaje de uso a partir de los argumentos que contiene:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--foo', nargs='?', help='foo help')
>>> parser.add_argument('bar', nargs='+', help='bar help')
>>> parser.print_help()
usage: PROG [-h] [--foo [FOO]] bar [bar ...]

positional arguments:
 bar          bar help

optional arguments:
 -h, --help   show this help message and exit
 --foo [FOO]  foo help

El mensaje por defecto puede ser sustituido con el argumento de palabra clave usage=:

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

optional arguments:
 -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¶

La mayoría de las llamadas al constructor ArgumentParser usarán el argumento de palabra clave description=. Este argumento da una breve descripción de lo que hace el programa y cómo funciona. En los mensajes de ayuda, la descripción se muestra entre la cadena de caracteres de uso (usage) de la línea de comandos y los mensajes de ayuda para los distintos argumentos:

>>> parser = argparse.ArgumentParser(description='A foo that bars')
>>> parser.print_help()
usage: argparse.py [-h]

A foo that bars

optional arguments:
 -h, --help  show this help message and exit

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

optional arguments:
 -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

optional arguments:
 -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

optional arguments:
 -h, --help  show this help message and exit

RawTextHelpFormatter mantiene espacios en blanco para todo tipo de texto de ayuda, incluyendo descripciones de argumentos. Sin embargo, varias líneas nuevas son reemplazadas por una sola. Si deseas conservar varias líneas en blanco, añade espacios entre las nuevas líneas.

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])

optional arguments:
 -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

optional arguments:
  -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¶

Sometimes, for example when dealing with a particularly long argument list, it may make sense to keep the list of arguments in a file rather than typing it out at the command line. If the fromfile_prefix_chars= argument is given to the ArgumentParser constructor, then arguments that start with any of the specified characters will be treated as files, and will be replaced by the arguments they contain. For example:

>>> with open('args.txt', 'w') 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’].

El argumento fromfile_prefix_chars= por defecto es None, lo que significa que los argumentos nunca serán tratados como referencias de archivos.

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

Nuevo en la versión 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]

optional arguments:
 -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¶

Por defecto, los objetos ArgumentParser añaden una opción que simplemente muestra el mensaje de ayuda del analizador. Por ejemplo, considera un archivo llamado myprogram.py que contiene el siguiente código:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo', help='foo help')
args = parser.parse_args()

Si -h o --help se indica en la línea de comandos, se imprimirá la ayuda de ArgumentParser:

$ python myprogram.py --help
usage: myprogram.py [-h] [--foo FOO]

optional arguments:
 -h, --help  show this help message and exit
 --foo FOO   foo help

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]

optional arguments:
 --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]

optional arguments:
  +h, ++help  show this help message and exit

exit_on_error¶

Normalmente, cuando pasa una lista de argumentos no válidos al método parse_args() de un ArgumentParser, saldrá con información de error.

If the user would like to catch errors manually, the feature can be enabled by setting exit_on_error to 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

Nuevo en la versión 3.9.

El método add_argument()¶

ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])¶

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 - Un contenedor con los valores permitidos para el argumento.
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().

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 se espera un argumento opcional, como -f o --foo, o un argumento posicional, como una lista de nombres de archivos. Por lo tanto, los primeros argumentos que se pasan a add_argument() deben ser una serie de indicadores (flags), o un simple nombre de 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' - Esta sólo almacena el valor del argumento. Esta es la acción por defecto. Por ejemplo:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> parser.parse_args('--foo 1'.split())
Namespace(foo='1')

'store_const' - Esta almacena el valor especificado por el argumento de palabra clave const . La acción 'store_const' se usa más 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' y 'store_false' - Son casos especiales de 'store_const' usados para almacenar los valores True y False respectivamente. Además, crean valores por defecto de False y True respectivamente. Por ejemplo:

>>> 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' - Esta almacena una lista, y añade cada valor del argumento a la lista. Esto es útil para permitir que una opción sea especificada varias veces. 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' - Esta almacena una lista, y añade el valor especificado por el argumento de palabra clave const a la lista. (Nótese que el argumento de palabra clave const por defecto es None.) La acción 'append_const' es útil típicamente cuando múltiples argumentos necesitan almacenar constantes a 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'>])
```
'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. Ver ArgumentParser para detalles de cómo se genera la salida.

’version’ - Esta espera un argumento de palabra clave version= en la llamada add_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

’extend’ - Esta almacena una lista, y extiende cada valor del argumento a la lista. Ejemplo de uso:

>>> 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'])

Nuevo en la versión 3.8.

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)

Nuevo en la versión 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¶

Los objetos ArgumentParser suelen asociar un único argumento de línea de comandos con una única acción a realizar. El argumento de palabra clave nargs asocia un número diferente de argumentos de línea de comandos con una sola acción. Los valores admitidos son:

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 con nargs=‘*’, pero es posible tener múltiples argumentos opcionales con nargs=‘*’. 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

Si no se proporciona el argumento de palabra clave nargs, el número de argumentos consumidos se determina por action. Generalmente esto significa que se consumirá un único argumento de línea de comandos y se obtendrá un único elemento (no una lista).

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() se llama con action='store_const' o action='append_const'. Estas acciones añaden el valor const a uno de los atributos del objeto retornado por parse_args(). Mira la descripción action para ver ejemplos.
Cuando add_argument() se llama con cadenas de caracteres de opción (como -f o —foo) y nargs=‘?’. 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 de const. Mira la descripción nargs para ejemplos.

Con las acciones 'store_const' y 'append_const', se debe asignar el argumento palabra clave const. Para otras acciones, por defecto es None.

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)

Si el espacio de nombres de destino ya tiene un atributo establecido, la acción default no lo sobrescribirá:

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

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('source_file', type=open)
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 FileNotFound exception would not be handled at all.

Even FileType tiene sus limitaciones para su uso con la palabra clave type. Si un argumento usa FileType y luego falla un argumento posterior, se informa un error pero el archivo no se cierra automáticamente. En este caso, sería mejor esperar hasta que se haya ejecutado el analizador y luego usar la declaración with para administrar los archivos.

Para los verificadores de tipo que simplemente verifican un conjunto fijo de valores, considere usar la palabra clave choice en su lugar.

choices¶

Algunos argumentos de la línea de comandos deberían seleccionarse de un conjunto restringido de valores. Estos pueden ser manejados pasando un objeto contenedor como el argumento de palabra clave choices a add_argument(). Cuando se analiza la línea de comandos, se comprueban los valores de los argumentos y se muestra un mensaje de error si el argumento no era uno de los valores aceptables:

>>> 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')

Ten en cuenta que la inclusión en el contenedor choices se comprueba después de que se haya realizado cualquier conversión de type, por lo que el tipo de los objetos del contenedor choices debe coincidir con el type especificado:

>>> parser = argparse.ArgumentParser(prog='doors.py')
>>> parser.add_argument('door', type=int, choices=range(1, 4))
>>> print(parser.parse_args(['3']))
Namespace(door=3)
>>> parser.parse_args(['4'])
usage: doors.py [-h] {1,2,3}
doors.py: error: argument door: invalid choice: 4 (choose from 1, 2, 3)

Se puede pasar cualquier contenedor como el valor para choices, así que los objetos list, set , y los contenedores personalizados están todos soportados.

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 desea 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¶

El valor help es una cadena de caracteres que contiene una breve descripción del argumento. Cuando un usuario solicita ayuda (normalmente usando -h o --help en la línea de comandos), estas descripciones help se mostrarán con cada argumento:

>>> parser = argparse.ArgumentParser(prog='frobble')
>>> parser.add_argument('--foo', action='store_true',
...                     help='foo the bars before frobbling')
>>> parser.add_argument('bar', nargs='+',
...                     help='one of the bars to be frobbled')
>>> parser.parse_args(['-h'])
usage: frobble [-h] [--foo] bar [bar ...]

positional arguments:
 bar     one of the bars to be frobbled

optional arguments:
 -h, --help  show this help message and exit
 --foo   foo the bars before frobbling

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)

optional arguments:
 -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]

optional arguments:
  -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

optional arguments:
 -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

optional arguments:
 -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]

optional arguments:
 -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')

Las clases Action¶

Las clases Action implementan la API de Action, un invocable que retorna un invocable que procesa los argumentos de la línea de comandos. Cualquier objeto que siga esta API puede ser pasado como el parámetro action a 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 propia action.

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 a Action.__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 - El objeto ArgumentParser que contiene esta acción.
namespace - El objeto Namespace que será retornado por parse_args(). La mayoría de las acciones añaden un atributo a este objeto usando setattr().
values - Los argumentos de la línea de comandos asociados, con cualquier tipo de conversión aplicada. Las conversiones de tipos se especifican con el argumento de palabra clave type a add_argument().
option_string - La cadena de caracteres de opción que se usó para invocar esta acción. El argumento option_string es opcional, y estará ausente si la acción está asociada a un argumento de posición.

El método __call__ puede realizar acciones arbitrarias, pero típicamente estable atributos en namespace basados en dest y values.

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 de add_argument() para más detalles.

args - Lista de cadenas de caracteres para analizar. El valor por defecto se toma de sys.argv.
namespace - Un objeto para obtener los atributos. Por defecto es un nuevo objeto vacío Namespace.

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)

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 objeto Namespace. Esto se puede lograr especificando el argumento de palabra clave namespace=:

>>> 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_string][, dest][, required][, help][, metavar])¶

Muchos programas dividen su funcionalidad en varios sub-comandos, por ejemplo, el programa svn puede llamar sub-comandos como svn checkout, svn update, y svn commit. Dividir la funcionalidad de esta forma puede ser una idea particularmente buena cuando un programa realiza varias funciones diferentes que requieren diferentes tipos de argumentos en la línea de comandos. ArgumentParser soporta la creación de tales sub-comandos con el método add_subparsers(). El método add_subparsers() se llama normalmente sin argumentos y retorna un objeto de acción especial. Este objeto tiene un único método, add_parser(), que toma un nombre de comando y cualquier argumento de construcción ArgumentParser, y retorna un objeto ArgumentParser que puede ser modificado de la forma habitual.

Descripción de los parámetros:

title - título para el grupo del analizador secundario en la salida de la ayuda; por defecto «subcommands» si se proporciona la descripción, de lo contrario utiliza el título para los argumentos de posición
description - descripción para el grupo del analizador secundario en la salida de la ayuda, por defecto None
prog - información de uso que se mostrará con la ayuda de los sub-comandos, por defecto el nombre del programa y cualquier argumento de posición antes del argumento del analizador secundario
parser_class - clase que se usará para crear instancias de análisis secundario, por defecto la clase del analizador actual (por ejemplo, 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 valor
required - 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 - cadena de caracteres que presenta los sub-comandos disponibles en la ayuda; por defecto es None y presenta los sub-comandos de la forma {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='sub-command 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='XYZ', 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 comando a, sólo están presentes los atributos foo y bar, y cuando se especifica el comando``b``, sólo están presentes los atributos foo y baz.

Del mismo modo, cuando se solicita un mensaje de ayuda de un analizador secundario, sólo se imprimirá la ayuda para ese analizador en particular. El mensaje de ayuda no incluirá mensajes del analizador principal o de analizadores relacionados. (Sin embargo, se puede dar un mensaje de ayuda para cada comando del analizador secundario suministrando el argumento help= a add_parser() como se ha indicado anteriormente).

>>> parser.parse_args(['--help'])
usage: PROG [-h] [--foo] {a,b} ...

positional arguments:
  {a,b}   sub-command help
    a     a help
    b     b help

optional arguments:
  -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

optional arguments:
  -h, --help  show this help message and exit

>>> parser.parse_args(['b', '--help'])
usage: PROG b [-h] [--baz {X,Y,Z}]

optional arguments:
  -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 clave``title`` y description. 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} ...

optional arguments:
  -h, --help  show this help message and exit

subcommands:
  valid subcommands

  {foo,bar}   additional help

Además, add_parser soporta un argumento adicional aliases, que permite que múltiples cadenas se refieran al mismo analizador secundario. Este ejemplo, algo del estilo svn, alias co como abreviatura para checkout:

>>> 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')

Una forma particularmente efectiva de manejar los sub-comandos es combinar el uso del método add_subparsers() con llamadas a set_defaults() para que cada analizador secundario sepa qué función de Python debe ejecutar. Por ejemplo:

>>> # sub-command 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()
>>>
>>> # 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 clave dest a la llamada add_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 de ArgumentParser.add_argument(). Los argumentos que tienen objetos FileType 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ón open() 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'>)

Los objetos FileType entienden el pseudo-argumento '-' y lo convierten automáticamente en sys.stdin para objetos de lectura FileType y sys.stdout para objetos de escritura FileType:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('infile', type=argparse.FileType('r'))
>>> parser.parse_args(['-'])
Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>)

Nuevo en la versión 3.4: Los argumentos de palabra clave encodings y errors.

Grupos de argumentos¶

ArgumentParser.add_argument_group(title=None, description=None)¶

Por defecto, ArgumentParser agrupa los argumentos de la línea de comandos en «argumentos de posición» y «argumentos opcionales» al mostrar los mensajes de ayuda. Cuando hay una mejor agrupación conceptual de argumentos que esta predeterminada, se pueden crear grupos apropiados usando el método add_argument_group():

>>> 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étodo add_argument() igual que un ArgumentParser 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étodo add_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

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».

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

Ten en cuenta que actualmente los grupos de argumentos mutuamente exclusivos no admiten los argumentos title y description de add_argument_group().

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 por set_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 es None, se asume sys.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 es None, se asume sys.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 a parse_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

Coincidencia de prefijos las reglas se aplican a parse_known_args(). El analizador puede consumir una opción aunque sea sólo un prefijo de una de sus opciones conocidas, en lugar de dejarla en la lista de argumentos restantes.

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)¶

Este método finaliza el programa, saliendo con el status especificado y, si corresponde, muestra un message antes de eso. El usuario puede anular este método para manejar estos pasos de manera diferente:

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)¶: Este método imprime un mensaje de uso incluyendo el message para error estándar y finaliza el programa con código de estado 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() y parse_known_intermixed_args() soportan este modo de análisis.

Estos analizadores no soportan todas las capacidades de argparse, y generarán excepciones si se utilizan capacidades no soportadas. En particular, los analizadores secundarios, argparse.REMAINDER, y los grupos mutuamente exclusivos que incluyen tanto opcionales como de posición no están soportados.

El siguiente ejemplo muestra la diferencia entre parse_known_args() y parse_intermixed_args(): el primero retorna ['2', '3'] como argumentos sin procesar, mientras que el segundo recoge todos los de posición en rest.

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

Nuevo en la versión 3.7.

Actualizar el código de optparse¶

Originalmente, el módulo argparse había intentado mantener la compatibilidad con optparse. Sin embargo, optparse era difícil de extender de forma transparente, particularmente con los cambios necesarios para soportar los nuevos especificadores nargs= y los mensajes de uso mejorados. Cuando casi todo en optparse había sido copiado y pegado o monkey-patched, ya no parecía práctico tratar de mantener la retro-compatibilidad.

El módulo argparse mejora la biblioteca estándar del módulo optparse de varias maneras, incluyendo:

Manejando argumentos de posición.
Soportando sub-comandos.
Permitiendo prefijos de opción alternativos como + y /.
Manejando argumentos de estilo cero o más y uno o más.
Generando mensajes de uso más informativos.
Proporcionando una interfaz mucho más simple para type y action personalizadas.

Una manera de actualizar parcialmente de optparse a argparse:

Reemplaza todas las llamadas optparse.OptionParser.add_option() con llamadas ArgumentParser.add_argument().
Reemplaza (options, args) = parser.parse_args() con args = parser.parse_args() y agrega las llamadas adicionales ArgumentParser.add_argument() para los argumentos de posición. Ten en cuenta que lo que antes se llamaba options, ahora en el contexto argparse se llama args.
Reemplaza optparse.OptionParser.disable_interspersed_args() por parse_intermixed_args() en lugar de parse_args().
Reemplaza las acciones de respuesta y los argumentos de palabra clave callback_* con argumentos de type o action.
Reemplaza los nombres de cadena de caracteres por argumentos de palabra clave type con los correspondientes objetos tipo (por ejemplo, int, float, complex, etc).
Reemplaza optparse.Values por Namespace y optparse.OptionError y optparse.OptionValueError por ArgumentError.
Reemplaza las cadenas de caracteres con argumentos implícitos como %default o %prog por la sintaxis estándar de Python y usa diccionarios para dar formato a cadenas de caracteres, es decir, %(default)s y %(prog)s.
Reemplaza el argumento version del constructor OptionParser por una llamada a parser.add_argument('--version', action='version', version='<the version>').

argparse — Analizador sintáctico (Parser) para las opciones, argumentos y sub-comandos de la línea de comandos¶