Question

例如，对于GNU --color[=WHEN]，您可以使用ls选项控制着色。现在在这种情况下，等号是至关重要的，因为--color必须区分ls --color的可选参数和位置参数（这是要列出的文件）。这是ls --color=always列出带有颜色的文件，与ls --color always相同，但always会列出文件argparse（以及颜色）。

现在我已经看到--longopt <argument>似乎接受了使用myls语法的长选项的参数，这将导致无法使参数成为可选参数。也就是说，如果我尝试使用与GNU ls相同的行为来实现myls --color always（这只是一个例子）我会遇到问题，因为现在myls --color=always意味着与{相同} {1}}（并且不是必需--color没有参数而always是位置参数。）

我知道我可以使用myls --color -- always来规避这一点，但是如果没有这种解决方法，有没有办法让这项工作成功？这是告诉argparse --color的参数必须提供--color[=WHEN]语法。

请注意，我不想依赖--color选项具有有限数量的有效参数这一事实。以下是我尝试过的无法正常工作的示例：

import argparse

parser = argparse.ArgumentParser()

parser.add_argument("--foo",
                    action="store",
                    nargs="?")
parser.add_argument("frob",
                    action="store",
                    nargs=argparse.REMAINDER)

print(parser.parse_args(["alpha", "beta"]))
print(parser.parse_args(["--foo", "alpha", "beta"]))
print(parser.parse_args(["--foo=bar", "alpha", "beta"]))

输出：

Namespace(foo=None, frob=['alpha', 'beta'])
Namespace(foo='alpha', frob=['beta'])
Namespace(foo='bar', frob=['alpha', 'beta'])

注意第alpha被解释为--foo的参数。我想：

Namespace(foo=None, frob=['alpha', 'beta'])
Namespace(foo=None, frob=['alpha', 'beta'])
Namespace(foo='bar', frob=['alpha', 'beta'])

Answer 1

显然这是不可能的。 GNU getopt（）（man getopt，man 3 getopt）支持此行为。 man getopt说：

如果[long]选项有一个可选参数，则必须在long选项名称后直接写入，用＆＃39; =＆＃39;分隔，如果存在

然而，Python getopt模块很清楚它不支持这个：

不支持[在长选项中]的可选参数。

argparse我在手册中找不到任何具体的参考资料，但如果它支持，我会感到惊讶。事实上，我很惊讶GNU getopt支持它，ls按照你描述的方式工作。用户界面应该很简单，这种行为远非简单。

Answer 2

您可能已经尝试了?可选项，然后是所需的位置：

 p=argparse.ArgumentParser()
 p.add_argument('--foo', nargs='?',default='one', const='two')
 p.add_argument('bar')

以

失败

In [7]: p.parse_args('--foo 1'.split())
usage: ipython3 [-h] [--foo [FOO]] bar
ipython3: error: the following arguments are required: bar

--foo消费1，不为bar留下任何内容。

http://bugs.python.org/issue9338讨论了这个问题。 nargs='?'贪婪，消耗一个参数，即使以下位置需要一个参数。但建议的补丁很复杂，因此我无法快速将其应用于解析器并测试您的案例。

定义一个可以与--foo==value一起使用但不在value中使用--foo value的动作的想法很有意思，但我不知道它需要实现什么。当然它不能与当前的解析器一起使用。我必须检查它如何处理明确的=。

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

通过更改parse_args中的深层嵌套函数，

    def consume_optional(....):
        ....
                # error if a double-dash option did not use the
                # explicit argument
                else:
                    msg = _('ignored explicit argument %r')
                    #raise ArgumentError(action, msg % explicit_arg)
                    # change for stack40989413
                    print('Warn ',msg)
                    stop = start_index + 1
                    args = [explicit_arg]
                    action.nargs=None
                    action_tuples.append((action, args, option_string))
                    break

并添加自定义Action类：

class MyAction(myparse._StoreConstAction):
    # requies change in consume_optional
    def __call__(self, parser, namespace, values, option_string=None):
        if values:
            setattr(namespace, self.dest, values)
        else:
            setattr(namespace, self.dest, self.const)

我可以从以下方式获得所需的行为：

p = myparse.ArgumentParser()
p.add_argument('--foo', action=MyAction, const='C', default='D')
p.add_argument('bar')

基本上我修改store_const以保存=explicit_arg（如果有）。

我不打算将此作为正式补丁提出，但如果有用，我会欢迎您提供反馈。使用风险由您自己承担。：）

Answer 3

这是一个解决方法：

#!/usr/bin/python

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("files", nargs="*", help="List of files", type=str)
parser.add_argument('--color', dest='color', action='store_true')
parser.add_argument('--color=ALWAYS', dest='color_always', action='store_true')

args = parser.parse_args()
print args

结果：

[~]$ ./test.py xyz --color
Namespace(color=True, color_always=False, files=['xyz'])
[~]$ ./test.py xyz --color=ALWAYS
Namespace(color=False, color_always=True, files=['xyz'])

Answer 4

问题已解决！ 有点（很多）hacky，但是你去了。

该解决方案围绕一个继承_StoreConstAction并对其稍作调整的类，但主要是在尝试获取其属性时欺骗了帮助格式化程序。

我在Windows和Linux下的python3中对此进行了测试。

import argparse
import inspect

class GnuStyleLongOption(argparse._StoreConstAction):
    def __init__(self, **kw):
        self._real_option_strings = kw['option_strings']
        opts = []
        for option_string in self._real_option_strings:
            opts.append(option_string)
            for choice in kw['choices']:
                opts.append(f'{option_string}={choice}')
        kw['option_strings'] = opts
        self.choices = kw.pop('choices')
        help_choices = [f"'{choice}'" for choice in self.choices]
        kw['help'] += f"; {kw['metavar']} is {', or '.join([', '.join(help_choices[:-1]), help_choices[-1]])}"
        super(GnuStyleLongOption, self).__init__(**kw)

    def __getattribute__(self, attr):
        caller_is_argparse_help = False
        for frame in inspect.stack():
            if frame.function == 'format_help' and frame.filename.endswith('argparse.py'):
                caller_is_argparse_help = True
                break

        if caller_is_argparse_help:
            if attr == 'option_strings':
                return [f'{i}[=WHEN]' for i in self._real_option_strings]
            if attr == 'nargs':
                return 0
            if attr == 'metavar':
                return None

        return super(GnuStyleLongOption, self).__getattribute__(attr)

    def __call__(self, parser, namespace, values, option_string=None):
        setattr(namespace, self.dest, self.const if '=' not in option_string else option_string[option_string.find('=') + 1:])

p = argparse.ArgumentParser()
p.add_argument('--color', '--colour', action=GnuStyleLongOption, choices=['always', 'never', 'auto'], const='always', default='auto', help='use markers to highlight whatever we want', metavar='WHEN')
p.add_argument('filenames', metavar='filename', nargs='*', help='file to process')
args = p.parse_args()

print(f'color = {args.color}, filenames = {args.filenames}')

结果：

~ $ ./gnu_argparse.py --help
usage: gnu_argparse.py [-h] [--color[=WHEN]] [filename [filename ...]]

positional arguments:
  filename              file to process

optional arguments:
  -h, --help            show this help message and exit
  --color[=WHEN], --colour[=WHEN]
                        use markers to highlight whatever we want; WHEN is
                        'always', 'never', or 'auto'

~ $ ./gnu_argparse.py
color = auto, filenames = []

~ $ ./gnu_argparse.py file
color = auto, filenames = ['file']

~ $ ./gnu_argparse.py --color file
color = always, filenames = ['file']

~ $ ./gnu_argparse.py --color never file
color = always, filenames = ['never', 'file']

~ $ ./gnu_argparse.py --color=never file
color = never, filenames = ['file']

~ $ ./gnu_argparse.py --colour=always file
color = always, filenames = ['file']

Answer 5

也许nargs会有所帮助。

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--color', nargs='?', const='c', default='d')
>>> parser.parse_args(['XX', '--color', 'always'])
Namespace(bar='XX', color='always')
>>> parser.parse_args(['XX', '--color'])
Namespace(bar='XX', color='c')
>>> parser.parse_args([])
Namespace(bar='d', color='d')

使用nargs，你得到不同的args，你就会知道输入类型是什么。

顺便说一下，我认为--color选项可以使用action='store_true'。

parser.add_argument('--color', action='store_true')

在argparse中使用GNU样式的长选项（不会将可选参数与位置混淆）

5 个答案: