Python命令行工具argparse模块学习笔记

argparse模块是在命令行(windows的cmd窗口，Linux的shell)执行程序时，直接在命令行添加程序执行所需参数的便捷工具。

使用步骤：

(1) import argparse # 导入模块

(2) parser = argparse.ArgumentParser() # 创建一个解析对象

(3) parser.add_argument() # 向该对象中添加命令行参数和选项

(4) args = parser.parse_args() # 进行解析

解析后的参数可使用'args.参数名'的形式进行取用，如：cfg.GPU = args.gpu

先举一个实际例子体会用法，再展开进行讲解：

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-w', '--weights', default="YOLO_small.ckpt", type=str)
    parser.add_argument('--data_dir', default="data", type=str)
    parser.add_argument('--threshold', default=0.2, type=float)
    parser.add_argument('--iou_threshold', default=0.5, type=float)
    parser.add_argument('--gpu', default='', type=str)
    args = parser.parse_args()

    if args.gpu is not None:
        cfg.GPU = args.gpu

    if args.data_dir != cfg.DATA_PATH:
        update_config_paths(args.data_dir, args.weights)

    os.environ['CUDA_VISIBLE_DEVICES'] = cfg.GPU

    yolo = YOLONet()
    pascal = pascal_voc('train')

    solver = Solver(yolo, pascal)

    print('Start training ...')
    solver.train()
    print('Done training.')


if __name__ == '__main__':

    # python train.py --weights YOLO_small.ckpt --gpu 0
    main()

以上是一个YOLO v1的例子，大体可知该模块的最常用法，下面讲解每个函数的不同用法。

1. parser = argparse.ArgumentParser()语句常用参数

argparse.ArgumentParser()方法有很多参数，主要用于命令行执行程序时，对该程序所需参数选项的说明和修饰。正如前面的例子中一样，很多时候不设置任何参数即可完成操作，如需对程序使用者进行提示程序运行方法和各参数选项的设置方法以及更多修饰和说明，使程序使用者更容易运行程序，则最好设置其中参数。其最常用的几个参数如下：

prog=None,     # 程序名
usage=None,     # 描述程序用法的字符串
description=None,     # -h或--help时显示的描述性字符串内容，最常用
epilog=None,     # -h/--help时显示的结尾文字
prefix_chars='-',     # 可选参数的前缀字符集（默认：‘-‘）
fromfile_prefix_chars=None,     # 命令行参数从文件中读取
conflict_handler='error',     #定义两个add_argument中添加的选项名字发生冲突时怎么处理，默认处理是抛出异常
add_help=True     # 是否增加-h/--help选项，默认是True

上述参数中一般只使用description给别人描述自己程序是用来干嘛的就行了，其它都不常用。

parser = argparse.ArgumentParser(description='可以这样使用')
parser.description='也可以这样使用'

2. parser.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_argument()方法必须的参数，且位于第一个位置，判断参数是可变参数，还是位置参数，格式要求：

parser.add_argument('--foo','-f')  #这种形式表示可变参数，前缀可根据parse.ArgumentParser()里面的prefix_char参数来定义
parser.add_argument('foo')  #这种形式表示位置参数

(2) help

自定义add_argument()中参数的帮助信息

# help_example.py
import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--foo',help="this is mystyle help")
parser.parse_args()

显示：
xxx$ ./help_example.py -h
usage: help_example.py [-h] [--foo FOO]

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

(3) type

默认情况下对于命令行参数是直接解析成字符串类型，type可以指定参数类型为其它

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('foo', type=int) #指定参数类型为整型
>>> parser.add_argument('bar', type=open) #指定对于参数进行open操作
>>> parser.parse_args('2 temp.txt'.split())
Namespace(bar=<_io.TextIOWrapper name='temp.txt' encoding='UTF-8'>, foo=2)

(4) choices

用于界定参数的取值范围

>>> 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)

(5) dest

使用parse_args()对参数进行解析后,一个属性对应一个参数的值,而该属性值正是dest的值，默认情况下，对于位置参数，就是位置参数的值，对于可选参数，则是去掉前缀后的值

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('bar')
_StoreAction(option_strings=[], dest='bar', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.add_argument('--version')
_StoreAction(option_strings=['--version'], dest='version', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)

即在默认情况下，args.bar即代表命令行指定bar的值，args.version即表示在命令行指定的--version的值。

(6) nargs

一般情况下，一个参数与一个操作参数(如:--version)关联，但nargs可以将多个参数与一个操作参数关联

N——一个正整数

>>> 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'])

'?'——一个或多个参数

>>> 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')

(7) required

用来设置必选参数，设定后在命令行不使用会报错

>>> parser.add_argument('--foo',required=True)
>>> parser.add_argument('--version 21'.split)
>>> parser.parse_args('--version 21'.split())
usage: [-h] --foo FOO [--version VERSION]
: error: the following arguments are required: --foo

(8) default

设置参数的默认值，命令行有则覆盖默认值，没有则使用默认值
用法见前述例子。

(9) const

官方给出的解释是：

The const argument of add_argument() is used to hold constant values that are not read from the command line but are required for the various ArgumentParser actions. The two most common uses of it are:
When add_argument() is called with action='store_const' or action='append_const'. These actions add the const value to one of the attributes of the object returned by parse_args(). See the action description for examples.
When add_argument() is called with option strings (like -f or --foo) and nargs='?'. This creates an optional argument that can be followed by zero or one command-line arguments. When parsing the command line, if the option string is encountered with no command-line argument following it, the value of const will be assumed instead. See the nargs description for examples.
With the 'store_const' and 'append_const' actions, the const keyword argument must be given. For other actions, it defaults to None.

是针对于action中的'store_const'与'append_const'而出现。其实对于那些需要接值的参数，预先存储一个值，如果没有则取用这个值，比如

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

(10) action

用来给ArgumenParser对象判断如何处理命令行参数，支持的操作如下：

'store' - 默认的操作，用来存储参数的值

>>>parser = argparse.ArgumentParser()
>>>parser.add_argument('--foo')
>>>parser.parse_args('--foo 1'.split)
Namespace(foo='1')

'store_const' - 适用于可选参数optional arguments，用来存储const关键字指定的值

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

'store_true和'store_false'' - 属于'store_const'的特殊用法，设定const的默认值为True或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)

'append' - 将每个参数的值追加到一个列表里面

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

'append_const' - 当多个参数需要将常量存储到一个列表时设置

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--str', dest='types', action='append_const', const=str)
>>> parser.add_argument('--int', dest='types', action='append_const', const=int)
>>> parser.parse_args('--str --int'.split())
Namespace(types=[<class 'str'>, <class 'int'>])

'count' - 对参数出现的次数进行计数

>>> parser.add_argument('-v',action='count')
_CountAction(option_strings=['-v'], dest='v', nargs=0, const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.parse_args(['-vvv'])
Namespace(v=3)

'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

(11) metavar

我理解为是对在命令行所接参数的样式的示例，比如--version后面应接3位大写字母(比如YYY),则可以设定metavar='YYY'，意思为此处应接三位大写字母

>>> parser.add_argument('--version',metavar='YYY')
_StoreAction(option_strings=['--version'], dest='version', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar='YYY')
>>> parser.add_argument('--info',metavar='XX')
_StoreAction(option_strings=['--info'], dest='info', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar='XX')
>>> parser.parse_args('--version HTB --info HK'.split())
Namespace(info='HK', version='HTB')
>>> parser.print_help()
usage: [-h] [--version YYY] [--info XX]

optional arguments:
  -h, --help     show this help message and exit
  --version YYY
  --info XX