0%

python_argparse学习

发表于 更新于 分类于 阅读次数： 阅读次数： Valine：
本文字数： 11k 阅读时长 ≈ 10 分钟

argparse模块

作用 ： argparse 是 Python 内置的一个用于命令项选项与参数解析的模块，通过在程序中定义好我们需要的参数，argparse 将会从sys.argv 中解析出这些参数，并自动生成帮助和使用信息。当然，Python 也有第三方的库可用于命令行解析，而且功能也更加强大，比如 docopt ，Click 。

1. 命令行参数分为位置参数和选项参数：

  • 位置参数就是程序根据该参数出现的位置来确定的
    如：[root@openstack_1 /]# ls root/ #其中root/是位置参数

  • 选项参数是应用程序已经提前定义好的参数，不是随意指定的
    如：[root@openstack_1 /]# ls -l # -l 就是ls命令里的一个选项参数

2. 使用步骤：

（1）import argparse 首先导入模块
（2）parser = argparse.ArgumentParser（） 创建一个解析对象
（3）parser.add_argument() 向该对象中添加你要关注的命令行参数和选项
（4）parser.parse_args() 进行解析

3. argparse.ArgumentParser（）方法参数

==一般我们只选择用description==

  1. description - 命令行帮助的开始文字，大部分情况下，我们只会用到这个参数
  2. epilog - 命令行帮助的结尾文字
  3. prog - (default: sys.argv[0])程序的名字，一般不需要修改，另外，如果你需要在help中使用到程序的名字，可以使用%(prog)s
  4. prefix_chars - 命令的前缀，默认是-，例如-f/–file。有些程序可能希望支持/f这样的选项，可以使用prefix_chars=”/”

  5. fromfile_prefix_chars - (default: None)如果你希望命令行参数可以从文件中读取，就可能用到。例如，如果fromfile_prefix_chars=’@’,命令行参数中有一个为” @args.txt”，args.txt的内容会作为命令行参数

  6. add_help - 是否增加-h/-help选项 (default: True)，一般help信息都是必须的，所以不用设置啦。

  7. parents - 类型是list，如果这个parser的一些选项跟其他某些parser的选项一样，可以用parents来实现继承，例如parents=[parent_parser]

  8. 三个允许的值：
    (1) # class argparse.RawDescriptionHelpFormatter 直接输出description和epilog的原始形式（不进行自动换行和消除空白的操作）
    (2) # class argparse.RawTextHelpFormatter 直接输出description和epilog以及add_argument中的help字符串的原始形式（不进行自动换行和消除空白的操作）
    (3) # class argparse.ArgumentDefaultsHelpFormatter 在每个选项的帮助信息后面输出他们对应的缺省值，如果有设置的话。==这个最常用吧！==

  9. argument_default - (default: None)设置一个全局的选项的缺省值，一般每个选项单独设置，所以这个参数用得少，不细说

  10. usage - (default: generated)如果你需要修改usage的信息（usage: PROG [-h] [–foo [FOO]] bar [bar …]），那么可以修改这个，一般不要修改。
  11. conflict_handler - 不建议使用。这个在极端情况下才会用到，主要是定义两个add_argument中添加的选项的名字发生冲突时怎么处理，默认处理是抛出异常。
