[PYTHON] argparse

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

Pour utiliser argparse

Faire un analyseur

Pour utiliser argparse, créez d'abord un objet ArgumentParser.

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

Ajouter un argument

Appelez la méthode add_argument () sur l'objet ArgumentParser Apprenez à prendre une chaîne de ligne de commande et à la transformer en objet.

parser.add_argument('intgers', 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 intgers (default: find the max)')

Lorsque vous appelez parse_args (), vous obtenez deux attributs, des indicateurs et vous accumulez. Renvoie l'objet dont il dispose.

L'attribut ʻintegrator est une liste d'un ou plusieurs entiers, et l'attribut ʻaccumulate est Si --sum est spécifié à partir de la ligne de commande, la fonction sum () sera Sinon, c'est une fonction max ().

Analyser l'argument

ArgmumentParser analyse ses arguments avec la méthode parse_args (). Cette méthode examine la ligne de commande, convertit chaque argument dans le type correct, Prenez les mesures appropriées.

Dans la plupart des cas, cela provient de l'analyse de la ligne de commande Moyens de construire un objet Namespace simple.

Dans le script, parse_args () est généralement appelé sans argument ArgumentParser obtient automatiquement les arguments de ligne de commande à partir de sys.argv.

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

Tous les arguments doivent être passés comme arguments de mot-clé.

prog

Si vous utilisez argparse, le nom du programme sur le message d'aide sera Par défaut, il est obtenu à partir de sys.argv [0].

Si vous exécutez un programme appelé myprogram.py, la valeur de sys.argv [0] sera Cela devient «myprogram.py».

Selon la façon dont le programme démarre sur la ligne de commande C'est le comportement souhaité dans la plupart des cas car il crée un message d'aide.

Pour modifier ce comportement par défaut, utilisez l'argument prog = de ArgumentParser Ceci peut être réalisé en spécifiant d'autres valeurs.

Le nom du programme a été donné avec l'argument prog =, même s'il est extrait de sys.argv [0] Même si dans le message d'aide avec le spécificateur de format % (prog) s Disponible.

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

usage

usage: PROG [-h] [--foo [FOO]] bar [bar ...]

Par défaut, l'utilisation est créée automatiquement, ʻUsage = `Peut être spécifié explicitement avec l'argument mot-clé.

parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')

usage: PROG [options]

description

Avec l'argument de mot-clé description =, l'utilisation de la ligne de commande et l'argument Ce que fait le programme et comment il fonctionne pendant le message d'aide Une brève explication à ce sujet s'affiche.

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

epilog

Afficher une description supplémentaire du programme après la description de l'argument.

>>> parser = argparse.ArgumentParser(
  description='A foo that bars',
  epilog="And that's how you'd foo a bar")
>>> parser.print_help()  
usage: argparse.py

A foo that bars

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

And that's how you'd foo a bar

parents

Si vous souhaitez appliquer un jeu d'arguments commun à plusieurs analyseurs Analyseur avec tous les arguments courants dans l'argument parents = Peut être passé.

Spécifiez add_help = False comme analyseur parent.

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

bar_parser = argparse.ArgumentParser(parents=[parent_parser])
bar_parser.add_argument('--bar')
bar_parser.parse_args(['--bar', 'YYY'])

add_argument (), méthode

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

name or flags

L'argument spécifié est-il un argument facultatif tel que «-f» ou «--foo»? S'il s'agit d'un argument positionnel tel qu'une liste de noms de fichiers, dans le premier argument de ʻadd_argument () ` donner.

Créez des arguments facultatifs comme suit.

parser.add_argument('-f', '--foo')

Les arguments positionnels sont créés comme suit.

parser.add_argument('bar')

Lorsque parse_args () est appelé, les arguments optionnels sont préfixés par - Il est identifié et les autres arguments sont traités comme des arguments de position.

action

store

Stocke simplement la valeur de l'argument. L'action par défaut.

store_const

stocke la valeur spécifiée par l'argument de mot-clé const.

parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='store_const', const=42)

42 est stocké dans une variable appelée foo.

store_true, store_false

Stocke respectivement Vrai et Faux.

parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='store_true')
parser.add_argument('--bar', action='store_false')

Dans le cas ci-dessus, «foo» stocke «True» et «bar» stocke «False».

