Python - Argparse_guidebook

发表于 更新于

主要学习官网文档

模块功能的介绍

argparse 模块的作用就是 在程序外加一个接口 通过命令的方式 向程序传入参数

可类比 ls -l 的例子 其中 -l就是可以看成一个参数

该模块 也有很多的参数 有可选参数 和默认的参数 其特点是 所有参数 均可自行定义

1
2
3
import argparse  ## 导入模块
parser = argparse.ArgumentParser() ## 定义模块的声明  在括号内可以添加 描述性的内容
parser.parse_args() ## 用于获取传进来的参数 类似于字典形式 可以通过args.参数名的形式访问

位置参数的介绍

1
2
3
4
5
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("echo")  ## 添加参数
args = parser.parse_args()  
print(args.echo)  ## 把输入的参数保存在这里
1
2
python3 prog.py foo  ## 输入
foo  ## 输出

还可以添加一些描述性的内容

1
2
3
4
5
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("echo", help="echo the string you use here") ## 这里出现提示 使用 help=‘’
args = parser.parse_args()
print(args.echo)

当输入的参数未声明类型的时候 默认是字符所以无法进行数字运算

1
2
3
4
5
6
7
8
9
10
11
12
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", help="display a square of a given number")
args = parser.parse_args()
print(args.square**2
      
## 输出结果
python3 prog.py 4
Traceback (most recent call last):
  File "prog.py", line 5, in <module>
    print(args.square**2)
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int

通过在add方法中 加入type = int 来指定类型

1
2
3
4
5
6
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", help="display a square of a given number",
                    type=int) ## 这里指定了了输入的类型
args = parser.parse_args()
print(args.square**2

可选参数介绍（使用- 来表示）

1
2
3
4
5
6
7
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--verbosity", help="increase output verbosity")
## -- 表示为可选参数
args = parser.parse_args()
if args.verbosity:
    print("verbosity turned on")

可以给参数接受的类型时 如果只有两种选择 True and False，可以采用action = 'store_true'来表示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--verbose", help="increase output verbosity",
                    action="store_true")## 这里表示 verbose参数只有两种情况
#为 args.verbose 赋值为 True。没有指定时则隐含地赋值为 False
args = parser.parse_args()
if args.verbose:
    print("verbosity turned on")
## 输出   
python3 prog.py --verbose ## 指定时 为True 如果没有指定 则为false
verbosity turned on  
python3 prog.py --verbose 1  ## 这时不能再指定其他类型
usage: prog.py [-h] [--verbose]
prog.py: error: unrecognized arguments: 1

短选项

可以使用一个-和一个字母来代替较长的参数

1
2
3
4
5
6
7
8
9
10
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbose", help="increase output verbosity",
                    action="store_true") ## 这里在输入参数时 使用 -v 和使用 --verbose一样
args = parser.parse_args()
if args.verbose:
    print("verbosity turned on")
    ## 输出
    python3 prog.py -v
	verbosity turned o

结合位置参数和可选参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbose", action="store_true",
                    help="increase output verbosity") ## 这里两个参数 一个是必填参数 一个是可选参数 可以从结果看出两者的区别
args = parser.parse_args()
answer = args.square**2
if args.verbose:
    print(f"the square of {args.square} equals {answer}")
else:
    print(answer)
    
    ##输出
python3 prog.py
usage: prog.py [-h] [-v] square
prog.py: error: the following arguments are required: square ## 不输入必选参数会报错的
python3 prog.py 4
16
python3 prog.py 4 --verbose 
the square of 4 equals 16
python3 prog.py --verbose 4
the square of 4 equals 16
  • 我们带回了一个位置参数，结果发生了报错。
  • 注意顺序无关紧要

还可有通过choices 关键字来限定参数的输入范围

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbosity", type=int, choices=[0, 1, 2],
                    help="increase output verbosity")
## 这里choices 限定了 只能在0 1 2 中选
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
    print(f"the square of {args.square} equals {answer}")
elif args.verbosity == 1:
    print(f"{args.square}^2 == {answer}")
else:
    print(answer)

还可以用count参数来表示输入参数的数字

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
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display the square of a given number")
parser.add_argument("-v", "--verbosity", action="count",
                    help="increase output verbosity")
## 这里count 表示参数出现的个数 表且将这个数字传进来  -vv 等于2 -v等于1
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
    print(f"the square of {args.square} equals {answer}")
elif args.verbosity == 1:
    print(f"{args.square}^2 == {answer}")
else:
    print(answer)
    ## 输出
python3 prog.py 4
16
python3 prog.py 4 -v
4^2 == 16
python3 prog.py 4 -vv
the square of 4 equals 16
python3 prog.py 4 --verbosity --verbosity
the square of 4 equals 16
python3 prog.py 4 -v 1
usage: prog.py [-h] [-v] square
prog.py: error: unrecognized arguments:

还可以加入一些默认值 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
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("x", type=int, help="the base")
parser.add_argument("y", type=int, help="the exponent")
parser.add_argument("-v", "--verbosity", action="count", default=0) ## 当可选参数为出现时 默认为0
args = parser.parse_args()
answer = args.x**args.y
if args.verbosity >= 2:
    print(f"{args.x} to the power {args.y} equals {answer}")
elif args.verbosity >= 1:
    print(f"{args.x}^{args.y} == {answer}")
else:
    print(answer)
    ## 输出
    python3 prog.py
usage: prog.py [-h] [-v] x y
prog.py: error: the following arguments are required: x, y
python3 prog.py -h
usage: prog.py [-h] [-v] x y

positional arguments:
  x                the base
  y                the exponent

options:
  -h, --help       show this help message and exit
  -v, --verbosity
python3 prog.py 4 2 -v
4^2 == 16

以及有可能两个参数产生矛盾 要尽可能避免

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
import argparse

parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group()
group.add_argument("-v", "--verbose", action="store_true")
group.add_argument("-q", "--quiet", action="store_true")
parser.add_argument("x", type=int, help="the base")
parser.add_argument("y", type=int, help="the exponent")
args = parser.parse_args()
answer = args.x**args.y

if args.quiet:
    print(answer)
elif args.verbose:
    print(f"{args.x} to the power {args.y} equals {answer}")
else:
    print(f"{args.x}^{args.y} == {answer}")
    
    # 输出
    python3 prog.py 4 2
4^2 == 16
python3 prog.py 4 2 -q
16
python3 prog.py 4 2 -v
4 to the power 2 equals 16
python3 prog.py 4 2 -vq
usage: prog.py [-h] [-v | -q] x y
prog.py: error: argument -q/--quiet: not allowed with argument -v/--verbose
python3 prog.py 4 2 -v --quiet
usage: prog.py [-h] [-v | -q] x y
prog.py: error: argument -q/--quiet: not allowed with argument -v/--verbose
            
## 当q v 两个参数同时出现时 不知道该执行 if 还是elif 因为这里没有顺序的问题