argparse  是一个用于解析 命令行选项，参数以及 子命令的库
源码来自  lib/argparse.py 
主要功能：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 5 5 $ python prog.py --sum 1 5 67 73
$ 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=<built-in function sum>, 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 => sys.argv[0] 这个脚本(程序）自身
usage => 来描述脚本(程序)的详细信息(默认会从创建argumentparser的usage读取)
description => 参数前显示的帮助信息(默认为none)
epilog => 参数后显示的帮助信息(默认为none)
parents => argumentparser方法包含的参数列表
formatter_class => 可定制的类来帮助输出信息
prefix_chars => 可选参数的前缀(默认是'-')
fromfile_prefix_chars => 前缀文件的字符(默认是none）
argument_default => 全局缺省的值(默认是none)
conflict_handler => 解决有冲突的选项(通常不需要)
add_help => 默认解析器会添加 -h 或者 --help选项(默认就含有)
allow_abbrev => 允许长选项使用缩写
下面是示例:
　prog:默认情况下,argumentparser这个对象使用sys.argv[0]决定展示帮助页面,当你在命令行 调用这个程序自身，它会显示帮助信息
例如，假如一个叫myprog.py的脚本
$ vim myprog.py#!/usr/local/cellar/pyenv/versions/3.6.1/bin/python3#coding:utf-8import 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 argparsein [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 exit19 +f f20 ++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 exit15 -f foo old foo help16 --foo foo new foo help
argumentparser 仅移除这个动作，假如所有的选项字符串都被覆盖了
add_help
默认情况下，argumentparser对象在创建选项会带着parser的帮助信息
下一篇介绍argumentparser
the add_argument() 方法

以上就是对python argparse库的用法讲解的详细内容。