metavar - argparse python example

Obteniendo los argumentos restantes en argparse

Question

Quiero obtener todos los argumentos no utilizados restantes a la vez. ¿Cómo lo hago?

parser.add_argument(''-i'', action=''store'', dest=''i'', default=''i.log'')
parser.add_argument(''-o'', action=''store'', dest=''o'', default=''o.log'')

Answer 1

Fui y codifiqué las tres sugerencias dadas como respuestas en este hilo. El código de prueba aparece en la parte inferior de esta respuesta. Conclusión: la mejor respuesta general hasta ahora es nargs=REMAINDER , pero puede depender realmente de su caso de uso.

Aquí están las diferencias que observé:

(1) nargs=REMAINDER gana la prueba de facilidad de uso.

$ python test.py --help
Using nargs=* : usage: test.py [-h] [-i I] [otherthings [otherthings ...]]
Using nargs=REMAINDER : usage: test.py [-h] [-i I] ...
Using parse_known_args : usage: test.py [-h] [-i I]

(2) nargs=* filtra silenciosamente el primer argumento en la línea de comando, lo que parece malo. Por otro lado, todos los métodos respetan -- como una forma de decir "por favor, no analices más de estas cadenas como se sabe".

$ ./test.py hello -- -- cruel -- -- world
Using nargs=* : [''hello'', ''--'', ''cruel'', ''--'', ''--'', ''world'']
Using nargs=REMAINDER : [''hello'', ''--'', ''--'', ''cruel'', ''--'', ''--'', ''world'']
Using parse_known_args : [''hello'', ''--'', ''--'', ''cruel'', ''--'', ''--'', ''world'']
$ ./test.py -i foo -- -i bar
Using nargs=* : [''-i'', ''bar'']
Using nargs=REMAINDER : [''--'', ''-i'', ''bar'']
Using parse_known_args : [''--'', ''-i'', ''bar'']

(3) Cualquier método, excepto parse_known_args muere si intenta analizar una cadena que comienza con - y resulta que no es válido.

$ python test.py -c hello
Using nargs=* : "unrecognized arguments: -c" and SystemExit
Using nargs=REMAINDER : "unrecognized arguments: -c" and SystemExit
Using parse_known_args : [''-c'', ''hello'']

(4) nargs=REMAINDER deja de analizar por completo cuando llega al primer argumento desconocido. parse_known_args engullirá los argumentos que son "conocidos", sin importar dónde aparezcan en la línea (y morirán si se ven mal formados).

$ python test.py hello -c world
Using nargs=* : "unrecognized arguments: -c world" and SystemExit
Using nargs=REMAINDER : [''hello'', ''-c'', ''world'']
Using parse_known_args : [''hello'', ''-c'', ''world'']
$ python test.py hello -i world
Using nargs=* : [''hello'']
Using nargs=REMAINDER : [''hello'', ''-i'', ''world'']
Using parse_known_args : [''hello'']
$ python test.py hello -i
Using nargs=* : "error: argument -i: expected one argument" and SystemExit
Using nargs=REMAINDER : [''hello'', ''-i'']
Using parse_known_args : "error: argument -i: expected one argument" and SystemExit

Aquí está mi código de prueba.

#!/usr/bin/env python
import argparse
import sys
def using_asterisk(argv):
parser = argparse.ArgumentParser()
parser.add_argument(''-i'', dest=''i'', default=''i.log'')
parser.add_argument(''otherthings'', nargs=''*'')
try:
options = parser.parse_args(argv)
return options.otherthings
except BaseException as e:
return e
def using_REMAINDER(argv):
parser = argparse.ArgumentParser()
parser.add_argument(''-i'', dest=''i'', default=''i.log'')
parser.add_argument(''otherthings'', nargs=argparse.REMAINDER)
try:
options = parser.parse_args(argv)
return options.otherthings
except BaseException as e:
return e
def using_parse_known_args(argv):
parser = argparse.ArgumentParser()
parser.add_argument(''-i'', dest=''i'', default=''i.log'')
try:
options, rest = parser.parse_known_args(argv)
return rest
except BaseException as e:
return e
if __name__ == ''__main__'':
print ''Using nargs=* : %r'' % using_asterisk(sys.argv[1:])
print ''Using nargs=REMAINDER : %r'' % using_REMAINDER(sys.argv[1:])
print ''Using parse_known_args : %r'' % using_parse_known_args(sys.argv[1:])

Answer 2

Otra opción es agregar un argumento posicional a su analizador. Especifique la opción sin guiones argparse , y argparse los buscará cuando no se reconozca ninguna otra opción. Esto tiene el beneficio adicional de mejorar el texto de ayuda para el comando:

>>> parser.add_argument(''otherthings'', nargs=''*'')
>>> parser.parse_args([''foo'', ''bar'', ''baz''])
Namespace(i=''i.log'', o=''o.log'', otherthings=[''foo'', ''bar'', ''baz''])

y

>>> print parser.format_help()
usage: ipython-script.py [-h] [-i I] [-o O] [otherthings [otherthings ...]]
positional arguments:
otherthings
optional arguments:
-h, --help show this help message and exit
-i I
-o O

Answer 3

Utilice argparse.REMAINDER :

parser.add_argument(''rest'', nargs=argparse.REMAINDER)

Ejemplo extendiendo su caso:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument(''-i'', action=''store'', dest=''i'', default=''i.log'')
parser.add_argument(''-o'', action=''store'', dest=''o'', default=''o.log'')
parser.add_argument(''rest'', nargs=argparse.REMAINDER)
parser.parse_args([''hello'', ''world''])
>>> Namespace(i=''i.log'', o=''o.log'', rest=[''hello'', ''world''])

Answer 4

Utilice parse_known_args() :

args, unknownargs = parser.parse_known_args()