argparse --- 命令行选项、参数和子命令解析器

创建一个解析器:

创建一个argparse的 ArgumentParser 对象：

parser = argparse.ArgumentParser(description='Process some integers.')

添加参数：调用 add_argument() 方法完成

parser.add_argument('integers', metavar='N', type=int, nargs='+',
                    help='an integer for the accumulator')

解析参数 : 通过 parse_args() 方法解析参数

parser.parse_args(['--sum', '7', '-1', '42'])

add_argument() 方法

ArgumentParser.add_argument(name or flags…[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])
定义单个的命令行参数应当如何解析。每个形参都在下面有它自己更多的描述，长话短说有：

name or flags - 一个命名或者一个选项字符串的列表，例如 foo 或 -f, --foo。

action - 当参数在命令行中出现时使用的动作基本类型。

nargs - 命令行参数应当消耗的数目。

const - 被一些 action 和 nargs 选择所需求的常数。

default - 当参数未在命令行中出现并且也不存在于命名空间对象时所产生的值。

type - 命令行参数应当被转换成的类型。

choices - 可用的参数的容器。

required - 此命令行选项是否可省略 （仅选项可用）。

help - 一个此选项作用的简单描述。

metavar - 在使用方法消息中使用的参数值示例。

dest - 被添加到 parse_args() 所返回对象上的属性名。

1. name or flags

可选参数是以’-‘为前缀的参数，剩下的就是位置参数
注：可选参数可以在add_argment(“这里如果加上“-”,则说明是可选的，否则是必须的”)定义

parser.add_argument('-f', '--foo',help="display the message!")    #指定一个可选参数,有时候写一个匹配项的时候还需要写全拼，实在是有些麻烦，
                                                                  #在Linux中大多数的交互命令都有简写，那么我们也可以来进行设置短选项, 有短选项，必须使用短选项            
parser.add_argument('--qqq',help="display the message!")
parser.add_argument('bar')            #指定一个位置参数        # 位置参数必须传入

2. action

action参数指定应该如何处理命令行参数，预置的操作有以下几种:

action=’store’ 仅仅保存参数值，为action默认值

action=’store_const’ 与store基本一致，但store_const只保存const关键字指定的值 注意：add_argument函数的const参数提供

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action='store_const', const=42)
>>> parser.parse_args(['--foo'])
Namespace(foo=42)

action=’store_true’或’store_false’ store_true表示如果配置，值为True，store_false表示如果配置，值为False。此时命令行参数后面不能配置具体的值。

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action='store_true')
>>> parser.add_argument('--bar', action='store_false')
>>> parser.add_argument('--baz', action='store_false')
>>> parser.parse_args('--foo --bar'.split())
Namespace(foo=True, bar=False, baz=True)

action=’append’ 将相同参数的不同值保存在一个list中

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

action=’count’ 统计该参数出现的次数

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--verbose', '-v', action='count', default=0)
>>> parser.parse_args(['-vvv'])
Namespace(verbose=3)

action=’help’ 输出程序的帮助信息

action=’version’ 输出程序版本信息

>>> import argparse
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--version', action='version', version='%(prog)s 2.0')
>>> parser.parse_args(['--version'])
PROG 2.0

action=‘extend’ 这会存储一个列表，并将每个参数值加入到列表中。

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument("--foo", action="extend", nargs="+", type=str)
>>> parser.parse_args(["--foo", "f1", "--foo", "f2", "f3", "f4"])
Namespace(foo=['f1', 'f2', 'f3', 'f4'])

除了上述几种预置action，还可以自定义action，需要继承Action并覆盖call和init方法。

3. nargs

默认情况下 ArgumentParser对象将参数与一个与action一一关联，通过指定 nargs可以将多个参数与一个action相关联。nargs支持值如下：

N (整数) N个命令行参数被保存在一个list中

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', nargs=2)
>>> parser.add_argument('bar', nargs=1)
>>> parser.parse_args('c --foo a b'.split())
Namespace(bar=['c'], foo=['a', 'b'])

‘?’ 如果存在该参数且给出了参数值，则从命令行取得该参数，如果存在该参数但未给出参数值，则从const关键字中取得参数值，如果不指定该参数，则将生成默认值。

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

‘ * ’ 命令行参数被保存在一个list中 通过输入前面是否有 - 或者 – 来判断是否为下一个参数。注意通过 nargs=’*’ 来实现多个位置参数通常没有意义，但是多个选项是可能的

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', nargs='*')
>>> parser.add_argument('--bar', nargs='*')
>>> parser.add_argument('baz', nargs='*')
>>> parser.parse_args('a b --foo x y --bar 1 2'.split())
Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])

‘+’命令行参数被保存在一个list中，要求至少要有一个参数，否则报错 通过输入前面是否有 - 或者 – 来判断是否为下一个参数

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('foo', nargs='+')
>>> parser.parse_args(['a', 'b'])
Namespace(foo=['a', 'b'])
>>> parser.parse_args([])
usage: PROG [-h] foo [foo ...]
PROG: error: the following arguments are required: foo