4. add_argument()方法参数须知：
  1. name or flags - 指定参数的形式，想写几个写几个，不过我们一般就写两个，一个短参数，一个长参数，看下面的例子”-f”, “–file”
  2. 可选的选项，位置不固定，想怎么写就怎么写，默认是可选的 # parser.add_argument(“-f”, “–file”, help=”test test test”)
  3. 位置固定的选项，例如”prog i_am_bar”，这样子的话，i_am_bar就是bar选项的值啦，默认是必须有的 # parser.add_argument(“bar”, help=”test test test”)
  4. nargs - 指定这个参数后面的value有多少个，例如，我们希望使用-n 1 2 3 4，来设置n的值为[1, 2, 3, 4] #parser.add_argument(“-n”, “–num”, nargs=”+”, type=int) # 这里nargs=”+”表示，如果你指定了-n选项，那么-n后面至少要跟一个参数，+表示至少一个,?表示一个或0个,0个或多个 。
  5. default - 如果命令行没有出现这个选项，那么使用default指定的默认值 #parser.add_argument(“+g”, “++gold”, help=”test test test”,default=”test_gold”)#需要prefix_chars包含”+” 。
  6. type - 如果希望传进来的参数是指定的类型（例如 float, int or file等可以从字符串转化过来的类型），可以使用 #parser.add_argument(“-x”, type=int) 。
  7. choices - 设置参数值的范围，如果choices中的类型不是字符串，记得指定type哦 #parser.add_argument(“-y”, choices=[‘a’, ‘b’, ‘d’])
  8. required - 通常-f这样的选项是可选的，但是如果required=True那么就是必须的了 #parser.add_argument(“-z”, choices=[‘a’, ‘b’, ‘d’], required=True)
  9. metavar - 参数的名字，在显示 帮助信息时才用到. # parser.add_argument(“-o”, metavar=”OOOOOO”)
  10. help - 设置这个选项的帮助信息
  11. dest - 设置这个选项的值就是解析出来后放到哪个属性中 #parser.add_argument(“-q”, dest=”world”)
  12. args = parser.parse_args(args) # 如果你没有args参数，那么就使用sys.argv，也就是命令行参数啦。有这个参数，就方便我们调试啊 。# args.world就是-q的值啦
  13. action - The basic type of action to be taken when this argument is encountered at the command line.
  14. const - A constant value required by some action and nargs selections.
1
2
3
4
5
6
import argparse  
parser = argparse.ArgumentParser()  
parser.add_argument('echo')     # add_argument()指定程序可以接受的命令行选项  
args = parser.parse_args()      # parse_args()从指定的选项中返回一些数据  
print(args)  
print(args.echo)
1
2
3
4
5
6
7
8
parser = argparse.ArgumentParser(description = 'this is a description')  
parser.add_argument('--ver', '-v', action = 'store_true', help = 'hahaha')  
# 将变量以标签-值的字典形式存入args字典  
args = parser.parse_args()  
if args.ver:  
    print("Ture")  
else:  
    print("False")
1
2
# required标签就是说--ver参数是必需的，并且类型为int，输入其它类型会报错  
parser.add_argument('--ver', '-v', required = True, type = int)
1
2
3
parser.add_argument('file', choices = ['test1', 'test2'])  
args = parser.parse_args()  
print('read in %s'%(args.file))
1
2
3
4
# 表示脚本可以读入两个整数赋予num键（此时的值为2个整数的数组）  
parser.add_argument('filename', nargs = 2, type = int)  
args = parser.parse_args()  
print('read in %s'%(args.filename))

分析：nargs还可以’*‘用来表示如果有该位置参数输入的话，之后所有的输入都将作为该位置参数的值；‘+’表示读取至少1个该位置参数。’?’表示该位置参数要么没有，要么就只要一个。（PS：跟正则表达式的符号用途一致。）
如：

1
2
3
parser.add_argument('filename', nargs = '+', type = int)  
args = parser.parse_args()  
print('read in %s'%(args.filename))

dest - 设置这个选项的value解析出来后放到哪个属性中

1
2
3
parser.add_argument('-file', choices = ['test1', 'test2'], dest = 'world')  
args = parser.parse_args()  
print('read in %s'%(args.world))

5. add

如果脚本很简单或临时使用，没有多个复杂的参数选项，可以直接利用sys.argv将脚本后的参数依次读取(读进来的默认是字符串格式)。比如如下名为test.py的脚本：

1
2
import sys  
print "Input argument is %s" %(sys.argv)

在shell脚本中运行python test.py help可以得到Input argument is help的结果。

