python内置库--argparse

Posted MyRecords

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python内置库--argparse相关的知识，希望对你有一定的参考价值。

1 关于argparse

从命令行工具运行python时，argparse 可以解析命令行工具输入的各种数据，通过argparse提供的函数或者属性，我们可以获得它解析到的数据

通过argparse，我们也可以自定义命令行选项，比如pytest -s -v ,-s -v就是pytest定义的命令行选项，通过argparse，我们也可以定义自己的命令行选项

下面是一个例子

命令行执行 python argparse_a.py a b

可以看到在命令行执行python文件时输入的参数 a b,通过argparse，我们得到了这2个参数

现在执行 python argparse_a.py -o ad a b

然后再，在我们执行命令的目录下面，多了一个ad文件
这些都是argparse解析命令行数据的功劳

2 argparse的使用

argparse的核心功能就3步
第一步 生成一个ArgumentParser这个类的实例对象parser

上面使用了prog等参数字段，具体意思后面会说到，这里也可以像之前的例子不加任何参数

第二步 在parser对象上添加参数名，这些参数就是我们命令行执行时要用到的

总的来说，添加参数名时，有3种类型的参数，positional arguments, options that accept values, and on/off flags

第三步 从parser对象上提取具体的参数数据，这些参数数据大部分是我们在命令行输入的数据

如上，通过parse_args()方法返回的对象加上参数名，我们就可以得到具体的参数数据

class argparse.ArgumentParser（）

执行ArgumentParser（）时，括号里接受下面这些参数来创建一个对象

  • prog - The name of the program (default: os.path.basename(sys.argv[0]))

  • usage - The string describing the program usage (default: generated from arguments added to parser)

  • description - Text to display before the argument help (by default, no text)

  • epilog - Text to display after the argument help (by default, no text)

  • parents - A list of ArgumentParser objects whose arguments should also be included

  • formatter_class - A class for customizing the help output

  • prefix_chars - The set of characters that prefix optional arguments (default: ‘-‘)

  • fromfile_prefix_chars - The set of characters that prefix files from which additional arguments should be read (default: None)

  • argument_default - The global default value for arguments (default: None)

  • conflict_handler - The strategy for resolving conflicting optionals (usually unnecessary)

  • add_help - Add a -h/--help option to the parser (default: True)

  • allow_abbrev - Allows long options to be abbreviated if the abbreviation is unambiguous. (default: True)

  • exit_on_error - Determines whether or not ArgumentParser exits with error info when an error occurs. (default: True)

prog

这个字段会影响到program name的值，默认情况下，它是通过sys.argv[0]来取值的，即在命令行python后面紧邻的那一段文本中最后一部分，比如py文件的文件名
默认情况下是像这样

现在加上pro参数

usage

默认情况下 显示自定义的参数字段

加上usage后

description

添加该参数


如上，可看出默认情况下并没有相关数据的显示

还有很多其他参数，可具体查看官网

add_argument()

该方法也可以在括号中添加多个参数，如下

  • name or flags - Either a name or a list of option strings, e.g. foo or -f, --foo.

  • action - The basic type of action to be taken when this argument is encountered at the command line.

  • nargs - The number of command-line arguments that should be consumed.

  • const - A constant value required by some action and nargs selections.

  • default - The value produced if the argument is absent from the command line and if it is absent from the namespace object.

  • type - The type to which the command-line argument should be converted.

  • choices - A sequence of the allowable values for the argument.

  • required - Whether or not the command-line option may be omitted (optionals only).

  • help - A brief description of what the argument does.

  • metavar - A name for the argument in usage messages.

  • dest - The name of the attribute to be added to the object returned by parse_args()

action

action参数值表示，我们在命令行中的参数数据应该被怎样处理，该参数默认值是store
action=\'store. 这是默认的处理方式，可以不用故意写出来，默认就是这样

action=\'store_const\'


如上，未输入p2参数，p2的值被设为const的值，sore_const就是该参数的值为const的值
注意，这种情况下我们不能在命令行指定p2的值

\'store_true\' and \'store_false\'
和action=\'store_const\'类似

append

\'count\'

没有看懂到底有啥作用，好像就是统计参数字段出现的次数

未完待续

Python命令行解析库argparse（转）

原文：http://www.cnblogs.com/linxiyue/p/3908623.html