append

Stockez la liste et ajoutez la valeur de chaque argument à la liste.

Cette action est utile pour les options pour lesquelles vous souhaitez autoriser plusieurs spécifications.

parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='append')
parser.parse_args('--foo 1 --foo 2'.splist())
Namespace(foo=['1', '2'])

append_const

Stockez la liste et définissez la valeur donnée à l'argument de mot-clé const Ajoutez à cette liste.

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

Comptez le nombre d'arguments de mot-clé.

Par exemple, cela aide à élever le niveau détaillé.

parser = argparse.ArgumentParser()
parser.add_argument('--versbose', '-v', action='count')
parser.parse_args('-vvv'.split())
Namespace(verbose=3)

nargs

L'objet ArgumentParser est généralement Passez un argument de ligne de commande à une action.

L'argument de mot-clé nargs est pour une action et le nombre d'autres Des arguments de ligne de commande peuvent être affectés.

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

• N --Si nargs est un entier, N arguments seront collectés à partir de la ligne de commande. Stocké dans une liste.

*? - Si possible, un argument est extrait de la ligne de commande pour créer un élément. Si aucun argument de ligne de commande n'existe, une valeur par défaut est générée.

• '*' - Tous les arguments de ligne de commande sont rassemblés dans une liste.

• '+' - Tous les arguments de ligne de commande sont rassemblés dans la liste, mais au moins Générez un message d'erreur si un argument de ligne de commande n'existe pas.

type

Par défaut, l'objet ArgumentParser a des arguments de ligne de commande Lire comme une simple chaîne de caractères.

Lorsque la chaîne de ligne de commande doit être traitée comme un autre type tel que float, int, etc. Vérification de type et vérification de type par argument de type mot-clé de ʻadd_argument () ` La conversion de type peut être effectuée.

Les types de données et fonctions intégrés communs peuvent être spécifiés directement comme valeur de l'argument type.

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('foo', type=int)
>>> parser.add_argument('bar', type=open)
>>> parser.parse_args('2 temp.text'.split())
Namespace(bar=<_io.TextIOWrapper name='temp.txt' encoding='UTF-8'>, foo=2)

choices

Si vous souhaitez que l'argument de ligne de commande soit choisi parmi plusieurs options Possible en passant l'argument du mot clé choice.

Lors de l'analyse de la ligne de commande, la valeur de l'argument est vérifiée et la valeur est S'il n'est pas inclus dans les options, un message d'erreur s'affichera.

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

required

Pour rendre les arguments facultatifs obligatoires, spécifiez «True» dans l'argument de mot clé «required =».

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', required=True)
>>> parser.parse_args(['--foo', 'BAR'])
Namespace(foo='BAR')
>>> parser.parse_args([])
usage: argparse.py [-h] [--foo FOO]
argparse.py: error: option --foo is required

help

L'utilisateur peut spécifier -h ou --help sur la ligne de commande, etc. Lorsque vous demandez de l'aide, cette description help est affichée dans chaque argument.

>>> 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'.split())
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

metavar

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

Par défaut, la valeur de dest est utilisée telle quelle pour l'argument positionnel. Pour les arguments facultatifs, convertissez la valeur de dest en majuscules et utilisez-la.

Un argument de position avec un "dest =" bar "est appelé" bar ". Lorsqu'un argument optionnel --foo nécessite un argument de ligne de commande, Son argument est appelé «FOO».

Un autre nom peut être spécifié comme «metavar».

>>> parser = argparse.ArgumnetParser()
>>> 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

Si vous spécifiez nargs, vous pouvez passer un taple à metavar Vous pouvez spécifier un nom différent pour chaque argument.

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

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

ArgumentParser sélectionne la première longue chaîne d'options et remplace le début -- En le supprimant, la valeur de «dest» est générée.

Si aucune chaîne d'options longue n'est spécifiée, commencez par la première chaîne d'options courte Générez un dest en supprimant le caractère- principal.

Tous les caractères -, à l'exception du début, sont convertis en _ afin qu'ils soient des noms d'attributs valides.

Pour donner un nom d'attribut personnalisé à dest, procédez comme suit.

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', dest='bar')
>>> parser.parse_args('--foo XXX'.split())
Namespace(bar='XXX')