麦子学院 2017-07-13 19:04
Python的argparse库如何使用？
回复:0 查看:2403
argparse
是一个用于解析 命令行选项，参数以及 子命令的库
主要功能：
1
、使得用户编写命令行变得简单
2
、针对程序需要的参数，
argparse
知道如何从
sys.argv
中解析这些参数
3
、针对用户给程序无效的参数，
argparse
可以自动生成帮助
usage
范例1:
写一个
python
文件或者函数，这个
python
程序接受一个整数列表，并生成它们的和 或者是它们之中最大的一个数
$
cat prog.
py
#coding:utf-8
import argparse
parser = argparse.ArgumentParser(description='some integers')
parser.add_argument('integers', metavar='N', type=
int, nargs='+',
help='an integer for accumulator')
parser.add_argument('--sum', dest='accumulate', action= 'store_const', const=sum, default=max,
help='sum the integers (default: find the max)')
args = parser.parse_args()
print(
args.accumulate(
args.integers))
然后针对这个文件提供参数，或者是提供选项 -h
$
python prog.
py 2 3 4 55
$
python prog.
py --sum 1 5 6773
$
python prog.
py --
help
usage: prog.
py [-h] [--sum]
N [
N ...]
some integers
positional
arguments:
N
an integer
for accumulator
optional
arguments:
-h, --
help show this
help message and
exit
--sum sum the integers (default:
find the max)
$
python prog.
py -h
usage: prog.
py [-h] [--sum]
N [
N ...]
some integers
positional
arguments:
N
an integer
for accumulator
optional
arguments:
-h, --
help show this
help message and
exit
--sum sum the integers (default:
find the max)
当试图传入一个字符给程序时，会报错
$
python prog.
py
a vb
c
usage: prog.
py [-h] [--sum]
N [
N ...]
prog.
py: error:
argument
N: invalid
int value: 'a'
1、创建一个命令行选项等的解析器
argparse.ArgumentParser
会创建一个对象，这个对象包含了将命令行解析为
python
数据类型所需的所有信息
argparse
方法一: add_argument()
用这个方法来填充ArgumentParser
生成的对象，这个包含了程序参数的信息
,
一般来说，这些调用可让
ArgumentParser
如何在
cmd
命令行接受字符串
并把它们变成对象，当调用parse_args()
时候，将存储并使用该信息
.
例如:
parser.add_argument('integers', metavar='N', type=
int, nargs='+',
help='an integer for accumulator')
parser.add_argument('--sum', dest='accumulate', action= 'store_const', const=sum, default=max,
help='sum the integers (default: find the max)')
当调用parse_args()
时，就会返回两个属性，
integers
和
accumulater
属性
, integers
属性接受 一个数字或者是多个数字，
而accumulater
属性可以接受一个
--sum
选项，当命令行中带有
--sum
选项以后，它代表的是系统的
sum()
函数的功能，若不带
--sum
选项，就是代表
max()
函数功能
解析命令行参数:
ArgumentParser
通过
parse_args()
方法来解析这些参数
,
它会检测命令行，把不同的参数转换成合适的格式从而调用不同的处理方式
,
大多情况下，当从命令行解析参数时，会构建一个简单的命名空间
.
In [7]:
parser.parse_args(['--sum','7','10','99'])
Out[7]:
Namespace(accumulate=, integers=[7, 10, 99])
在脚本中，parse_args()
通常不加参数的情况被调用
, ArgumentParser
会从
sys.argv
自动匹配命令行里面的参数
ArgumentParser方法分析
class argparse.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,
allow_abbrev=True)
所有参数都需要以关键字参数来传递。
下面是每个参数的详细解释:
下面是示例:
prog:
默认情况下,
ArgumentParser这个对象使用sys.argv[0]决定展示帮助页面,当你在命令行 调用这个程序自身，它会显示帮助信息
例如，假如一个叫myprog.py
的脚本
$
vim myprog.
py
#!/usr/local/Cellar/pyenv/versions/3.6.1/bin/
python3
#coding:utf-8
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo',
help='foo help')
args = parser.parse_args()
$
python myprog.
py --
help
usage: myprog.
py [-h] [--foo FOO]
optional
arguments:
-h, --
help show this
help message and
exit
--foo FOO foo
help
另一种方法，ArgumentParser
支持
prog=
的参数也可以达到同样效果，代码如下
:
In [1]: import argparse
In [2]: parser = argparse.ArgumentParser(prog='myprog')
In [3]: parser.print_help()
usage: myprog [-h]
optional arguments:
-h, --help show this help message and
exit
#
这里要注意，执行当前
shell
的目录里要有
myprog.py
这个文件
注意这个程序名称，不管是使用sys.argv[0]
还是
prog=
这种方法，都等价于使用
%(prog)s
这个格式化方法
In [3]: parser.add_argument('--foo',help='foo of the %(prog)s program')
Out[3]: _StoreAction(option_strings=['--foo'], dest='foo', nargs=None,
const=None,
default=None,
type=None, choices=None, help='foo of the %(prog)s program', metavar=None)
In [4]: parser.print_help()
usage: myprog [-h] [--foo FOO]
optional arguments:
-h, --help show this help
message
and
exit
--foo FOO foo
of the myprog
program
或者使用usage=
这种方法
In [2]: parser = argparse.ArgumentParser(prog='PROG',usage='%(prog)s [options]')
In [3]: parser.add_argument('--foo',nargs='?',
help='foo help')
Out[3]: _StoreAction(option_strings=['--foo'], dest='foo', nargs='?', const=None, default=None, type=None, choices=None,
help='foo help', metavar=None)
In [4]: parser.add_argument('bar',nargs='+',
help='bar help')
Out[4]: _StoreAction(option_strings=[], dest='bar', nargs='+', const=None, default=None, type=None, choices=None,
help='bar help', metavar=None)
In [5]: 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
description
大多ArgumentParser
实例在构造的时候都会使用
description=
这个参数，这个参数会告诉你程序是如何工作的，描述信息会显示在
usage
和参数之间
In [1]: import argparse
In [2]: parser = argparse.ArgumentParser(description=' example ')
In [3]: parser.print_help()
usage: ipython [-h]
example
optional arguments:
-h, --help show this help message and
exit
默认情况下，description
的就会显示在这行里，可以通过
formatter_class
参数来修改
epilog
主要针对有一些程序会在参数描述附加程序描述,
默认是显示在
optional argument
描述以后
In [4]: parser = argparse.ArgumentParser(description=' example ',epilog=' haha that is the end' )
In [5]: parser.print_help()
usage: ipython [-h]
example
optional arguments:
-h, --help show this help message and
exit
haha that is the end
如果想修改，需要调整
formatter_class argument
修改
parents
有时候，几个parser
需要共享常见的参数。 这时候，与其重复的定义这些参数，不如使用一个包含所有参数的
parser,
然后再通过
parents=
这个参数传递这些参数
. parets=
参数可以接受一个
ArgumentParser
对象的列表，收集所有 位置的和可选的操作，将这些操作加入一个正在构造的
ArgumentParser
中
In [6]: parent_parser = argparse.ArgumentParser(add_help=False)
In [7]: parent_parser.add_argument('--parent',
type=int)
Out[7]: _StoreAction(option_strings=['--parent'], dest='parent', nargs=None,
const=None,
default=None,
type=<
class 'int'>, choices=None, help=None, metavar=None)
In [8]: foo_parser = argparse.ArgumentParser(parents=[parent_parser])
In [9]: foo_parser.add_argument('foo')
Out[9]: _StoreAction(option_strings=[], dest='foo', nargs=None,
const=None,
default=None,
type=None, choices=None, help=None, metavar=None)
In [10]: foo_parser.parse_args(['--parent','2','xx'])
Out[10]: Namespace(foo='xx', parent=2)
In [11]: bar_parser = argparse.ArgumentParser(parents=[parent_parser])
In [12]: bar_parser.add_argument('--bar')
Out[12]: _StoreAction(option_strings=['--bar'], dest='bar', nargs=None,
const=None,
default=None,
type=None, choices=None, help=None, metavar=None)
In [13]: bar_parser.parse_args(['--bar','yy'])
Out[13]: Namespace(bar='yy', parent=None)
In [14]: parent_parser.print_help()
usage: ipython [--parent PARENT]
optional arguments:
--parent PARENT
In [15]: foo_parser.print_help()
usage: ipython [-h] [--parent PARENT] foo
positional arguments:
foo
optional arguments:
-h, --help show this help message and
exit
--parent PARENT
In [16]: bar_parser.print_help()
usage: ipython [-h] [--parent PARENT] [--bar BAR]
optional arguments:
-h, --help show this help message and
exit
--parent PARENT
--bar BAR
这里，我定义了一个父类parent_parser
以及两个子类
foo_parser
和
bar_parser
，这两个子类明确指定了
parents=[parent_parser]
注意，这里很多父类在初始化的时候都指定了 add_help=False,
如果不指定的话
,
当使用
-h,
或者
--help
的时候会看到两个选项并且引发
error
还要注意，父类parser
必须完全初始化才能通过
parents=
传给子类，如果你没有这样做的话，后面对于父类
parser
做的修改都不会反应在子类
parser
中
formatter_class
ArgumentParser对象允许一个可以定制化的类来被格式化, 目前，支持这4个类
class argparse. RawDescriptionHelpFormatter
class argparse. RawTextHelpFormatter
class argparse. ArgumentDefaultsHelpFormatter
class argparse. MetavarTypeHelpFormatter
其中，RawDescriptionHelpFormatter and RawTextHelpFormatter 这两个类会对文本显示格式有更多的限定,在默认情况下，ArgumentParser会在显示命令行帮助信息中对description= 和 epilog= 自动换行。
In [1]: import argparse
In [2]: parser = argparse.ArgumentParser(
...: prog='PROG',
...: description=''' that
...: is
...: a description ''',
...: epilog=''' that
...: is
...: a epilog ''')
...:
In [3]: parser.print_help()
usage: PROG [-h]
that is a description #
可以看到自动换行
optional arguments:
-h, --help show this help message and
exit
that is a epilog
#
可以看到自动换行
通过传递formatter_class=
说明
description=
和
epilog=
已经被格式化并且不应该换行了
In [4]: parser = argparse.ArgumentParser(prog='hey!',
...: formatter_class=argparse.RawDescriptionHelpFormatter,
...: description=''' let
...: us
...: do it''')
...:
In [5]: parser.print_help()
usage: hey! [-h]
let
us
do it
optional arguments:
-h, --help show this help message and
exit
RawTextHelpFormatter 为各种帮助信息保留了空白，包括参数描述信息
ArgumentDefaultsHelpFormatter这个类会自动为每个参数的帮助信息添加默认值
In [9]: parser = argparse.ArgumentParser(
...: prog='hey',
...: formatter_class=argparse.ArgumentDefaultsHelpFormatter)
...:
In [10]: parser.add_argument('--foo',
type=int,
default=42,help='foo!')
Out[10]: _StoreAction(option_strings=['--foo'], dest='foo', nargs=None,
const=None,
default=42,
type=<
class 'int'>, choices=None, help='foo!', metavar=None)
In [11]: parser.add_argument('bar',nargs='*',
default=[1,2,3,4],help='bar!')
Out[11]: _StoreAction(option_strings=[], dest='bar', nargs='*',
const=None,
default=[1, 2, 3, 4],
type=None, choices=None, help='bar!', metavar=None)
In [12]: parser.print_help()
usage: hey [-h] [--foo FOO] [bar [bar ...]]
positional arguments:
bar bar! (
default: [1, 2, 3, 4])
optional arguments:
-h, --help show this help
message
and
exit
--foo FOO foo! (
default: 42)
MetavarTypeHelpFormatter 为每个参数以 参数的类型作为显示，摒弃了常规使用dest的模式
In [13]: parser = argparse.ArgumentParser(
...: prog='
HELP',
...: formatter_class=argparse.MetavarTypeHelpFormatter)
...:
In [14]: parser.add_argument('--foo',type=int)
Out[14]: _StoreAction(option_strings=['--foo'], dest='foo', nargs=
None, const=
None,
default=
None,
type=<
class 'int'>, choices=
None,
help=
None, metavar=
None)
In [15]: parser.add_argument('bar',
type=float)
Out[15]: _StoreAction(option_strings=[], dest='bar', nargs=
None, const=
None,
default=
None,
type=<
class 'float'>, choices=
None,
help=
None, metavar=
None)
In [16]: parser.print_help()
usage:
HELP [-h] [--foo int] float
positional arguments:
float
optional arguments:
-h, --help show this help message and exit
--foo int
prefix_chars
许多命令行选项都用"-"
当前缀，比如
-h
或者
--help,Parser
可以通过
prefix_chars
来设置不同的前缀符号
你可以用"+"
或者使用
"/"
1 In [1]:
import argparse
2
3 In [2]: parser = argparse.ArgumentParser(prog='PROG',prefix_chars="-+")
4
5 In [3]: parser.add_argument('+f')
6 Out[3]: _StoreAction(option_strings=['+f'], dest='f', nargs=
None, const=
None, default=
None, type=
None, choices=
None, help=
None, metavar=
None)
7
8 In [4]: parser.add_argument('++bar')
9 Out[4]: _StoreAction(option_strings=['++bar'], dest='bar', nargs=
None, const=
None, default=
None, type=
None, choices=
None, help=
None, metavar=
None)
10 In [5]: parser.print_help()
11
12
13
14 In [5]: parser.print_help()
15 usage: PROG [-h] [+f F] [++bar BAR]
16
17 optional arguments:
18 -h, --help show this help message
and exit
19 +f F
20 ++bar BAR
prefix_chars=
默认的参数是
'-'.
fromfile_prefix_chars
有的情况下，当处理特别长的参数列表，将这个参数列表保存在文件中，也可以支持
这个需要在构建ArgumentParser
的时候加入
fromfile_prefix_chars =
选项
argument_default
一般来说，参数都通过add_argument()
来指定或者通过调用
setdefaults()
传递
name-value
的方法
有时候，需要为参数指定一个单独的默认值，通过给ArgumentParser
指定
argument_default
关键字参数即可
比如，可以通过argument_default=SUPPERSS
来阻止在
parse_args()
中全局创建属性
conflict_handler
ArgumentParser
对象不允许使用同一个选项字串来表示两个操作
,
若尝试在 已经使用的选项新建一个参数的话，就说引发异常
1
In [7]: parser = argparse.ArgumentParser(prog='PROG')
2
3
In [8]: parser.add_argument('-f','--foo',help='old foo help')
4
Out[8]: _StoreAction(option_strings=['-f', '--foo'], dest='foo', nargs=None,
const=None,
default=None,
type=None, choices=None, help='old foo help', metavar=None)
5
6
In [9]: parser.add_argument('--foo',help='new foo help')
7 ---------------------------------------------------------------------------
8 ArgumentError Traceback (most recent call last)
可以使用选项 conflict_handler='resolve'
1
In [10]: parser = argparse.ArgumentParser(prog='PROG',conflict_handler='resolve'
2 ...: )
3
4
In [11]: parser.add_argument('-f','--foo',help='old foo help')
5
Out[11]: _StoreAction(option_strings=['-f', '--foo'], dest='foo', nargs=None,
const=None,
default=None,
type=None, choices=None, help='old foo help', metavar=None)
6
7
In [12]: parser.add_argument('--foo',help='new foo help')
8
Out[12]: _StoreAction(option_strings=['--foo'], dest='foo', nargs=None,
const=None,
default=None,
type=None, choices=None, help='new foo help', metavar=None)
9
10
In [13]: parser.print_help()
11 usage: PROG [-h] [-f FOO] [--foo FOO]
12
13 optional arguments:
14 -h, --help show this help
message
and
exit
15 -f FOO old foo help16 --foo FOO new foo help
ArgumentParser
仅移除这个动作，假如所有的选项字符串都被覆盖了
add_help
默认情况下，ArgumentParser
对象在创建选项会带着
parser
的帮助信息
下一篇介绍ArgumentParser
The add_argument()
方法
来源：
博客园