2.7之后python不再对optparse模块进行扩展，python标准库推荐使用argparse模块对命令行进行解析。

1.example

有一道面试题：编写一个脚本main.py，使用方式如下：

main.py -u http://www.sohu.com -d ‘a=1,b=2,c=3‘ -o /tmp/index.html

功能要求：打开-u指定的页面，将页面中所有的链接后面增加参数a=1&b=2&c=3(需要考虑链接中已经存在指定的参数的问题), 然后保存到-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
25
26
27
28
29
30
31
import argparse
import urllib
from pyquery import PyQuery as pq
def getArgs():
    parse=argparse.ArgumentParser()
    parse.add_argument(‘-u‘,type=str)
    parse.add_argument(‘-d‘,type=str)
    parse.add_argument(‘-o‘,type=str)
    args=parse.parse_args()
    return vars(args)
def urlAddQuery(url,query):
    query=query.replace(‘,‘,‘&‘) 
    if ‘?‘ in url:
        return url.replace(‘?‘,‘?‘+query+‘&‘)
    else:
        return url+‘?‘+query
def getHref():
    args=getArgs()
    url=args[‘u‘]
    query=args[‘d‘].strip("\‘")
    fileName=args[‘o‘]
    doc=pq(url=url)
    with open(fileName,‘w‘) as f:
        for a in doc(‘a‘):
            a=pq(a)
            href=a.attr(‘href‘)
            if href:
                newurl=urlAddQuery(href,query)
                f.write(newurl+‘\n‘)
if __name__==‘__main__‘:
    getHref()

2.创建解析器

1
2
import argparse
parser = argparse.ArgumentParser()

class 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)

创建一个ArgumentParser实例对象，ArgumentParser对象的参数都为关键字参数。

  prog：程序的名字，默认为sys.argv[0]，用来在help信息中描述程序的名称。

1
2
3
4
5
6
>>> parser = argparse.ArgumentParser(prog=‘myprogram‘)
>>> parser.print_help()
usage: myprogram [-h]
 
optional arguments:
 -h, --help  show this help message and exit

  usage：描述程序用途的字符串

1
2
3
4
5
6
7
8
9
10
11
12
>>> parser = argparse.ArgumentParser(prog=‘PROG‘, usage=‘%(prog)s [options]‘)
>>> parser.add_argument(‘--foo‘, nargs=‘?‘, help=‘foo help‘)
>>> parser.add_argument(‘bar‘, nargs=‘+‘, help=‘bar help‘)
>>> 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：help信息前的文字。

  epilog：help信息之后的信息

1
2
3
4
5
6
7
8
9
10
11
12
>>> parser = argparse.ArgumentParser(
...     description=‘A foo that bars‘,
...     epilog="And that‘s how you‘d foo a bar")
>>> parser.print_help()
usage: argparse.py [-h]
 
A foo that bars
 
optional arguments:
 -h, --help  show this help message and exit
 
And that‘s how you‘d foo a bar

parents：由ArgumentParser对象组成的列表，它们的arguments选项会被包含到新ArgumentParser对象中。

1
2
3
4
5
6
7
>>> parent_parser = argparse.ArgumentParser(add_help=False)
>>> parent_parser.add_argument(‘--parent‘, type=int)
 
>>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])
>>> foo_parser.add_argument(‘foo‘)
>>> foo_parser.parse_args([‘--parent‘, ‘2‘, ‘XXX‘])
Namespace(foo=‘XXX‘, parent=2)

formatter_class：help信息输出的格式,

prefix_chars：参数前缀，默认为‘-‘

1
2
3
4
5
>>> parser = argparse.ArgumentParser(prog=‘PROG‘, prefix_chars=‘-+‘)
>>> parser.add_argument(‘+f‘)
>>> parser.add_argument(‘++bar‘)
>>> parser.parse_args(‘+f X ++bar Y‘.split())
Namespace(bar=‘Y‘, f=‘X‘)

fromfile_prefix_chars：前缀字符，放在文件名之前

1
2
3
4
5
6
>>> with open(‘args.txt‘, ‘w‘) as fp:
...    fp.write(‘-f\nbar‘)
>>> parser = argparse.ArgumentParser(fromfile_prefix_chars=‘@‘)
>>> parser.add_argument(‘-f‘)
>>> parser.parse_args([‘-f‘, ‘foo‘, ‘@args.txt‘])
Namespace(f=‘bar‘)

