【转载】Python命令行工具argparse模块学习笔记

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

本文搬运自Python命令行工具argparse模块学习笔记和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

以下为一个YOLO v1的例子实际例子及详细讲解：

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

1. parser = argparse.ArgumentParser()

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

class ArgumentParser(prog=None, usage=None, description=None, epilog=None, 
parents=[], formatter_class=argparse.HelpFormatter, prefix_chars='-', 
fromfile_prefix_chars=None, argument_default=None, 
conflict_handler='error', add_help=True)

其中，

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='也可以这样使用'

具体来说，各个参数意义如下：

(1) prog

程序的名字，默认为sys.argv[0]，用来在help信息中描述程序的名称。

>>> parser = argparse.ArgumentParser(prog='myprogram')
>>> parser.print_help()
usage: myprogram [-h]
 
optional arguments:
 -h, --help  show this help message and exit

(2) usage

描述程序用途的字符串

>>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')
>>> parser.add_argument('--foo', nargs='?', help='foo help')
>>> parser.add_argument('bar', nargs='+', help='bar help')
>>> parser.print_help()
usage: PROG [options]
 
positional arguments:
 bar          bar help
 
optional arguments:
 -h, --help   show this help message and exit
 --foo [FOO]  foo help

(3) description

help信息前的文字

(4) epilog

help之后的信息

>>> parser = argparse.ArgumentParser(
...     description='A foo that bars',
...     epilog="And that's how you'd foo a bar")
>>> parser.print_help()
usage: argparse.py [-h]
 
A foo that bars
 
optional arguments:
 -h, --help  show this help message and exit
 
And that's how you'd foo a bar

(5) parents

由ArgumentParser对象组成的列表，它们的arguments选项会被包含到新ArgumentParser对象中。

>>> parent_parser = argparse.ArgumentParser(add_help=False)
>>> parent_parser.add_argument('--parent', type=int)
 
>>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])
>>> foo_parser.add_argument('foo')
>>> foo_parser.parse_args(['--parent', '2', 'XXX'])
Namespace(foo='XXX', parent=2)

(6) formatter_class

help信息输出的格式

(7) prefix_chars

参数前缀，默认为’-’

>>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')
>>> parser.add_argument('+f')
>>> parser.add_argument('++bar')
>>> parser.parse_args('+f X ++bar Y'.split())
Namespace(bar='Y', f='X')

(8) fromfile_prefix_chars

前缀字符，放在文件名之前

>>> with open('args.txt', 'w') as fp:
...    fp.write('-f\nbar')
>>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')
>>> parser.add_argument('-f')
>>> parser.parse_args(['-f', 'foo', '@args.txt'])
Namespace(f='bar')

当参数过多时，可以将参数放到文件中读取，例子中parser.parse_args([’-f’, ‘foo’, ‘@args.txt’])解析时会从文件args.txt读取，相当于[’-f’, ‘foo’, ‘-f’, ‘bar’]。

(9) argument_default

参数的全局默认值。例如，要禁止parse_args时的参数默认添加，我们可以：

>>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)
>>> parser.add_argument('--foo')
>>> parser.add_argument('bar', nargs='?')
>>> parser.parse_args(['--foo', '1', 'BAR'])
Namespace(bar='BAR', foo='1')
>>> parser.parse_args()
Namespace()

当parser.parse_args()时不会自动解析foo和bar了。

(10) conflict_handler

解决冲突的策略，默认情况下冲突会发生错误：

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-f', '--foo', help='old foo help')
>>> parser.add_argument('--foo', help='new foo help')
Traceback (most recent call last):
 ..
ArgumentError: argument --foo: conflicting option string(s): --foo

我们可以设定冲突解决策略：

>>> parser = argparse.ArgumentParser(prog='PROG', conflict_handler='resolve')
>>> parser.add_argument('-f', '--foo', help='old foo help')
>>> parser.add_argument('--foo', help='new foo help')
>>> parser.print_help()
usage: PROG [-h] [-f FOO] [--foo FOO]
 
optional arguments:
 -h, --help  show this help message and exit
 -f FOO      old foo help
 --foo FOO   new foo help

(11) add_help

设为False时，help信息里面不再显示-h --help信息。

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

参数的数量

• 值可以为整数N(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