所有子解析器的可选参数

Question

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

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 循环中为每个位置创建位置参数，这似乎不是最好的方法。因为否则，它只会将可选参数添加到最后一个子解析器。

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 运行s

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获取子解析器设置的默认值。主解析器解析了--foo，但是它的值被子解析器覆盖了。

bug/issues 中对此进行了一些讨论。 http://bugs.python.org/issue9351 更改了处理方式，使子解析器默认值优先于主解析器值。我认为那个补丁有问题，但它已经生效了几年。

如果他们被赋予不同的 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 必须以正确的顺序给出。子解析器 cmd 实际上是 main.

的位置

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

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

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

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

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

但是如果我使用 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)

运行s

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 问题的影响。

所有子解析器的可选参数

Optional arguments across all subparsers

argparse

python-3.x