当参数过多时，可以将参数放到文件中读取，例子中parser.parse_args([‘-f‘, ‘foo‘, ‘@args.txt‘])解析时会从文件args.txt读取，相当于[‘-f‘, ‘foo‘, ‘-f‘, ‘bar‘]。

argument_default：参数的全局默认值。例如，要禁止parse_args时的参数默认添加，我们可以：

1
2
3
4
5
6
7
>>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)
>>> parser.add_argument(‘--foo‘)
>>> parser.add_argument(‘bar‘, nargs=‘?‘)
>>> parser.parse_args([‘--foo‘, ‘1‘, ‘BAR‘])
Namespace(bar=‘BAR‘, foo=‘1‘)
>>> parser.parse_args()
Namespace()

当parser.parse_args()时不会自动解析foo和bar了。

conflict_handler：解决冲突的策略，默认情况下冲突会发生错误：

1
2
3
4
5
6
>>> parser = argparse.ArgumentParser(prog=‘PROG‘)
>>> parser.add_argument(‘-f‘, ‘--foo‘, help=‘old foo help‘)
>>> parser.add_argument(‘--foo‘, help=‘new foo help‘)
Traceback (most recent call last):
 ..
ArgumentError: argument --foo: conflicting option string(s): --foo

我们可以设定冲突解决策略：

1
2
3
4
5
6
7
8
9
10
>>> parser = argparse.ArgumentParser(prog=‘PROG‘, conflict_handler=‘resolve‘)
>>> parser.add_argument(‘-f‘, ‘--foo‘, help=‘old foo help‘)
>>> parser.add_argument(‘--foo‘, help=‘new foo help‘)
>>> parser.print_help()
usage: PROG [-h] [-f FOO] [--foo FOO]
 
optional arguments:
 -h, --help  show this help message and exit
 -f FOO      old foo help
 --foo FOO   new foo help

　add_help：设为False时，help信息里面不再显示-h --help信息。

3.添加参数选项

1
2
3
4
5
>>> 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)‘)

add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])

  name or flags：参数有两种，可选参数和位置参数。

添加可选参数：

1
>>> parser.add_argument(‘-f‘, ‘--foo‘)

添加位置参数：

1
>>> parser.add_argument(‘bar‘)

parse_args()运行时，会用‘-‘来认证可选参数，剩下的即为位置参数。

1
2
3
4
5
6
7
8
9
10
>>> parser = argparse.ArgumentParser(prog=‘PROG‘)
>>> parser.add_argument(‘-f‘, ‘--foo‘)
>>> parser.add_argument(‘bar‘)
>>> parser.parse_args([‘BAR‘])
Namespace(bar=‘BAR‘, foo=None)
>>> parser.parse_args([‘BAR‘, ‘--foo‘, ‘FOO‘])
Namespace(bar=‘BAR‘, foo=‘FOO‘)
>>> parser.parse_args([‘--foo‘, ‘FOO‘])
usage: PROG [-h] [-f FOO] bar
PROG: error: too few arguments

解析时没有位置参数就会报错了。

action:默认为store

  store_const，值存放在const中：

1
2
3
4
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument(‘--foo‘, action=‘store_const‘, const=42)
>>> parser.parse_args(‘--foo‘.split())
Namespace(foo=42)

  store_true和store_false，值存为True或False

1
2
3
4
5
6
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument(‘--foo‘, action=‘store_true‘)
>>> parser.add_argument(‘--bar‘, action=‘store_false‘)
>>> parser.add_argument(‘--baz‘, action=‘store_false‘)
>>> parser.parse_args(‘--foo --bar‘.split())
Namespace(bar=False, baz=True, foo=True)

  append：存为列表

1
2
3
4
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument(‘--foo‘, action=‘append‘)
>>> parser.parse_args(‘--foo 1 --foo 2‘.split())
Namespace(foo=[‘1‘, ‘2‘])

  append_const：存为列表，会根据const关键参数进行添加：

1
2
3
4
5
>>> 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)
>>> parser.parse_args(‘--str --int‘.split())
Namespace(types=[<type ‘str‘>, <type ‘int‘>])

  count：统计参数出现的次数

1
2
3
4
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument(‘--verbose‘, ‘-v‘, action=‘count‘)
>>> parser.parse_args(‘-vvv‘.split())
Namespace(verbose=3)

  help：help信息

  version：版本

1
2
3
4
5
>>> 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

nargs：参数的数量

值可以为整数N(N个)，*(任意多个)，+(一个或更多)

1
2
3
4
5
6
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument(‘--foo‘, nargs=‘*‘)
>>> parser.add_argument(‘--bar‘, nargs=‘*‘)
>>> parser.add_argument(‘baz‘, nargs=‘*‘)
>>> parser.parse_args(‘a b --foo x y --bar 1 2‘.split())
Namespace(bar=[‘1‘, ‘2‘], baz=[‘a‘, ‘b‘], foo=[‘x‘, ‘y‘])

值为？时，首先从命令行获得参数，若没有则从const获得，然后从default获得：

1
2
3
4
5
6
7
8
9
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument(‘--foo‘, nargs=‘?‘, const=‘c‘, default=‘d‘)
>>> parser.add_argument(‘bar‘, nargs=‘?‘, default=‘d‘)
>>> parser.parse_args(‘XX --foo YY‘.split())
Namespace(bar=‘XX‘, foo=‘YY‘)
>>> parser.parse_args(‘XX --foo‘.split())
Namespace(bar=‘XX‘, foo=‘c‘)
>>> parser.parse_args(‘‘.split())
Namespace(bar=‘d‘, foo=‘d‘)

更常用的情况是允许参数为文件

1
2
3
4
5
6
7
8
9
10
11
>>> 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)
>>> parser.parse_args([‘input.txt‘, ‘output.txt‘])
Namespace(infile=<open file ‘input.txt‘, mode ‘r‘ at 0x...>,
          outfile=<open file ‘output.txt‘, mode ‘w‘ at 0x...>)
>>> parser.parse_args([])
Namespace(infile=<open file ‘<stdin>‘, mode ‘r‘ at 0x...>,
          outfile=<open file ‘<stdout>‘, mode ‘w‘ at 0x...>)

const：保存一个常量

default：默认值

type：参数类型

choices：可供选择的值

1
2
3
4
5
6
7
>>> parser = argparse.ArgumentParser(prog=‘doors.py‘)
>>> parser.add_argument(‘door‘, type=int, choices=range(1, 4))
>>> print(parser.parse_args([‘3‘]))
Namespace(door=3)
>>> parser.parse_args([‘4‘])
usage: doors.py [-h] {1,2,3}
doors.py: error: argument door: invalid choice: 4 (choose from 1, 2, 3)

required：是否必选

desk：可作为参数名

1
2
3
4
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument(‘--foo‘, dest=‘bar‘)
>>> parser.parse_args(‘--foo XXX‘.split())
Namespace(bar=‘XXX‘)

4.解析参数

参数有几种写法：

最常见的空格分开：

1
2
3
4
5
6
7
>>> parser = argparse.ArgumentParser(prog=‘PROG‘)
>>> parser.add_argument(‘-x‘)
>>> parser.add_argument(‘--foo‘)
>>> parser.parse_args(‘-x X‘.split())
Namespace(foo=None, x=‘X‘)
>>> parser.parse_args(‘--foo FOO‘.split())
Namespace(foo=‘FOO‘, x=None)

长选项用=分开

1
2
>>> parser.parse_args(‘--foo=FOO‘.split())
Namespace(foo=‘FOO‘, x=None)

短选项可以写在一起：

1
2
>>> parser.parse_args(‘-xX‘.split())
Namespace(foo=None, x=‘X‘)

parse_args()方法的返回值为namespace，可以用vars()内建函数化为字典：

1
2
3
4
5
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument(‘--foo‘)
>>> args = parser.parse_args([‘--foo‘, ‘BAR‘])
>>> vars(args)
{‘foo‘: ‘BAR‘}

以上是关于python内置库--argparse的主要内容，如果未能解决你的问题，请参考以下文章

分享几个好用到爆的 Python 内置模块

Python argparse库简单入门

关于 argparse 库 [python] [重复]

Python命令行解析库argparse（转）

如何使用 Python 中的 argparse 和 csv 库编写文件？

python 模块argparse用法实例详解