web-dev-qa-db-fra.com

Obtention des arguments restants dans argparse

Je veux obtenir tous les arguments inutilisés restants à la fois. Comment fait-on ça?

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

Une autre option consiste à ajouter un argument positionnel à votre analyseur. Spécifiez l'option sans tirets, et argparse les recherchera lorsqu'aucune autre option n'est reconnue. Cela a l'avantage supplémentaire d'améliorer le texte d'aide de la commande:

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

et

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

Utilisez parse_known_args() :

args, unknownargs = parser.parse_known_args()
78
Elmar Peise

Utilisation argparse.REMAINDER :

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

Exemple:

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

Je suis allé et codé les trois suggestions données comme réponses dans ce fil. Le code de test apparaît au bas de cette réponse. Conclusion: La meilleure réponse globale à ce jour est nargs=REMAINDER, mais cela peut vraiment dépendre de votre cas d'utilisation.

Voici les différences que j'ai observées:

(1) nargs=REMAINDER remporte le test de convivialité.

$ 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=* filtre discrètement le premier -- argument sur la ligne de commande, ce qui semble mauvais. En revanche, toutes les méthodes respectent -- pour dire "s'il vous plaît, n'analysez plus ces chaînes en tant qu'arguments connus."

$ ./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) Toute méthode sauf parse_known_args meurt s'il essaie d'analyser une chaîne commençant par - et il s'avère que ce n'est pas valable.

$ 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 arrête complètement l'analyse lorsqu'il atteint le premier argument inconnu. parse_known_args engloutira les arguments qui sont "connus", peu importe où ils apparaissent sur la ligne (et mourra s'ils paraissent mal formés).

$ 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

Voici mon code de test.

#!/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 __== '__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:])
25
Quuxplusone