从argparse解包参数

Question

我一直在编写一些命令行python程序并使用argparse它来做.我一直在构建我的代码,如下所示.

def main(arg1, arg2):
    # magic
    pass

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('arg1')
    parser.add_argument('arg2')

    args = parser.parse_args()

    main(args.arg1, args.arg2)

这真是超级刺激得叫出来arg1和arg23倍.我明白必须做两次.

有没有办法将parse_args函数返回的命名空间视为元组？或者更好的是作为可选args的元组和字典并进行解包？

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('arg1')
    parser.add_argument('arg2')
    parser.add_argument('--opt-arg', default='default_value')

    args, kwargs = parser.magic_method_call_that_would_make_my_life_amazing()

    # I get goosebumps just thinking about this
    main(*args, **kwargs)

Answer 1

https://docs.python.org/3/library/argparse.html#the-namespace-object

这个类是故意简单的,只是一个带有可读字符串表示的对象子类.如果您希望使用类似dict的属性视图,则可以使用标准Python惯用法,即vars():

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> args = parser.parse_args(['--foo', 'BAR'])
>>> vars(args)
{'foo': 'BAR'}

注意在至少那一个大的进步,或变化,从optparse到 argparse的是,位置参数,如你的,被处理过的一样自选.它们都出现在args Namespace对象中.在optparse,定位只是解析定义选项的剩余部分.您可以argparse通过省略参数并使用parse_known_args以下方法获得相同的效果:

parser = argparse.ArgumentParser()
args, extras = parser.parse_known_args()

args现在是一个命名空间和extras一个列表.然后,您可以将您的功能称为:

myfoo(*extras, **vars(args))

例如:

In [994]: import argparse
In [995]: def foo(*args, **kwargs):
   .....:     print(args)
   .....:     print(kwargs)
   .....:     
In [996]: parser=argparse.ArgumentParser()
In [997]: parser.add_argument('-f','--foo')
Out[997]: _StoreAction(option_strings=['-f', '--foo'], dest='foo', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)
In [998]: args,extras = parser.parse_known_args(['-f','foobar','arg1','arg2'])
In [999]: args
Out[999]: Namespace(foo='foobar')
In [1000]: extras
Out[1000]: ['arg1', 'arg2']
In [1001]: foo(*extras, **vars(args))
('arg1', 'arg2')
{'foo': 'foobar'}

同argparse一段显示您可以定义自己的Namespace类.定义一个行为类似字典(用作**args)和命名空间的并不难.所有argparse要求是它与getattr和一起使用setattr.

In [1002]: getattr(args,'foo')
Out[1002]: 'foobar'
In [1004]: setattr(args,'bar','ugg')
In [1005]: args
Out[1005]: Namespace(bar='ugg', foo='foobar')

另一个标准的Python功能让我vars(args)作为一个元组传递:

In [1013]: foo(*vars(args).items())
(('foo', 'foobar'), ('bar', 'ugg'))
{}

对于去年1月的类似答案:https://stackoverflow.com/a/34932478/901925

整齐地将位置参数作为args和可选参数传递为从argpase到函数的kwargs

在那里,我提出了如何在解析后将"位置"与"选项"分开的想法.

这是一个自定义命名空间类,在其API中包含一种将自身返回为字典的方法:

In [1014]: class MyNameSpace(argparse.Namespace):
   ......:     def asdict(self):
   ......:         return vars(self)
   ......:     
In [1015]: args = parser.parse_args(['-f','foobar'], namespace=MyNameSpace())
In [1016]: args
Out[1016]: MyNameSpace(foo='foobar')
In [1017]: foo(**args.asdict())
()
{'foo': 'foobar'}

另一个想法 - 使用多个nargs(2,'*','+')中的一个作为位置参数.然后,在将其传递给函数时,只需键入一个名称.

parser.add_argument('pos',nargs='+')
args = ...
args.pos # a list, possibly empty
foo(*args.pos, **vars(args))

Answer 2

你可以在这里看到类似的问题.

编辑:寻找一种不使用内部方法的方法,我发现这个讨论建议使用vars().这非常有效:

import argparse

def main(arg1, arg2):
    print arg1, arg2

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('arg1')
    parser.add_argument('arg2')

    args = parser.parse_args()
    main(**vars(args))

Answer 3

这样做有什么问题

if __name__ == '__main__':
    # do argparse stuff as above
    main(args)

也就是说,为什么你如此忙于提出main()位置论证？

说实话,我通常在模块的开头解析a)[对于小脚本等],它为我提供了一个在所有函数范围内的变量,或b)[通常]在main()我使用的内部你的成语:

def parse_arguments():
    parser = argparse.ArgumentParser()
    parser.add_argument('arg1')
    parser.add_argument('arg2')
    args = parser.parse_args()
    return args

def main():
    args = parse_arguments()
    # do stuff with args.arg1 and args.arg2