python-3.x - 所有子解析器的可选参数

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 文档，我无法找到使可选参数全局的方法。

我正在为 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 次

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，但是它的值被子解析器覆盖了。

在错误/问题中已经对此进行了一些讨论。 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')

复合用法看起来像:

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

必须以正确的顺序给出相应的位置。子解析器 cmd 实际上是 main 的位置。

为 main 定义的可选项必须出现在子解析器名称之前。为子解析器定义的 optional 必须出现在之后。它们可以有相同的 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)

运行

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