在add_argument()中，type只是一个可调用的对象，它接收字符串并返回选项值。

import ast

def arg_as_list(s):                                                            
    v = ast.literal_eval(s)                                                    
    if type(v) is not list:                                                    
        raise argparse.ArgumentTypeError("Argument \"%s\" is not a list" % (s))
    return v                                                                   


def foo():
    parser.add_argument("--list", type=arg_as_list, default=[],
                        help="List of values")

这将允许:

$ ./tool --list "[1,2,3,4]"

我想处理传递多个列表，整数值和字符串。

如何将Bash变量传递给Python?

def main(args):
    my_args = []
    for arg in args:
        if arg.startswith("[") and arg.endswith("]"):
            arg = arg.replace("[", "").replace("]", "")
            my_args.append(arg.split(","))
        else:
            my_args.append(arg)

    print(my_args)


if __name__ == "__main__":
    import sys
    main(sys.argv[1:])

秩序并不重要。如果你想传递一个列表，只需在“[”和“]之间做，并用逗号分隔它们。

然后,

python test.py my_string 3 "[1,2]" "[3,4,5]"

Output => ['my_string'， '3'， ['1'， '2']， ['3'， '4'， '5']]]， my_args变量按顺序包含参数。

编辑:结合了Katu建议的改进，删除了单独的解析步骤。

JSON列表解决方案

通过命令行处理传递列表(也包括字典)的一个好方法是使用json。

# parse_list.py
import argparse
import json

parser = argparse.ArgumentParser()
# note type arg, used to load json string
parser.add_argument('-l', '--list', type=json.loads)
args = parser.parse_args()
print(args.list)

示例使用

$ python parse_list.py -l "[265340, 268738, 270774, 270817]"
[265340, 268738, 270774, 270817]

请注意，如果你传递action='append'和默认参数，Argparse将尝试附加到提供的默认值，而不是替换默认值，这可能是你所期望的，也可能不是。

下面是Argparse Docs中给出的一个action='append示例。 在这种情况下，事情将如预期的那样工作:

>> import argparse
>> parser = argparse.ArgumentParser()
>> parser.add_argument('--foo', action='append')
>> parser.parse_args('--foo 1 --foo 2'.split())

Out[2]: Namespace(foo=['1', '2'])

然而，如果你选择提供一个默认值，Argparse的"append"操作将尝试附加到提供的默认值，而不是替换默认值:

import argparse
REASONABLE_DEFAULTS = ['3', '4']
parser = argparse.ArgumentParser()
parser.add_argument('--foo', default=REASONABLE_DEFAULTS,action='append')
parser.parse_args('--foo 1 --foo 2'.split())

Out[6]: Namespace(foo=['3', '4', '1', '2'])

如果你希望Argparse替换默认值——比如传入一个元组作为默认值，而不是一个列表——这可能会导致一些令人困惑的错误:

import argparse
REASONABLE_DEFAULTS = ('3', '4')
parser = argparse.ArgumentParser()
parser.add_argument('--foo', default=REASONABLE_DEFAULTS,action='append')
parser.parse_args('--foo 1 --foo 2'.split())

AttributeError: 'tuple' object has no attribute 'append'

有一个跟踪这种意外行为的bug，但由于它可以追溯到2012年，所以不太可能得到解决。

在add_argument()中，type只是一个可调用的对象，它接收字符串并返回选项值。

import ast

def arg_as_list(s):                                                            
    v = ast.literal_eval(s)                                                    
    if type(v) is not list:                                                    
        raise argparse.ArgumentTypeError("Argument \"%s\" is not a list" % (s))
    return v                                                                   


def foo():
    parser.add_argument("--list", type=arg_as_list, default=[],
                        help="List of values")

这将允许:

$ ./tool --list "[1,2,3,4]"

如果你想让一个开关有多个参数，那么你可以使用nargs='+'。如果你的例子'-l'实际上是接受整数:

a = argparse.ArgumentParser()
a.add_argument(
    '-l', '--list',  # either of this switches
    nargs='+',       # one or more parameters to this switch
    type=int,        # /parameters/ are ints
    dest='lst',      # store in 'lst'.
    default=[],      # since we're not specifying required.
)

print a.parse_args("-l 123 234 345 456".split(' '))
print a.parse_args("-l 123 -l=234 -l345 --list 456".split(' '))

生产

Namespace(lst=[123, 234, 345, 456])
Namespace(lst=[456])  # Attention!

如果多次指定相同的参数，默认操作('store')将替换现有数据。

另一种方法是使用追加操作:

a = argparse.ArgumentParser()
a.add_argument(
    '-l', '--list',  # either of this switches
    type=int,        # /parameters/ are ints
    dest='lst',      # store in 'lst'.
    default=[],      # since we're not specifying required.
    action='append', # add to the list instead of replacing it
)

print a.parse_args("-l 123 -l=234 -l345 --list 456".split(' '))

生产

Namespace(lst=[123, 234, 345, 456])

或者您可以编写一个自定义处理程序/操作来解析逗号分隔的值，这样您就可以这样做

-l 123,234,345 -l 456