argparse.REMAINDER 其余的命令行参数保存到一个list中 就不存在上面‘*’和‘+’的问题了

4. const

当 add_argument() 通过 action=‘store_const’ 或 action='append_const 调用时。这些动作将 const 值添加到 parse_args() 返回的对象的属性中。在 action 的描述中查看案例。

对 ‘store_const’ 和 ‘append_const’ 动作， const 命名参数必须给出。对其他动作，默认为 None。

当 add_argument() 通过选项（例如 -f 或 --foo）调用并且 nargs=’?’ 时。这会创建一个可以跟随零个或一个命令行参数的选项。当解析命令行时，如果选项后没有参数，则将用 const 代替。在 nargs 描述中查看案例。

5. default

如果参数可以缺省，default指定命令行参数不存在时的参数值。

default的值的类型，要与type保持一致。

位置参数配合nargs=’?'时，就变成了一个可选的位置参数 输出的值是default的值

default值与nargs配置不符，输出default的值

6. type

默认情况下，ArgumentParser对象将命令行参数保存为字符串。但通常命令行参数应该被解释为另一种类型，如 float或int。
通过指定type,可以对命令行参数执行类型检查和类型转换。通用的内置类型和函数可以直接用作type参数的值：

parser.add_argument('--f1', type= int, default=42)

7. choices

choices 将命令行参数的值限定在一个范围内，超出范围则报错

>>> parser = argparse.ArgumentParser(prog='game.py')
>>> parser.add_argument('move', choices=['rock', 'paper', 'scissors'])
>>> parser.parse_args(['rock'])
Namespace(move='rock')
>>> parser.parse_args(['fire'])
usage: game.py [-h] {rock,paper,scissors}
game.py: error: argument move: invalid choice: 'fire' (choose from 'rock',
'paper', 'scissors')

choices 容器包含的内容会在执行任意 type 转换之后被检查，因此 choices 容器中对象的类型应当与指定的 type 相匹配:

>>> parser = argparse.ArgumentParser(prog='doors.py')
>>> parser.add_argument('door', type=int, choices=range(1, 4))
>>> print(parser.parse_args(['3']))
Namespace(door=3)
>>> parser.parse_args(['4'])
usage: doors.py [-h] {1,2,3}
doors.py: error: argument door: invalid choice: 4 (choose from 1, 2, 3)

7.required

指定命令行参数是否必需，默认指定的参数为可选参数。

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', required=True)
>>> parser.parse_args(['--foo', 'BAR'])
Namespace(foo='BAR')
>>> parser.parse_args([])
usage: [-h] --foo FOO
: error: the following arguments are required: --foo

8.dest

dest 允许自定义ArgumentParser的参数属性名称

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', dest='bar')
>>> parser.parse_args('--foo XXX'.split())
Namespace(bar='XXX')

对于位置参数动作，dest 通常会作为 add_argument() 的第一个参数提供:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('bar')
>>> parser.parse_args(['XXX'])
Namespace(bar='XXX')

对于可选参数动作，dest 的值通常取自选项字符串。 ArgumentParser 会通过接受第一个长选项字符串并去掉开头的 – 字符串来生成 dest 的值。 如果没有提供长选项字符串，则 dest 将通过接受第一个短选项字符串并去掉开头的 - 字符来获得。 任何内部的 - 字符都将被转换为 _ 字符以确保字符串是有效的属性名称。

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('-f', '--foo-bar', '--foo')
>>> parser.add_argument('-x', '-y')
>>> parser.parse_args('-f 1 -x 2'.split())
Namespace(foo_bar='1', x='2')
>>> parser.parse_args('--foo 1 -y 2'.split())
Namespace(foo_bar='1', x='2')

9. metavar

这个参数用于help 信息输出中。 默认情况下，对于位置参数动作，dest 值将被直接使用，而对于可选参数动作，dest 值将被转为大写形式。 因此，一个位置参数 dest=‘bar’ 的引用形式将为 bar。 一个带有单独命令行参数的可选参数 --foo 的引用形式将为 FOO。

默认：

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> parser.add_argument('bar')
>>> parser.parse_args('X --foo Y'.split())
Namespace(bar='X', foo='Y')
>>> parser.print_help()
usage:  [-h] [--foo FOO] bar

positional arguments:
 bar

optional arguments:
 -h, --help  show this help message and exit
 --foo FOO

可以使用 metavar 来指定一个替代名称:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', metavar='YYY')
>>> parser.add_argument('bar', metavar='XXX')
>>> parser.parse_args('X --foo Y'.split())
Namespace(bar='X', foo='Y')
>>> parser.print_help()
usage:  [-h] [--foo YYY] XXX

positional arguments:
 XXX

optional arguments:
 -h, --help  show this help message and exit
 --foo YYY