1. 一般形式
但是大多数情况下，脚本很可能需要多个参数，而且每次参数的类型用处各不相同，那么这个时候在参数前添加标签表明参数的类型和用途便十分有用，而利用argparse模块可以很方便得实现这一目的。

同样用名为test.py的脚本举个栗子：

1
2
3
4
5
6
7
8
9
import argparse  
    
parser = argparse.ArgumentParser(description="your script description") # description参数可以用于插入描述脚本用途的信息，可以为空  
parser.add_argument('--verbose', '-v', action='store_true', help='verbose mode')   # 添加--verbose标签，标签别名可以为-v，这里action的意思是当参数字典的verbose建对应的值为True，而help参数用于描述--v  
args = parser.parse_args()  # 将变量以标签-值的字典形式存入args字典  
if args.verbose:  
    print "Verbose mode on!"  
else:  
   print "Verbose mode off!"

运行python test.py后面跟了–verbose/-v的时候会输出前者，如果什么都没有会输出后者。如果输入了–verbose/-v以外的参数则会报错：unrecognized arguments

稍微提一下，action参数表示值赋予键的方式，这里用到的是bool类型；如果是’count’表示将–verbose标签出现的次数作为verbose的值；’append’表示将每次出现的该便签后的值都存入同一个数组再赋值。（嘛，一般后面两种用的比较少就不多说了）
PS：–help标签在使用argparse模块时会自动创建，因此一般情况不需要我们主动定义帮助信息。

1
2
3
4
5
6
7
8
$ python test.py --help  
usage: test.py [-h] [--verbose]  
    
your script description  
    
optional arguments:  
    -h, --help        show this help message and exit  
    --verbose, -v     verbose mode
2. 必需参数
这种模式用于确保某些必需的参数有输入。

1
parser.add_argument('--verbose', required=True, type=int)

required标签就是说–verbose参数是必需的，并且类型为int，输入别的类型会报错。

3. 位置参数（positional arguments）
位置参数与sys.argv调用比较像，参数没有显式的–xxx或者-xxx标签，因此调用属性也与sys.argv相同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    parser.add_argument('filename')    # 输入的第一个参数赋予名为filename的键  
    args = parser.parse_args()  
    print "Read in %s" %(args.filename)  
``` 
  
输入python test.py test.txt则会输出Read in test.txt

此外，可以用nargs参数来限定输入的位置参数的个数，默认为1。当然nargs参数也可用于普通带标签的参数。

parser.add_argument(‘num’, nargs=2, type=int) 表示脚本可以读入两个整数赋予num键（此时的值为2个整数的数组）。nargs还可以’*‘用来表示如果有该位置参数输入的话，之后所有的输入都将作为该位置参数的值；‘+’表示读取至少1个该位置参数。’?’表示该位置参数要么没有，要么就只要一个。（PS：跟正则表达式的符号用途一致。）比如用：

```python
    parser.add_argument('filename')  
    parser.add_argument('num', nargs='*)  
``` 
  
就可以运行python test.py text.txt 1 2  
由于没有标签，所以用位置参数的时候需要比较小心。

##### 4. 输入类型

    之前已经提到了用type参数就可以指定输入的参数类型。而这个type类型还可以表示文件操作的类型从而直接进行文件的读写操作。

```python
    parser.add_argument('file', type=argparser.FileType('r'))    # 读取文件  
    args = parser.parse_args()  
    for line in args.file:  
        print line.strip()
5. 参数默认值
一般情况下会设置一些默认参数从而不需要每次输入某些不需要变动的参数，利用default参数即可实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
    parser.add_argument('filename', default='text.txt') 
``` 

这个时候直接运行python text.py就能得到Read in text.txt而不需要输入文件名了。

##### 6. 候选参数选择

    表示该参数能接受的值只能来自某几个值候选值中，除此以外会报错，用choices参数即可。比如：

```python
    parser.add_argument('filename', choices=['test1.txt', 'text2.txt'])  
``` 
  
#### 6. action参数

argparse内置6种动作可以在解析到一个参数时进行触发：

name | desperation  
---|---  
store | 保存参数值，可能会先将参数值转换成另一个数据类型。若没有显式指定动作，则默认为该动作。  
store_const | 保存一个被定义为参数规格一部分的值，而不是一个来自参数解析而来的值。这通常用于实现非布尔值的命令行标记。  
store_ture/store_false | 保存相应的布尔值。这两个动作被用于实现布尔开关。  
append | 将值保存到一个列表中。若参数重复出现，则保存多个值。  
append_const | 将一个定义在参数规格中的值保存到一个列表中。  
version | 打印关于程序的版本信息，然后退出  
      

```python
    import argparse  
        
    parser = argparse.ArgumentParser()  
        
    parser.add_argument('-s', action='store', dest='simple_value',  
            help='Store a simple value')  
        
    parser.add_argument('-c', action='store_const', dest='constant_value',  
            const='value-to-store',  
           help='Store a constant value')  
        
    parser.add_argument('-t', action='store_true', default=False,  
           dest='boolean_switch',  
           help='Set a switch to true')  
    parser.add_argument('-f', action='store_false', default=False,  
           dest='boolean_switch',  
           help='Set a switch to false')  
        
    parser.add_argument('-a', action='append', dest='collection',  
           default=[],  
           help='Add repeated values to a list')  
        
    parser.add_argument('-A', action='append_const', dest='const_collection',  
           const='value-1-to-append',  
           default=[],  
           help='Add different values to list')  
    parser.add_argument('-B', action='append_const', dest='const_collection',  
           const='value-2-to-append',  
           help='Add different values to list')  
        
    parser.add_argument('--version', action='version', version='%(prog)s 1.0')  
        
    results = parser.parse_args()  
    print 'simple_value     =', results.simple_value  
    print 'constant_value   =', results.constant_value  
    print 'boolean_switch   =', results.boolean_switch  
    print 'collection       =', results.collection  
    print 'const_collection =', results.const_collection
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$ python argparse_action.py -h  
    
usage: argparse_action.py [-h] [-s SIMPLE_VALUE] [-c] [-t] [-f]  
                          [-a COLLECTION] [-A] [-B] [--version]  
    
optional arguments:  
  -h, --help       show this help message and exit  
  -s SIMPLE_VALUE  Store a simple value  
  -c               Store a constant value  
 -t               Set a switch to true  
 -f               Set a switch to false  
 -a COLLECTION    Add repeated values to a list  
 -A               Add different values to list  
 -B               Add different values to list  
 --version        show program's version number and exit
1
2
3
4
5
6
7
$ python argparse_action.py -s value  
    
simple_value     = value  
constant_value   = None  
boolean_switch   = False  
collection       = []  
const_collection = []
1
2
3
4
5
6
7
$ python argparse_action.py -c  
    
simple_value     = None  
constant_value   = value-to-store  
boolean_switch   = False  
collection       = []  
const_collection = []
1
2
3
4
5
6
7
$ python argparse_action.py -t  
    
simple_value     = None  
constant_value   = None  
boolean_switch   = True  
collection       = []  
const_collection = []
1
2
3
4
5
6
7
$ python argparse_action.py -f  
    
simple_value     = None  
constant_value   = None  
boolean_switch   = False  
collection       = []  
const_collection = []
1
2
3
4
5
6
7
$ python argparse_action.py -a one -a two -a three  
    
simple_value     = None  
constant_value   = None  
boolean_switch   = False  
collection       = ['one', 'two', 'three']  
const_collection = []
1
2
3
4
5
6
7
$ python argparse_action.py -B -A  
    
simple_value     = None  
constant_value   = None  
boolean_switch   = False  
collection       = []  
const_collection = ['value-2-to-append', 'value-1-to-append']
1
2
3
$ python argparse_action.py --version  
    
argparse_action.py 1.0

参考

  1. https://mkaz.tech/python-argparse-cookbook.html
  2. https://docs.python.org/2/howto/argparse.html