argparse是否提供了内置工具，可以将组或解析器解析为自己的命名空间？我觉得我必须在某个地方错过一个选项。
编辑：这个例子可能不是我应该做的，以构建解析器以实现我的目标，但这是我迄今为止所做的。我的具体目标是能够为子解析器提供被解析为命名空间字段的选项组。我与父母的想法只是为了同样的目的使用共同的选项。
示例：
import argparse
# Main parser
main_parser = argparse.ArgumentParser()
main_parser.add_argument("-common")
# filter parser
filter_parser = argparse.ArgumentParser(add_help=False)
filter_parser.add_argument("-filter1")
filter_parser.add_argument("-filter2")
# sub commands
subparsers = main_parser.add_subparsers(help='sub-command help')
parser_a = subparsers.add_parser('command_a', help="command_a help", parents=[filter_parser])
parser_a.add_argument("-foo")
parser_a.add_argument("-bar")
parser_b = subparsers.add_parser('command_b', help="command_b help", parents=[filter_parser])
parser_b.add_argument("-biz")
parser_b.add_argument("-baz")
# parse
namespace = main_parser.parse_args()
print namespace
这就是我得到的，显然：
$ python test.py command_a -foo bar -filter1 val
Namespace(bar=None, common=None, filter1='val', filter2=None, foo='bar')
但这就是我真正追求的目标：
Namespace(bar=None, common=None, foo='bar',
filter=Namespace(filter1='val', filter2=None))
然后更多的选项组已经解析为名称空间：
Namespace(common=None,
foo='bar', bar=None,
filter=Namespace(filter1='val', filter2=None),
anotherGroup=Namespace(bazers='val'),
anotherGroup2=Namespace(fooers='val'),
)
我找到了related question here，但它涉及一些自定义解析，似乎只涵盖了一个非常具体的情况。
是否有一个选项可以告诉argparse将某些组解析为命名空间字段？
答案 0 :(得分：10)
如果重点只是将选定的参数放在他们自己的namespace中，并且子问题（和父母）的使用是这个问题的偶然事件，那么这个自定义操作可能会解决问题。
class GroupedAction(argparse.Action):
def __call__(self, parser, namespace, values, option_string=None):
group,dest = self.dest.split('.',2)
groupspace = getattr(namespace, group, argparse.Namespace())
setattr(groupspace, dest, values)
setattr(namespace, group, groupspace)
有多种方法可以指定group名称。它可以在定义Action时作为参数传递。它可以作为参数添加。在这里，我选择从dest解析它（因此namespace.filter.filter1可以获得filter.filter1的值。
# Main parser
main_parser = argparse.ArgumentParser()
main_parser.add_argument("-common")
filter_parser = argparse.ArgumentParser(add_help=False)
filter_parser.add_argument("--filter1", action=GroupedAction, dest='filter.filter1', default=argparse.SUPPRESS)
filter_parser.add_argument("--filter2", action=GroupedAction, dest='filter.filter2', default=argparse.SUPPRESS)
subparsers = main_parser.add_subparsers(help='sub-command help')
parser_a = subparsers.add_parser('command_a', help="command_a help", parents=[filter_parser])
parser_a.add_argument("--foo")
parser_a.add_argument("--bar")
parser_a.add_argument("--bazers", action=GroupedAction, dest='anotherGroup.bazers', default=argparse.SUPPRESS)
...
namespace = main_parser.parse_args()
print namespace
我必须添加default=argparse.SUPPRESS，因此bazers=None条目不会出现在主命名空间中。
结果：
>>> python PROG command_a --foo bar --filter1 val --bazers val
Namespace(anotherGroup=Namespace(bazers='val'),
bar=None, common=None,
filter=Namespace(filter1='val'),
foo='bar')
如果您需要嵌套命名空间中的默认条目，则可以先手动定义命名空间：
filter_namespace = argparse.Namespace(filter1=None, filter2=None)
namespace = argparse.Namespace(filter=filter_namespace)
namespace = main_parser.parse_args(namespace=namespace)
结果与以前一样，除了：
filter=Namespace(filter1='val', filter2=None)
答案 1 :(得分：7)
我不完全确定你在问什么，但我认为你想要的是argument group或sub-command将其参数放入子命名空间。
据我所知，argparse并不是开箱即用的。但是，只要你愿意在底层挖掘一下，通过后处理结果真的不难做到。 （我猜通过子类ArgumentParser更容易做到这一点，但你明确表示你不想这样做，所以我没有尝试过。）
parser = argparse.ArgumentParser()
parser.add_argument('--foo')
breakfast = parser.add_argument_group('breakfast')
breakfast.add_argument('--spam')
breakfast.add_argument('--eggs')
args = parser.parse_args()
现在，breakfast选项的所有目的地列表为：
[action.dest for action in breakfast._group_actions]
args中的键值对是：
args._get_kwargs()
所以，我们所要做的就是移动匹配的那些。如果我们构建字典来创建命名空间，那将会更容易：
breakfast_options = [action.dest for action in breakfast._group_actions]
top_names = {name: value for (name, value) in args._get_kwargs()
if name not in breakfast_options}
breakfast_names = {name: value for (name, value) in args._get_kwargs()
if name in breakfast_options}
top_names['breakfast'] = argparse.Namespace(**breakfast_names)
top_namespace = argparse.Namespace(**top_names)
就是这样; top_namespace看起来像：
Namespace(breakfast=Namespace(eggs=None, spam='7'), foo='bar')
当然，在这种情况下，我们有一个静态组。如果您想要更通用的解决方案怎么办？简单。 parser._action_groups是所有组的列表，但前两个是全局位置和关键字组。所以，只需迭代parser._action_groups[2:]，对上面为breakfast所做的每一项做同样的事情。
子命令而不是组怎么样？类似，但细节不同。如果你保留了每个subparser对象，那就是整个ArgumentParser。如果没有，但你确实保留了subparsers对象，那么它是Action的一种特殊类型，其choices是一个dict，其键是subparser名称，其值是subparser本身。如果你不保留......从parser._subparsers开始并从那里弄明白。
无论如何，一旦你知道如何找到你想要移动的名字以及你想要移动它们的位置，它就与群组相同。
除了全局args和/或组以及特定于subparser的args和/或组之外，还有一些由多个subparser共享的组......然后从概念上讲它会变得棘手，因为每个subparser都会以引用结束对同一组，你不能把它移到他们身上。但幸运的是，您只处理一个subparser（或者没有），因此您可以忽略其他subparser并移动所选子分段下的任何共享组（以及不的任何组）在选定的子分析符中，要么离开顶部，要么丢弃，或者任意选择一个subparser。
答案 2 :(得分：6)
使用Action子类嵌套适用于一种类型的Action，但如果您需要子类化几种类型（存储，存储true，追加等），则会很麻烦。这是另一个想法 - 子类命名空间。执行相同类型的名称split和setattr，但是在命名空间而不是Action中执行。然后只需创建新类的实例，并将其传递给parse_args。
class Nestedspace(argparse.Namespace):
def __setattr__(self, name, value):
if '.' in name:
group,name = name.split('.',1)
ns = getattr(self, group, Nestedspace())
setattr(ns, name, value)
self.__dict__[group] = ns
else:
self.__dict__[name] = value
p = argparse.ArgumentParser()
p.add_argument('--foo')
p.add_argument('--bar', dest='test.bar')
print(p.parse_args('--foo test --bar baz'.split()))
ns = Nestedspace()
print(p.parse_args('--foo test --bar baz'.split(), ns))
p.add_argument('--deep', dest='test.doo.deep')
args = p.parse_args('--foo test --bar baz --deep doodod'.split(), Nestedspace())
print(args)
print(args.test.doo)
print(args.test.doo.deep)
Namespace(foo='test', test.bar='baz')
Nestedspace(foo='test', test=Nestedspace(bar='baz'))
Nestedspace(foo='test', test=Nestedspace(bar='baz', doo=Nestedspace(deep='doodod')))
Nestedspace(deep='doodod')
doodod
此命名空间的__getattr__（计数和附加等操作所需）可以是：
def __getattr__(self, name):
if '.' in name:
group,name = name.split('.',1)
try:
ns = self.__dict__[group]
except KeyError:
raise AttributeError
return getattr(ns, name)
else:
raise AttributeError
我已经提出了其他几个选项，但最好这样。它将存储详细信息放在命名空间中，而不是解析器。
答案 3 :(得分：1)
从abarnert的回答开始，我将以下MWE ++ ;-)放在一起，处理具有相似选项名称的多个配置组。
#!/usr/bin/env python2
import argparse, re
cmdl_skel = {
'description' : 'An example of multi-level argparse usage.',
'opts' : {
'--foo' : {
'type' : int,
'default' : 0,
'help' : 'foo help main',
},
'--bar' : {
'type' : str,
'default' : 'quux',
'help' : 'bar help main',
},
},
# Assume your program uses sub-programs with their options. Argparse will
# first digest *all* defs, so opts with the same name across groups are
# forbidden. The trick is to use the module name (=> group.title) as
# pseudo namespace which is stripped off at group parsing
'groups' : [
{ 'module' : 'mod1',
'description' : 'mod1 description',
'opts' : {
'--mod1-foo, --mod1.foo' : {
'type' : int,
'default' : 0,
'help' : 'foo help for mod1'
},
},
},
{ 'module' : 'mod2',
'description' : 'mod2 description',
'opts' : {
'--mod2-foo, --mod2.foo' : {
'type' : int,
'default' : 1,
'help' : 'foo help for mod2'
},
},
},
],
'args' : {
'arg1' : {
'type' : str,
'help' : 'arg1 help',
},
'arg2' : {
'type' : str,
'help' : 'arg2 help',
},
}
}
def parse_args ():
def _parse_group (parser, opt, **optd):
# digest variants
optv = re.split('\s*,\s*', opt)
# this may rise exceptions...
parser.add_argument(*optv, **optd)
errors = {}
parser = argparse.ArgumentParser(description=cmdl_skel['description'],
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
# it'd be nice to loop in a single run over zipped lists, but they have
# different lenghts...
for opt in cmdl_skel['opts'].keys():
_parse_group(parser, opt, **cmdl_skel['opts'][opt])
for arg in cmdl_skel['args'].keys():
_parse_group(parser, arg, **cmdl_skel['args'][arg])
for grp in cmdl_skel['groups']:
group = parser.add_argument_group(grp['module'], grp['description'])
for mopt in grp['opts'].keys():
_parse_group(group, mopt, **grp['opts'][mopt])
args = parser.parse_args()
all_group_opts = []
all_group_names = {}
for group in parser._action_groups[2:]:
gtitle = group.title
group_opts = [action.dest for action in group._group_actions]
all_group_opts += group_opts
group_names = {
# remove the leading pseudo-namespace
re.sub("^%s_" % gtitle, '', name) : value
for (name, value) in args._get_kwargs()
if name in group_opts
}
# build group namespace
all_group_names[gtitle] = argparse.Namespace(**group_names)
# rebuild top namespace
top_names = {
name: value for (name, value) in args._get_kwargs()
if name not in all_group_opts
}
top_names.update(**all_group_names)
top_namespace = argparse.Namespace(**top_names)
return top_namespace
def main():
args = parse_args()
print(str(args))
print(args.bar)
print(args.mod1.foo)
if __name__ == '__main__':
main()
然后你可以像这样调用它（助记符：--mod1-...是“mod1”等的选项）：
$ ./argparse_example.py one two --bar=three --mod1-foo=11231 --mod2.foo=46546
Namespace(arg1='one', arg2='two', bar='three', foo=0, mod1=Namespace(foo=11231), mod2=Namespace(foo=46546))
three
11231
答案 4 :(得分：0)
在这个脚本中，我修改了argparse._SubParsersAction的__call__方法。它不是将namespace传递给subparser，而是传递一个新的。然后它将其添加到主namespace。我只更改了3行__call__。
import argparse
def mycall(self, parser, namespace, values, option_string=None):
parser_name = values[0]
arg_strings = values[1:]
# set the parser name if requested
if self.dest is not argparse.SUPPRESS:
setattr(namespace, self.dest, parser_name)
# select the parser
try:
parser = self._name_parser_map[parser_name]
except KeyError:
args = {'parser_name': parser_name,
'choices': ', '.join(self._name_parser_map)}
msg = _('unknown parser %(parser_name)r (choices: %(choices)s)') % args
raise argparse.ArgumentError(self, msg)
# CHANGES
# parse all the remaining options into a new namespace
# store any unrecognized options on the main namespace, so that the top
# level parser can decide what to do with them
newspace = argparse.Namespace()
newspace, arg_strings = parser.parse_known_args(arg_strings, newspace)
setattr(namespace, 'subspace', newspace) # is there a better 'dest'?
if arg_strings:
vars(namespace).setdefault(argparse._UNRECOGNIZED_ARGS_ATTR, [])
getattr(namespace, argparse._UNRECOGNIZED_ARGS_ATTR).extend(arg_strings)
argparse._SubParsersAction.__call__ = mycall
# Main parser
main_parser = argparse.ArgumentParser()
main_parser.add_argument("--common")
# sub commands
subparsers = main_parser.add_subparsers(dest='command')
parser_a = subparsers.add_parser('command_a')
parser_a.add_argument("--foo")
parser_a.add_argument("--bar")
parser_b = subparsers.add_parser('command_b')
parser_b.add_argument("--biz")
parser_b.add_argument("--baz")
# parse
input = 'command_a --foo bar --bar val --filter extra'.split()
namespace = main_parser.parse_known_args(input)
print namespace
input = '--common test command_b --biz bar --baz val'.split()
namespace = main_parser.parse_args(input)
print namespace
这会产生：
(Namespace(command='command_a', common=None,
subspace=Namespace(bar='val', foo='bar')),
['--filter', 'extra'])
Namespace(command='command_b', common='test',
subspace=Namespace(baz='val', biz='bar'))
我使用parse_known_args来测试额外字符串如何传递回主解析器。
我删除了parents内容，因为它没有为此命名空间更改添加任何内容。它只是一种方便的方法来定义几个子分析器使用的一组参数。 argparse未记录通过parents添加了哪些参数，以及哪些参数是直接添加的。它不是分组工具
argument_groups也没什么帮助。它们由帮助格式化程序使用，但不是由parse_args使用。
我可以继承_SubParsersAction（而不是重新分配__call__），但我已经更改了main_parse.register。
答案 5 :(得分：0)
请查看argpext module上的PyPi，它可能对您有帮助！
答案 6 :(得分：0)
基于@abarnert的回答，我编写了一个简单的函数，可以完成OP的需求：
from argparse import Namespace, ArgumentParser
def parse_args(parser):
assert isinstance(parser, ArgumentParser)
args = parser.parse_args()
# the first two argument groups are 'positional_arguments' and 'optional_arguments'
pos_group, optional_group = parser._action_groups[0], parser._action_groups[1]
args_dict = args._get_kwargs()
pos_optional_arg_names = [arg.dest for arg in pos_group._group_actions] + [arg.dest for arg in optional_group._group_actions]
pos_optional_args = {name: value for name, value in args_dict if name in pos_optional_arg_names}
other_group_args = dict()
# If there are additional argument groups, add them as nested namespaces
if len(parser._action_groups) > 2:
for group in parser._action_groups[2:]:
group_arg_names = [arg.dest for arg in group._group_actions]
other_group_args[group.title] = Namespace(**{name: value for name, value in args_dict if name in group_arg_names})
# combine the positiona/optional args and the group args
combined_args = pos_optional_args
combined_args.update(other_group_args)
return Namespace(**combined_args)
您只需为其提供ArgumentParser实例，它就会根据参数的组结构返回嵌套的NameSpace。