python argh/argparse: Comment puis-je passer d'une liste comme un argument de ligne de commande?

Je suis en train de passer d'une liste d'arguments d'un script python à l'aide de la argh bibliothèque. Quelque chose qui peut prendre des intrants tels que:

./my_script.py my-func --argA blah --argB 1 2 3 4
./my_script.py my-func --argA blah --argB 1
./my_script.py my-func --argA blah --argB

Mon code ressemble à ceci:

import argh

@argh.arg('--argA', default="bleh", help='My first arg')
@argh.arg('--argB', default=[], help='A list-type arg--except it\'s not!')
def my_func(args):
    "A function that does something"

    print args.argA
    print args.argB

    for b in args.argB:
        print int(b)*int(b)  #Print the square of each number in the list
    print sum([int(b) for b in args.argB])  #Print the sum of the list

p = argh.ArghParser()
p.add_commands([my_func])
p.dispatch()

Et voici comment il se comporte:

$ python temp.py my-func --argA blooh --argB 1
blooh
['1']
1
1

$ python temp.py my-func --argA blooh --argB 10
blooh
['1', '0']
1
0
1

$ python temp.py my-func --argA blooh --argB 1 2 3
usage: temp.py [-h] {my-func} ...
temp.py: error: unrecognized arguments: 2 3

Le problème semble assez simple: argh est seulement en acceptant le premier argument, et la traiter comme une chaîne de caractères. Comment puis-je faire "s'attendre à" une liste d'entiers à la place?

Je vois comment cela se fait dans optparse, mais que dire de la (non-déconseillé) argparse? Ou en utilisant argh est beaucoup plus agréable, décoré de la syntaxe? Ceux-ci semblent beaucoup plus pythonic.

InformationsquelleAutor Abe | 2012-02-22
  1. 82

    Avec argparse, il vous suffit d'utiliser type=int

    import argparse

parser = argparse.ArgumentParser()
parser.add_argument('-a', '--arg', nargs='+', type=int)
print parser.parse_args()

    Exemple de sortie:

    $ python test.py -a 1 2 3
Namespace(arg=[1, 2, 3])

    Edit: je ne suis pas familier avec argh, mais il semble être juste un wrapper autour de argparse et cela a fonctionné pour moi:

    import argh

@argh.arg('-a', '--arg', nargs='+', type=int)
def main(args):
    print args

parser = argh.ArghParser()
parser.add_commands([main])
parser.dispatch()

    Exemple de sortie:

    $ python test.py main -a 1 2 3
Namespace(arg=[1, 2, 3], function=<function main at 0x.......>)
    • Génial! J'ai modifié le code pour inclure la ligne: @argh.arg('--argB', par défaut=[], help='A list-type arg--sauf si c\'est pas!", nargs='+', type=int) et argh aimé. Merci pour l'aide!
    • Yep, c'est la manière correcte. Les versions récentes de Argh également en charge le "naturel", plus pythonic notation: func(argA, *argB) (si *args cartes à nargs='*' au lieu de nargs='+').
    • Je vois que quand j'utilise nargs= , je ne peux pas faire -un=1 2 3 . Ce que je veux dire, c'est que l'utilisation de '=' après l'argument metavar. Toute solution à me laisser utiliser = pour chaque arg. Par ex dans votre exemple, je veux le faire , python test.py -un=1 2 3
    • Mikhaylenko La question ci-dessus.
    • Je ne connais pas de moyen simple de le faire. Une alternative pourrait être quelque chose comme: parser.add_argument('-a', '--arg', type=lambda s: [int(n) for n in s.split()]) et appeler le script à l'aide de citations: python test.py --arg="1 2 3"
    • le problème est dans la = caractère. -a 1 2 signifie "a = [1, 2]", tandis que -a=1 2 signifie "un = 1; quelques-position d'argument = 2".

    InformationsquelleAutor jcollado
  2. 1

    J'afin d'avoir accès à chaque valeur de paramètre, le code suivant peut être utile.

    import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-a', '--arg', nargs='+', type=int)
args = vars(parser.parse_args())

print "first parameter:" + str(args["arg"][0])
print "second parameter:" + str(args["arg"][1])
print "third parameter:" + str(args["arg"][2])
    InformationsquelleAutor Luis Jose