Python模块百科_命令行参数解析模块argparse
- 一、简介(argparse)
- 二、命令行参数解析器类(ArgumentParser)
- 三、添加命令行参数解析规则(add_argument)
- 3.1 关键字name or flags
- 3.2 关键字action
- 3.2.1 store
- 3.2.2 store_const
- 3.2.3 store_true 和 store_false
- 3.2.4 append
- 3.2.5 append_const
- 3.2.6 count
- 3.2.7 help
- 3.2.8 version
- 3.3 关键字nargs
- 3.3.1 N (an integer)
- 3.3.2 '?'
- 3.3.3 '*'
- 3.3.4 '+'
- 3.3.5 argparse.REMAINDER
- 3.4 关键字const
- 3.5 关键字default
- 3.6 关键字type
- 3.7 关键字choices
- 3.8 关键字required
- 3.9 关键字help
- 3.10 关键字dest
- 3.11 关键字metavar
- 四、命令行参数解析结果
一、简介(argparse)
argparse
是 Python 的标准库之一,用于编写用户友好的命令行接口。它提供了一种方式来解析命令行参数和选项,并将它们转换为 Python 对象。
argparse
模块的基本使用包含5步:
- import
argparse
模块 - 创建命令行参数解析器对象
- 添加命令行参数解析规则
- 解析命令行参数
- 读取解析结果对象
以下是简单示例
# 1 import argparse模块
import argparse# 2 创建命令行参数解析器对象
parser = argparse.ArgumentParser(description='Process some integers.')# 3 添加命令行参数解析规则
parser.add_argument('integers', metavar='N', type=int, nargs='+',help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',const=sum, default=max,help='sum the integers (default: find the max)')# 4 解析命令行参数
args = parser.parse_args()# 5 读取解析结果对象
print(args.integers)
二、命令行参数解析器类(ArgumentParser)
通过ArgumentParser()
函数的调用可获取解析器对象ArgumentParser
,下面为简单示例
# usage 字段
usage: 程序名 [-h|--help] .....# Description 字段
程序功能描述# 位置参数说明(必选)
positional arguments:...# 可选参数说明
optional arguments:
...# 补充说明字段
...
usage: PROG [-h] [--foo [FOO]] bar [bar ...]bar helppositional arguments:bar bar helpoptional arguments:-h, --help show this help message and exit--foo [FOO] foo helpAnd that's how you'd foo a bar
解析器对象的成员及其功能
名字 | 默认值 | 功能 |
---|---|---|
prog | sys.argv[0] | -h 时显示的程序名 |
usage | - | usage字段描述 |
description | None | description字段描述 |
epilog | None | 补充字段描述 |
parents | None | 从父(公共)解析器中继承所有的参数选项 |
formatter_class | None | 定制说明文本的显示风格 |
prefix_class | - | 定制前缀字符,例如前缀**“-b"改为“+b”** |
add_help | True | 是否使能显示参数 -h --help |
allow_abbrev | True | 是否支持长参数 |
fromfile_prefix_chars | None | |
argument_default | None | |
conflict_handler | None |
比较常用的是description
parser = argparse.ArgumentParser(description='Process some integers.')
或者
parser = argparse.ArgumentParser()
parser.descritpioin="Process some integers."
三、添加命令行参数解析规则(add_argument)
add_argument是解析器类ArgumentParsert的核心方法,用于向解析器添加参数解析规则,以下是主要语法
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 | 选项必选or可选 |
help | 参数描述 |
metavar | 使用说明中显示的参数名 |
dest | 选项最终在解析结果对象中的名字 |
3.1 关键字name or flags
关键字name是什么,flags又是什么,两者有什么差别呢
name表示参数名,其赋值与位置顺序相关,因此也叫位置参数名,命令行中必须赋值
flags表示-|--
开头的参数名,命令行中可选参数
# 可选的flags参数
parser.add_argument('-f', '--foo')# 必选的name位置参数
parser.add_argument('parm0')
parser.add_argument('parm1')
这里假设--foo
需要带1个参数,那么
prog arg1 --foo arg2 arg3
- arg1 是位置参数parm0的值
- arg2 是可选参数’-f, --foo’的值
- arg3 是位置参数parm1的值
换句话来说,在输入的命令行中,除去所有-|--
开头的参数及其带上的参数值之外,剩下的参数都为位置参数,其顺序依次对应使用add_argument注册的位置参数顺序。
在命令行调用中,位置参数必须赋值,即每个必选参数都要有赋值;而可选参数(-|--)
可根据需求选择
3.2 关键字action
关键字action控制匹配到命令行选项后的行为
关键字action只支持以下值,如下表:
值 | 含义 |
---|---|
store | 保存参数值 |
store_const | 与关键字const配合使用,保存关键字const的值 |
store_true | 保存值为True |
store_false | 保存值为False |
append | 保存多次选项值为列表 |
append_const | 与关键字const配合使用,保存关键字const的值为列表 |
const | 保存选项的出现次数 |
help | 效果等效于-h 和 --help |
version | 打印版本 |
3.2.1 store
保存参数值,这也是默认的行为
parser = argparse.ArgumentParser()
parser.add_argument('--foo')
parser.parse_args('--foo 1'.split())
在parse_args()
之后,--foo
选项的值就保存到了parse_args()
的解析结果对象中。
可以这样获取解析结果对象的值:
args = parser.parse_args('--foo 1'.split())
print(args.foo)# 执行结果
1
选项名是解析结果对象的成员,而选项对应的值则是成员的值
3.2.2 store_const
在匹配到选项后,存储关键字const的值,常用于命令行中不带参数的选项
parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='store_const', const=42)
args = parser.parse_args(['--foo'])
print(args.foo)# 执行结果
42
从上面的例子,可以看到,在匹配到--foo
后,对应成员foo的保存为了const参数
的值。
但更多时候,不带参数的选项更多只是表示布尔型的开关,这时候可用store_true
或者store_false
3.2.3 store_true 和 store_false
store_true
和store_false
是一种特殊的store_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')
args = parser.parse_args('--foo --bar'.split())
print(args.foo, args.bar, args.baz)# 执行结果
True False True
示例中有3个布尔型“开关”,可以发现有以下特点:
store_true
在匹配到命令选项后,保存为True
;相对的,store_false
保存为False
- 当命令行中没匹配到开关后,例如示例中的
baz
,则保存为store_false
的相反值True
3.2.4 append
把所有值保存为一个列表,常用于支持多次选项的情况
parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='append')
args = parser.parse_args('--foo 1 --foo 2'.split())
print(args.foo)# 执行结果
['1', '2']
3.2.5 append_const
与store_const
非常相似,只是把值存储为一个列表。此时如果没有指定关键字const,则默认为None
。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)
args = parser.parse_args('--str --int'.split())
print(args.types)# 执行结果
[<class 'str'>, <class 'int'>]
- 关键字dest用于指定成员名
- 参数的值可以是各种对象,包括类型对象,即示例中的str类型和int类型
在示例中,--str
的常量值是str类型,以列表形式保存到types成员;--int
的常量值是int类型,以列表形式保存到types成员
3.2.6 count
如果只需要统计选项出现的次数,此处可以用count
,
parser = argparse.ArgumentParser()
parser.add_argument('--verbose', '-v', action='count')
args = parser.parse_args(['-vvv'])
print(args.verbose)# 执行结果
3
3.2.7 help
打印帮助信息,功能等效于-h|--help
parser = argparse.ArgumentParser(prog='frobble')
parser.add_argument('--foo', action='store_true',help='foo the bars before frobbling')
parser.add_argument('bar', nargs='+',help='one of the bars to be frobbled')
parser.parse_args(['-h'])
3.2.8 version
打印版本信息,需要配合关键字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
3.3 关键字nargs
关键字nargs是number argumemts的缩写,表示选项有多少个参数,其支持以下值:
值 | 含义 |
---|---|
N (an integer) | 收集N个参数到列表 |
‘?’ | 无参数或单个参数 |
‘*’ | 大于等于0个参数 |
‘+’ | 大于等于1个参数 |
argparse.REMAINDER | 只收集不解析 |
当没有指定关键字nargs时,其实际的值取决于关键字action,例如当action = "store"
时,默认获取1个参数,当action = "store_true"
时,选项不需要带参数。
3.3.1 N (an integer)
此处的N
,表示一个整型数字,含义为选项需要提供N个参数。
parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs=2)
parser.add_argument('bar', nargs=1)
args = parser.parse_args('c --foo a b'.split())
print(args.foo, args.bar)# 执行结果
['a', 'b'] ['c']
需要注意的是,当nargs = 1
时,其并不等效于关键字nargs的默认情况。
parser = argparse.ArgumentParser()
parser.add_argument('bar0', nargs=1)
parser.add_argument('bar1')
args = parser.parse_args('a b'.split())
print(args.bar0, args.bar1)# 执行结果
['a'] 'b'
可以发现,nargs = 1
时,例如bar0,其值是一个列表,一个只有1个元素的列表;而默认情况下,就是一个元素,官方称为item
。
3.3.2 ‘?’
nargs='?'
可以实现3种场景:
- 输入的命令行中,选项带参数时,值为附带的参数
- 输入的命令行中,没有改选项时,值为关键字default的值
- 输入的命令行中,有选项但没带参数时,值为关键字const的值(只适用于可选选项(flag))
parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs='?', const='c', default='d')
parser.add_argument('bar', nargs='?', default='d')
args = parser.parse_args(['XX', '--foo', 'YY'])
print(args.bar, args.foo)
args = parser.parse_args(['XX', '--foo'])
print(args.bar, args.foo)
args = parser.parse_args([])
print(args.bar, args.foo)# 执行结果
'XX' 'YY'
'XX' 'C'
'd' 'd'
一个更常用的场景,是实现可选的输入输出文件,例如:
parser = argparse.ArgumentParser()
parser.add_argument('infile', nargs='?', type=argparse.FileType('r'), default=sys.stdin)
parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'), default=sys.stdout)
print(parser.parse_args(['input.txt', 'output.txt']))
print(parser.parse_args([]))# 执行结果
Namespace(infile=<_io.TextIOWrapper name='input.txt' mode='r' encoding='cp936'>, outfile=<_io.TextIOWrapper name='output.txt' mode='w' encoding='cp936'>)
Namespace(infile=<_io.TextIOWrapper name='<stdin>' mode='r' encoding='UTF-8'>, outfile=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='UTF-8'>)
3.3.3 ‘*’
nargs=2
会限制一定要有2个参数,如果需要任意多个参数呢?可以用nargs='*'
,
parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs='*')
parser.add_argument('--bar', nargs='*')
parser.add_argument('baz', nargs='*')
args = parser.parse_args('a b --foo x y --bar 1 2'.split())
print(args.bar, args.baz, args.foo)# 执行结果
['1', '2'] ['a', 'b'] ['x', 'y']
与nargs=N
相似,最终的值是列表类型。
3.3.4 ‘+’
nargs='+'
与nargs='*'
从功能上非常相似,唯一不同的地方在于,nargs='+'
要求至少要有1个参数,否则会报错。
'?'
,'+'
与'*'
的定义与正则表达式中的?
,+
和*
非常相似
在正则表达式中,
- ?:表示0或1个字符
- +:表示大于等于1个字符
- *:表示大于等于0个字符
示例如下:
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('foo', nargs='+')
args = parser.parse_args(['a', 'b'])
print(args.foo)
args = parser.parse_args([])# 执行结果
['a', 'b']
usage: PROG [-h] foo [foo ...]
PROG: error: the following arguments are required: foo
3.3.5 argparse.REMAINDER
nargs=argparse.REMAINDER
常用于收集参数后传递给其他的命令行解析工具,其不会解析-|--
,只是收集所有选项到列表。
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('--foo')
parser.add_argument('command')
parser.add_argument('args', nargs=argparse.REMAINDER)
print(parser.parse_args('--foo B cmd --arg1 XX ZZ'.split()))# 执行结果
Namespace(args=['--arg1', 'XX', 'ZZ'], command='cmd', foo='B')
上例中,argparse没有解析args
选项的--arg1
,而是全部收集到了一个列表
3.4 关键字const
在关键字acton和关键字nargs中,其实已经涉及了关键字const的所有功能。
关键字const只是存储一个常量值,在以下两种情况下才会使用:
action='store_const'
或者action='append_const'
nargs='?'
当使用action='store_const'
和action='append_const'
时,关键字const必须提供,对其他的action关键字时,默认值为None
3.5 关键字default
选项不带参数,或者命令行没对应选项,这时候就可以使用默认值,而关键字default存储的就是默认值。默认情况下,关键字default的值为None
。
parser = argparse.ArgumentParser()
parser.add_argument('--foo', default=42)
print(parser.parse_args(['--foo', '2']))
print(parser.parse_args([]))# 执行结果
Namespace(foo='2')
Namespace(foo=42)
如果关键字default赋值的是字符串,而关键字type有指定参数类型,那么就会把字符串转为关键字type指定的类型,
parser = argparse.ArgumentParser()
parser.add_argument('--length', default='10', type=int)
parser.add_argument('--width', default=10.5, type=int)
print(parser.parse_args())# 执行结果
Namespace(length=10, width=10.5)
如果[关键字nargs为?
或者*
,那么default的值会在命令行没有参数时使用,
parser = argparse.ArgumentParser()
parser.add_argument('foo', nargs='?', default=42)
print(parser.parse_args(['a']))
print(parser.parse_args([]))# 执行结果
Namespace(foo='a')
Namespace(foo=42)
关键字default也提供一种特殊用法:default=argparse.SUPPRESS
。在这种情况下,如果命令行并没有匹配的选项,那么并不会在解析结果对象中添加选项对应的成员,
parser = argparse.ArgumentParser()
parser.add_argument('--foo', default=argparse.SUPPRESS)
print(parser.parse_args([]))
print(parser.parse_args(['--foo', '1']))# 执行结果
Namespace()
Namespace(foo='1')
3.6 关键字type
默认情况下,argparse解析的参数默认为字符串类型,当然也可以通过关键字type指定其他任何类型,例如float
,int
,甚至是文件类型file
,
parser = argparse.ArgumentParser()
parser.add_argument('foo', type=int)
parser.add_argument('bar', type=open)
print(parser.parse_args('2 temp.txt'.split()))# 执行结果
Namespace(bar=<_io.TextIOWrapper name='temp.txt' mode='r' encoding='cp936'>, foo=2)
如果关键字type指定的是文件类型,还可以通过```FileType(‘w’)以可写形式打开文件,
parser = argparse.ArgumentParser()
parser.add_argument('bar', type=argparse.FileType('w'))
print(parser.parse_args(['out.txt']))# 执行结果
Namespace(bar=<_io.TextIOWrapper name='out.txt' mode='w' encoding='cp936'>)
关键字type甚至能指定为函数,经过函数处理后的返回值作为参数值,
def perfect_square(string):value = int(string)sqrt = math.sqrt(value)if sqrt != int(sqrt):msg = "%r is not a perfect square" % stringraise argparse.ArgumentTypeError(msg)return value
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('foo', type=perfect_square)
print(parser.parse_args(['9']))
print(parser.parse_args(['7']))# 执行结果
Namespace(foo=9)
usage: PROG [-h] foo
PROG: error: argument foo: '7' is not a perfect square
3.7 关键字choices
需要限制选项的值范围时可以用关键字choices。关键字choices限定了参数值的可选列表,如果命令行提供的参数值不在列表中,则会报错,
parser = argparse.ArgumentParser(prog='game.py')
parser.add_argument('move', choices=['rock', 'paper', 'scissors'])
print(parser.parse_args(['rock']))
print(parser.parse_args(['fire']))# 执行结果
Namespace(move='rock')
usage: game.py [-h] {rock,paper,scissors}
game.py: error: argument move: invalid choice: 'fire' (choose from 'rock', 'paper', 'scissors')
当然,需要注意的是,关键字choice的值必须符合关键字type指定的类型。
3.8 关键字required
默认情况下,-f
和--foo
都是可选的,但如果需要改为必选,可以使用关键字required,
parser = argparse.ArgumentParser()
parser.add_argument('--foo', required=True)
print(parser.parse_args(['--foo', 'BAR']))
print(parser.parse_args([]))# 执行结果
Namespace(foo='BAR')
usage: argparse.py [-h] --foo FOO
argparse.py: error: the following arguments are required: --foo
3.9 关键字help
关键字help是选项的说明,在-h
或者--help
时会显示出来,
parser = argparse.ArgumentParser(prog='frobble')
parser.add_argument('--foo', action='store_true', help='foo the bars before frobbling')
parser.add_argument('bar', nargs='+', help='one of the bars to be frobbled')
parser.parse_args(['-h'])# 执行结果
usage: frobble [-h] [--foo] bar [bar ...]positional arguments:bar one of the bars to be frobbledoptional arguments:-h, --help show this help message and exit--foo foo the bars before frobbling
关键字help也支持格式化显示,%(prog)s
和大部分**add_argument()**的关键字,包括%(default)s
,%(type)s
,等等,
parser = argparse.ArgumentParser(prog='frobble')
parser.add_argument('bar', nargs='?', type=int, default=42, help='the bar to %(prog)s (default: %(default)s)')
parser.print_help()# 执行结果
usage: frobble [-h] [bar]positional arguments:bar the bar to frobble (default: 42)optional arguments:-h, --help show this help message and exit
格式为%(keyword)s
,如果需要显示%
,就需要使用%%
还存在一种特殊情况,如果不希望参数显示在*–help*中,可以用:argparse.SUPPRESS,
parser = argparse.ArgumentParser(prog='frobble')
parser.add_argument('--foo', help=argparse.SUPPRESS)
parser.print_help()# 执行结果
usage: frobble [-h]optional arguments:-h, --help show this help message and exit
3.10 关键字dest
argparse会把解析的结果保存成解析结果对象的属性,但是,属性名是什么呢?例如,parser.add_argument(’-f', '--foo')
,解析结果是保存在属性f
中还是foo
中?关键字dest就是用于定制属性名的。
对位置参数而言,关键字dest默认为第一个参数名,
parser = argparse.ArgumentParser()
parser.add_argument('bar')
print(parser.parse_args(['XXX']))# 执行结果
Namespace(bar='XXX')
对可选参数而言,关键字dest首选第一个出现的长参数名。如果没有长参数,则选择第一个短参数名。不管选择的是长参数还是短参数,都会把-|--
给去掉,同时把名字中的-
符号替换为_
,以符合python的变量命名规则,
parser = argparse.ArgumentParser()
parser.add_argument('-f', '--foo-bar', '--foo')
parser.add_argument('-x', '-y')
print(parser.parse_args('-f 1 -x 2'.split()))
print(parser.parse_args('--foo 1 -y 2'.split()))# 执行结果
Namespace(foo_bar='1', x='2')
Namespace(foo_bar='1', x='2')
定制属性名
parser = argparse.ArgumentParser()
parser.add_argument('--foo', dest='bar')
print(parser.parse_args('--foo XXX'.split()))# 执行结果
Namespace(bar='XXX')
3.11 关键字metavar
在执行-h|--help
,显示的帮助信息中,如何定制选项带的参数名呢?
-t T loop times
希望修改显示的T
为TIMES
,更直观。这时候就可以使用关键字metavar。
在默认情况下,对位置参数,会直接显示参数名,对可选参数,则会显示大写
parser = argparse.ArgumentParser()
parser.add_argument('--foo')
parser.add_argument('bar')
print(parser.parse_args('X --foo Y'.split()))
parser.print_help()# 执行结果
Namespace(bar='X', foo='Y')
usage: lib_argparse.py [-h] [--foo FOO] barpositional arguments:baroptional arguments:-h, --help show this help message and exit--foo FOO
上例中,位置参数bar直接显示为bar,而可选参数–foo带的参数名就转大写显示FOO。
定制显示的参数名
parser = argparse.ArgumentParser()
parser.add_argument('--foo', metavar='YYY')
parser.add_argument('bar', metavar='XXX')
print(parser.parse_args('X --foo Y'.split()))
parser.print_help()# 执行结果
Namespace(bar='X', foo='Y')
usage: lib_argparse.py [-h] [--foo YYY] XXXpositional arguments:XXXoptional arguments:-h, --help show this help message and exit--foo YYY
当然,还存在一种特殊情况,就是有多个参数nargs=N
,这时候关键字metavar可以以列表形式提供啦,
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('-x', nargs=2)
parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))
parser.print_help()# 执行结果
usage: PROG [-h] [-x X X] [--foo bar baz]optional arguments:-h, --help show this help message and exit-x X X--foo bar baz
最后,关键字metavar与关键字dest不一样的地方在于,关键字metavar仅仅只影响-h|–help的显示效果,关键dest则同时影响解析结果属性名
四、命令行参数解析结果
选项名是解析结果对象的成员,而选项对应的值则是成员的值,所以直接使用解析结果的成员值就行
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('-x', dest='xyz')
parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))# 执行解析
args = parser.parse_args("--foo a b -x c".split())# 读取结果
print(args.foo)
['a', 'b']
print(args.xyz)
c
may the odds be ever in your favor ~