python内置模块argparse的使用

官网文档

https://docs.python.org/3/howto/argparse.html   # 简易教程
https://docs.python.org/3/library/argparse.html#module-argparse   # 详细教程

add_argument()方法中的一些参数说明

add_argument('-f', '--foo')  # 可选参数
add_argument('foo')  # 位置参数
action  #该action关键字参数指定的命令行参数应该如何处理
action = 'store'  # 默认操作仅存储参数的值，可以不写
action = 'store_const' # 将存储由const关键字参数指定的值
action = 'store_true'  # 这些是'store_const'分别存储值True和False的情况下使用
action = 'store_false'
action = 'append'  # 存储一个列表，并将命令行的每个参数值附加到列表中
action = 'append_const' # 存储一个列表，并将const关键字参数指定的值附加到列表中，可用于多个参数需要将常量存储到同一列表，const默认参数为None
action = 'count' # 计算关键字参数出现的次数
action = 'extend' # 存储一个列表，并将每个参数值添加到列表中
nargs : 将单个命令行参数与要执行的单个操作相关联，并收集到一个列表中
nargs = N(一个整数)   # nargs=2，命令行python  test.py --foo  a b  将a,b收集到一个列表中
nargs = ?  # 表示从命令行使用一个参数，作为选项参数的值，如果命令行指定了参数的值则使用(python test.py --foo  xx)，如果不存在命令行参数(python test.py)，使用default默认值，如果存在可选项参数(python test.py --foo)，但是没有指定参数值，会使用const的值。
nargs = *  # 存在的所有命令行参数都收集到一个列表中
nargs = +  # 跟*用法一样，都会收集到一个列表中，但是如果没有命令行参数则会报错
default   # 指定默认值
type   # 指定类型 int float等
choices  # 指定某些命令行参数应从一组受限制的值中选择，如果参数不是可接受的值一直，则报错
required=True  # 指定参数值为必填
help  #帮助信息说明

type指定值的类型

import argparse
parser = argparse.ArgumentParser()
# 用于指定程序愿意接受的命令行选项
# type用于指定类型
# parser.add_argument('square', help='echo the string you use here', type=int)
args = parser.parse_args()
print(args.square**2)
运行:
python test.py 4
结果：16

可选参数--

import argparse
parser = argparse.ArgumentParser()
# --表示可选参数
parser.add_argument('--verbosity', help='increase output verbosity')
args = parser.parse_args()
# 如果加了参数，那么就会执行这段代码
if args.verbosity:
    print('verbosity turned on')
运行
python test.py --verbosity  # 不会打印if语句中的代码，且会报错
python test.py --verbosity 4  # 加了参数所以会打印if语句中的代码

可参数中action指定store_true默认隐式传递True

import argparse
parser = argparse.ArgumentParser()
# action用来指定值，并将True分配给args.verbose
# 如果在指定程序的时候，你额外加了参数的话，那么就会报错
parser.add_argument('--verbose', help='increase output verbosity', action='store_true')
args = parser.parse_args()
if args.verbose:
    print('verbosity turned on')
运行：
python test.py --verbose  # 打印if语句中的代码
python test.py --verbose 1  # 则会报错，因为已经指定了默认值，加参数的话会报错

可选选项之简短选项

import argparse
parser = argparse.ArgumentParser()
# 参数一为参数二的简短缩写，执行程序时，直接使用-v，而不使用--verbose了
parser.add_argument('-v', '--verbose', help='increase output verbosity', action='store_true')
args = parser.parse_args()
if args.verbose:
    print('verbosity turned on')
运行：
python test.py -v  # 打印if语句的代码

结合位置参数和可选参数(可选参数中指定了默认值store_true即表示True)

import argparse
parser = argparse.ArgumentParser()
# 执行代码的时候需要输入参数
parser.add_argument('square', type=int, help='display a square of a given number')
# 执行代码的时候不需要输入参数，因为指定了默认值
parser.add_argument('-v', '--verbose', help='increase output verbosity', action='store_true')
args = parser.parse_args()
# 参数**2
answer = args.square**2
# 如果为真执行下面代码
if args.verbose:
    print(f'the square of {args.square} equals {answer}')
# 否则执行下面代码
else:
    print(answer)
运行：
python test.py 4   # 16
python test.py -v 4 # 4, 16   顺序无关紧要
python test.py 4 -v  # 4, 16

结合位置参数和可选参数(没有指定默认值)

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('square', help='display a square of a given number', type=int)
parser.add_argument('-v', '--verbose', help='increase output verbose', type=int)
args = parser.parse_args()
answer = args.square**2
if args.verbose == 2:
    print(f'the square of {args.square} equals {answer}')
elif args.verbose == 1:
    print(f'{args.square}^2 == {answer}')
else:
    print(answer)
运行：
python test.py 4   # 16  4被square接收了, -v是指定可选参数，没有用-v所以就不会使用，但是要知道不指定-v，则会有隐式的默认值None
python test.py 4 -v  # 会报错，因为使用了-v，所以就要加参数
python test.py 4 -v 1   # 4^2 == 16
python test.py 4 -v 2  #  the square of 4 equals 16

可选参数中指定choices选项来限制接收的参数

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('square', type=int, help='display a square of a given number')
parser.add_argument('-v', '--verbose', choices=[0, 1, 2], help='increase output verbose', type=int)
args = parser.parse_args()
answer = args.square**2
if args.verbose == 2:
    print(f'the square of {args.square} equals {answer}')
elif args.verbose == 1:
    print(f'{args.square}^2 == {answer}')
else:
    print(answer)

运行：
python test.py 4 -v 0  # 16 , 因为-v的参数为0在choices里面，所以会执行else语句，起码不会报错了
python test.py 4 -v 3  # 会报错,因为-v的参数3，不在choices里面

可选参数中指定action="count"用来计算特定可选参数的出现次数,即把出现的次数当做参数传递

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('square', type=int, help='square number')
parser.add_argument('-v', '--verbose', action='count', help='verbose ok')
args = parser.parse_args()
answer = args.square**2
if args.verbose == 2:
    print('the square of {} equals {}'.format(args.square, answer))
elif args.verbose == 1:
    print('{}^2 == {}'.format(args.square, answer))
else:
    print(answer)
运行:
python test.py 4 -v   # 因为上面可选参数中指定了action='count', 所以这里的-v就表示出现了1次，即把1当做参数传递给verbose
python test.py 4 -vv  # -vv表示出现了2次，即把2当做参数传递给了verbose
python test.pt 4 --verbose --verbose # 同上面-vv用法一致
python test.py 4 -v 1  # 报错，因为用了action='count'，即把出现的次数当做参数传递给verbose,所以再传递参数的话就会报错

可选参数指定default默认值，使程序不使用可选参数时，做比较判断时不会报错

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('square', type=int, help='square number')
parser.add_argument('-v', 'verbose', action='count', default=0, help='verbose ok')
args = parser.parse_args()
answer = args.square**2
if args.verbose >= 2:
    print("the square of {} equals {}".format(args.square, answer))
elif args.verbose >= 1:
    print("{}^2 == {}".format(args.square, answer))
else:
    print(answer)

python test.py 4 -vvv  # the square of 4 equals 16
python test.py 4 -vvvv # the square of 4 equals 16
python test.py 4   # 16  这边要注意下，因为我们在可选参数中加了default默认值=0，所以不指定-v的时候，它不会报错，不然不加的话默认-v隐式的会有默认值None，None无法用比较符跟数值做比较

add_mutually_exclusive_group()用来解决多个可选参数中的冲突选项，即多个可选参数时，可用长格式选项和简写格式选项结合使用

import argparse
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group()
group.add_argument('-v', '--verbose', action='store_true')
group.add_argument('-q', '--quit', 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.quit:
    print(answer)
elif args.verbose:
    print("{} to the power {} equals {}".format(args.x, args.y, answer))
else:
    print("{}^{} == {}".format(args.x, args.y, answer))
运行：
python test.py 4 2 -v --quit

description描述信息，可通过python test.py --help查看

import argparse
parser = argparse.ArgumentParser(description="calculate X to the power of Y"))
group = parser.add_mutually_exclusive_group()
group.add_argument('-v', '--verbose', action='store_true')
group.add_argument('-q', '--quit', 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.quit:
    print(answer)
elif args.verbose:
    print("{} to the power {} equals {}".format(args.x, args.y, answer))
else:
    print("{}^{} == {}".format(args.x, args.y, answer))
运行：
python test.py 4 2 -v --quit