Question

我目前正在测试argparse用法，但它没有按预期工作。我有几个subparser和可选参数，按以下方式调用：

python3 myprogram.py positional argument --optional something

# Outcome
Namespace(optional='something')

如果可选项是最后一个，程序按预期工作，但如果它是任何其他顺序，则被丢弃。

python3 myprogram.py positional --optional argument
python3 myprogram.py --optional positional argument

# Outcome
Namespace(optional=None)

通过查看argparse文档，我无法找到一种方法来创建可选参数 global 。

我为for循环中的每个位置创建位置参数，这似乎不是最好的方法。否则，它会将可选参数仅添加到最后一个subparser。

import argparse

class Parsing(object):

    def __init__(self):

        parser = argparse.ArgumentParser(prog='python3 myprogram.py',
            formatter_class=argparse.RawDescriptionHelpFormatter,
            description='some description')

        self.subparser = parser.add_subparsers(title='Positional', help='help description')

        for sub in self.Generate(): # Method with a bunch of subparsers
            self.Subparser(sub)

    def Subparser(self, parsers):

        for each in sorted(parsers):
            positional = subparser.add_parser(each)
            self.Optional(positional) # Method with some optional arguments for each of the second subparsers

        self.Optional(parser) # Adding the optional arguments to the first subparser

    def Optional(self, parser):

        # ... Optional arguments

    def Generate(self):

        # ... Subparsers

我可能在上面的例子中遗漏了一些代码，试图简化我能做的最好的事情并希望它能被察觉。

问题：有没有办法在所有子分析符中创建可选参数？

Answer 1

您的描述和代码很难理解，但我的结论是，您的问题在于当主要和子分析者共享参数dest时如何处理默认值。

我压缩了你的代码，所以我可以进行测试运行：

import argparse
class Parsing(object):
    def __init__(self):
        self.parser = argparse.ArgumentParser(prog='prog',
            description='some description')
        self.subparser = self.parser.add_subparsers(dest='cmd', title='Cmds', help='help description')
        self.make_subparsers(['cmd1','cmd2'])

    def make_subparsers(self, parsers):
        for each in parsers:
            subp = self.subparser.add_parser(each)
            self.optional(subp, default='sub') 
        self.optional(self.parser, default='main') 

    def optional(self, parser, default=None):
        parser.add_argument('--foo', default=default)

args = Parsing().parser.parse_args()
print(args)

我参加了2次

1315:~/mypy$ python3.5 stack41431025.py cmd1 --foo 1
Namespace(cmd='cmd1', foo='1')

1316:~/mypy$ python3.5 stack41431025.py --foo 1 cmd1
Namespace(cmd='cmd1', foo='sub')

在第一个中，foo由cmd1子分析器解析的字符串设置。

在第二个中，foo获取subparser设置的默认值。主解析器解析了--foo，但它的值被subparser覆盖了。

在bug /问题中已经对此进行了一些讨论。 http://bugs.python.org/issue9351更改了处理，以便subparser默认优先于主解析器值。我认为这个补丁存在问题，但它已经生效了几年。

如果给予不同的dest，则会保留更多控制权。

def make_subparsers(self, parsers):
    for each in parsers:
        subp = self.subparser.add_parser(each)
        self.optional(subp, default='sub') 
    self.optional(self.parser, default='main', dest='main_foo') 

def optional(self, parser, default=None, dest=None):
    parser.add_argument('--foo', default=default, dest=dest)

1325:~/mypy$ python3.5 stack41431025.py --foo 1 cmd1
Namespace(cmd='cmd1', foo='sub', main_foo='1')
1325:~/mypy$ python3.5 stack41431025.py cmd1
Namespace(cmd='cmd1', foo='sub', main_foo='main')
1325:~/mypy$ python3.5 stack41431025.py --foo 1 cmd1 --foo 2
Namespace(cmd='cmd1', foo='2', main_foo='1')

====================

（早期答案）

我将尝试绘制可能的参数组合

parser = argparse.ArgumentParser()
parser.add_argument('mainpos', help='positional for main')
parser.add_argument('--mainopt', help='optional defined for main')
sp = parser.add_subparser(dest='cmd')
p1 = sp.add_parser('cmd1')
p1.add_argument('subpos', help='postional for sub')
p1.add_argument('--subopt', help='optional defined for sub')

复合usage看起来像：

python prog.py foo [--mainopt bar] cmd1 sfoo [--subopt baz]

必须以正确的顺序给出相应的positionals。 subparser cmd实际上是main的位置。

为main定义的可选项必须在subparser名称之前发生。为子分析器定义的可选项必须在之后进行。它们可以具有相同的flag或dest，但必须单独定义。如果它们具有相同的dest，则可能存在价值冲突，尤其是默认值。

parser.parse_args()开始将输入字符串与其参数匹配。如果它看到--mainopt正在解析那个可选参数。否则它需要两个postionals。第二个必须是子名称之一。

获得一个subparser名称后，它会将剩余的字符串传递给该subparser。 subparser处理其余部分，并将值放在主命名空间中。 subparser做的第一件事就是设置默认值。该操作是否覆盖主解析器设置的值取决于namespace在两者之间的传递方式。

=====

解析由命令行中的参数顺序驱动。它尝试以任何顺序允许标记的参数。但是一旦将解析传递给subparser，主解析器就不会再解析了。它只是做了一些清理任务。

但是如果我使用parse_known_args，我可以收集两个解析器都没有处理的字符串，然后另一个解析它们。

parser1 = argparse.ArgumentParser()
parser1.add_argument('--foo')
sp = parser1.add_subparsers(dest='cmd')
sp1 = sp.add_parser('cmd1')
args, extra = parser1.parse_known_args()

parser2 = argparse.ArgumentParser()
parser2.add_argument('--foo')
if extra:
    args = parser2.parse_args(extra)
print(args)

运行

1815:~/mypy$ python stack41431025.py --foo 1 cmd1
Namespace(cmd='cmd1', foo='1')

1815:~/mypy$ python stack41431025.py cmd1 --foo 2
Namespace(foo='2')

1815:~/mypy$ python stack41431025.py --foo 1 cmd1 --foo 3
Namespace(foo='3')

我没有在任何更复杂的问题上测试过这个想法，所以可能会有一些我没有想过的互动。但这是我可以在任何地方发生的最接近的标记参数，并且不会遇到冲突的default问题。

所有子分析器

1 个答案: