实现所需功能的一种方法是从click.option继承并自定义解析器。

自定义类：

import click

class OptionEatAll(click.Option):

    def __init__(self, *args, **kwargs):
        self.save_other_options = kwargs.pop('save_other_options', True)
        nargs = kwargs.pop('nargs', -1)
        assert nargs == -1, 'nargs, if set, must be -1 not {}'.format(nargs)
        super(OptionEatAll, self).__init__(*args, **kwargs)
        self._previous_parser_process = None
        self._eat_all_parser = None

    def add_to_parser(self, parser, ctx):

        def parser_process(value, state):
            # method to hook to the parser.process
            done = False
            value = [value]
            if self.save_other_options:
                # grab everything up to the next option
                while state.rargs and not done:
                    for prefix in self._eat_all_parser.prefixes:
                        if state.rargs[0].startswith(prefix):
                            done = True
                    if not done:
                        value.append(state.rargs.pop(0))
            else:
                # grab everything remaining
                value += state.rargs
                state.rargs[:] = []
            value = tuple(value)

            # call the actual process
            self._previous_parser_process(value, state)

        retval = super(OptionEatAll, self).add_to_parser(parser, ctx)
        for name in self.opts:
            our_parser = parser._long_opt.get(name) or parser._short_opt.get(name)
            if our_parser:
                self._eat_all_parser = our_parser
                self._previous_parser_process = our_parser.process
                our_parser.process = parser_process
                break
        return retval

使用自定义类：

要使用自定义类，请将cls参数传递给@click.option()装饰器，如下所示：

@click.option("--an_option", cls=OptionEatAll)

或者如果希望该选项将吃掉命令行的整个剩余部分，而不考虑其它选项：

@click.option("--an_option", cls=OptionEatAll, save_other_options=False)

这是如何工作的？

这是因为click是一个设计良好的OO框架，@click.option()装饰器通常示例化click.Option对象，但允许使用cls参数覆盖此行为，因此在我们自己的类中继承click.Option并覆盖所需的方法是一件相对容易的事情。
在本例中，我们覆盖click.Option.add_to_parser()，猴子修补解析器，以便我们可以根据需要吃多个令牌。

测试代码：

@click.command()
@click.option('-g', 'greedy', cls=OptionEatAll, save_other_options=False)
@click.option('--polite', cls=OptionEatAll)
@click.option('--other')
def foo(polite, greedy, other):
    click.echo('greedy: {}'.format(greedy))
    click.echo('polite: {}'.format(polite))
    click.echo('other: {}'.format(other))

if __name__ == "__main__":
    commands = (
        '-g a b --polite x',
        '-g a --polite x y --other o',
        '--polite x y --other o',
        '--polite x -g a b c --other o',
        '--polite x --other o -g a b c',
        '-g a b c',
        '-g a',
        '-g',
        'extra',
        '--help',
    )

    import sys, time
    time.sleep(1)
    print('Click Version: {}'.format(click.__version__))
    print('Python Version: {}'.format(sys.version))
    for cmd in commands:
        try:
            time.sleep(0.1)
            print('-----------')
            print('> ' + cmd)
            time.sleep(0.1)
            foo(cmd.split())

        except BaseException as exc:
            if str(exc) != '0' and \
                    not isinstance(exc, (click.ClickException, SystemExit)):
                raise

测试结果：

Click Version: 6.7
Python Version: 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 18:11:49) [MSC v.1900 64 bit (AMD64)]
-----------
> -g a b --polite x
greedy: ('a', 'b', '--polite', 'x')
polite: None
other: None
-----------
> -g a --polite x y --other o
greedy: ('a', '--polite', 'x', 'y', '--other', 'o')
polite: None
other: None
-----------
> --polite x y --other o
greedy: None
polite: ('x', 'y')
other: o
-----------
> --polite x -g a b c --other o
greedy: ('a', 'b', 'c', '--other', 'o')
polite: ('x',)
other: None
-----------
> --polite x --other o -g a b c
greedy: ('a', 'b', 'c')
polite: ('x',)
other: o
-----------
> -g a b c
greedy: ('a', 'b', 'c')
polite: None
other: None
-----------
> -g a
greedy: ('a',)
polite: None
other: None
-----------
> -g
Error: -g option requires an argument
-----------
> extra
Usage: test.py [OPTIONS]

Error: Got unexpected extra argument (extra)
-----------
> --help
Usage: test.py [OPTIONS]

Options:
  -g TEXT
  --polite TEXT
  --other TEXT
  --help         Show this message and exit.

你可以使用这个技巧。

import click

@click.command()
@click.option('--users', nargs=0, required=True)
@click.argument('users', nargs=-1)
@click.option('--bar')
def fancy_command(users, bar):
    users_str = ', '.join(users)
    print('Users: {}. Bar: {}'.format(users_str, bar))

if __name__ == '__main__':
    fancy_command()

添加具有所需名称和无参数nargs=0的伪option，然后添加具有无限参数nargs=-1的“argument”。

$ python foo --users alice bob charlie --bar baz
Users: alice, bob, charlie. Bar: baz

但要小心进一步的选择：

$ python foo --users alice bob charlie --bar baz faz
Users: alice, bob, charlie, faz. Bar: baz

我也遇到了同样的问题。我没有实现一个带有n个参数的命令行选项，而是决定使用多个相同的命令行选项，并让Click在幕后用参数生成一个元组。我最终认为，如果Click不支持它，那么做出这个决定可能是有原因的。
https://click.palletsprojects.com/en/7.x/options/#multiple-options
这里有一个例子可以说明我的观点：
不是传递单个字符串参数，而是分隔符上的拆分：

commit -m foo:bar:baz

我选择使用这个：

commit -m foo -m bar -m baz

下面是源代码：

@click.command()
@click.option('--message', '-m', multiple=True)
def commit(message):
    click.echo('\n'.join(message))

这更像是键入，但我确实认为它使CLI更加用户友好和健壮。

我自己需要这个，并考虑解决由@nikita-malovichko提供的solution，尽管它是非常限制性的，但它对我不起作用（见我对该答案的评论），所以想出了下面的替代方案。
我的解决方案并没有直接解决如何支持nargs=*的问题，但它为我自己提供了一个很好的选择，所以为了他人的利益分享它。
我们的想法是使用一个选项来指定另一个选项的预期计数，即在运行时动态设置nargs计数。

import click

def with_dynamic_narg(cnt_opt, tgt_opt):
    class DynamicNArgSetter(click.Command):
        def parse_args(self, ctx, args):
            ctx.resilient_parsing = True
            parser = self.make_parser(ctx)
            opts, _, _ = parser.parse_args(args=list(args))
            if cnt_opt in opts:
                for p in self.params:
                    if isinstance(p, click.Option) and p.name == tgt_opt:
                        p.nargs = int(opts[cnt_opt])

            ctx.resilient_parsing = False
            return super().parse_args(ctx, args)

    return DynamicNArgSetter

@click.command(cls=with_dynamic_narg('c', 'n'))
@click.option("-c", type=click.INT)
@click.option("-n", nargs=0)
def f(c, n):
    print(c, n)

if __name__ == '__main__':
    f()

在上面的代码中，创建了一个自定义Command类，它知道“count”arg和接受多个arg的目标arg之间的链接。它首先在“resilient”模式下执行本地解析以检测计数，然后使用计数更新目标arg的nargs值，然后在正常模式下继续解析。
下面是一些交互示例：

$ python t.py -c 0
0 None
$ python t.py -c 1
Usage: t.py [OPTIONS]
Try 't.py --help' for help.

Error: Missing option '-n'.
$ python t.py -c 0 -n a
Usage: t.py [OPTIONS]
Try 't.py --help' for help.

Error: Got unexpected extra argument (a)
$ python t.py -c 1 -n a
1 a
$ python /tmp/t.py -c 2 -n a b
2 ('a', 'b')

注意：与官方推荐的使用multiple=True相比，它的优点是我们可以使用文件名通配符，并让shell扩展它们。

$ touch abc.1 abc.2
$ python t.py -c 2 -n abc.*
2 ('abc.1', 'abc.2')
$ python t.py -c $(echo abc.* | wc -w) -n abc.*
2 ('abc.1', 'abc.2')