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