举例

代码存放与test.py文件中

import argparse
#第一步:创建一个ArgumentParser对象;ArgumentParser 对象包含将命令行解析成 Python 数据类型所需的全部信息。
parser = argparse.ArgumentParser(description='Process some integers.')

#第二步:添加参数;通过调用 add_argument() 方法完成的。这些信息在 parse_args() 调用时被存储和使用。
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)')
                    
#第三步:解析参数;parse_args()方法解析参数。在脚本中,通常parse_args()会被不带参数调用,而ArgumentParser将自动从sys.argv中确定命令行参数。
args = parser.parse_args()

print(args.accumulate(args.integers))

测试:

$python test.py -h

usage: test.py [-h] [--sum] N [N ...]

Process some integers.

positional arguments:
  N           an integer for the accumulator

optional arguments:
  -h, --help  show this help message and exit
  --sum       sum the integers (default: find the max)
$python test.py 4 8 9 6 7

9
$python test.py 4 a d

usage: test.py [-h] [--sum] N [N ...]
test.py: error: argument N: invalid int value: 'a'
$python test.py 4 3 5 --sum

12

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, exit_on_error=True)

创建新对象时,所有参数都会作为关键字被传入(sys.argv:传递给Python脚本的命令行参数列表):

prog - 程序的名称(默认:sys.argv[0])
usage - 描述程序用途的字符串(默认值:从添加到解析器的参数生成,在用法消息中可以使用 %(prog)s 格式说明符来填入程序名称。)
description - 在参数帮助文档之前显示的文本(默认值:无)
epilog - 在参数帮助文档之后显示的文本(默认值:无)
parents - 一个 ArgumentParser 对象的列表,它们的参数也应包含在内
formatter_class - 用于自定义帮助文档输出格式的类
prefix_chars - 可选参数的前缀字符集合(默认值:’-’)
fromfile_prefix_chars - 当需要从文件中读取其他参数时,用于标识文件名的前缀字符集合(默认值:None)
argument_default - 参数的全局默认值(默认值: None)
conflict_handler - 解决冲突选项的策略(通常是不必要的)
add_help - 为解析器添加一个 -h/–help 选项(默认值: True)
allow_abbrev - 如果缩写是无歧义的,则允许缩写长选项 (默认值:True)
exit_on_error - 决定当错误发生时是否让 ArgumentParser 附带错误信息退出。 (默认值: True)

源码:

import argparse

parser = argparse.ArgumentParser()  

args = parser.parse_args()
print(args.accumulate(args.integers))

测试:

python test.py -h

输出:

usage: test.py [-h]

optional arguments:
  -h, --help  show this help message and exit

修改源码中parser = argparse.ArgumentParser()
改为parser = argparse.ArgumentParser(prog='PROG',usage='%(prog)s [options]',description='A foo that bars',epilog="And that's how you'd foo a bar")
输出:

usage: PROG [options]

A foo that bars

optional arguments:
  -h, --help  show this help message and exit

And that's how you'd foo a bar

详细参数示例请参考.

add_argument() 方法

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 - 此命令行选项是否可省略 (仅选项可用)。
help - 一个此选项作用的简单描述。
metavar - 在使用方法消息中使用的参数值示例。
dest - 被添加到 parse_args() 所返回对象上的属性名。

name or flags

add_argument() 方法必须知道它是否是一个选项,例如 -f 或 --foo,或是一个位置参数,例如一组文件名。第一个传递给 add_argument() 的参数必须是一系列 flags 或者是一个简单的参数名。

创建选项:

parser.add_argument('-f', '--foo')

创建位置参数:

parser.add_argument('bar')

parse_args() 被调用,选项会以 - 前缀识别,剩下的参数则会被假定为位置参数:

import argparse

parser = argparse.ArgumentParser(prog='PROG')

parser.add_argument('-f', '--foo')
parser.add_argument('bar')
parser.add_argument('car')
args = parser.parse_args(['BAR','CAR'])
print(args)
args = parser.parse_args(['BAR','CAR','-f','FOO'])
print(args)

测试输出:
Namespace(bar='BAR', car='CAR', foo=None)
Namespace(bar='BAR', car='CAR', foo='FOO')
这里位置参数必须一一对应,不可以多也不可以少。

action

ArgumentParser 对象将命令行参数与动作相关联。大多数动作只是简单的向 parse_args() 返回的对象上添加属性。action 命名参数指定了这个命令行参数应当如何处理,动作有:

1.‘store’- 存储参数的值。这是默认的动作。

import argparse
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('-f', '--foo',action='store')
args = parser.parse_args(['-f','1'])
print(args)

>>>Namespace(foo='1')

2.‘store_const’-存储被 const 命名参数指定的值,作通常用在选项中来指定一些标志。

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-f', '--foo',action='store_const',const=32)
args = parser.parse_args(['-f'])
print(args)

>>>Namespace(foo=32)

3.‘store_true’ and ‘store_false’ - 这些是 ‘store_const’ 分别用作存储 True 和 False 值的特殊用例。另外,它们的默认值分别为 False 和 True,这种情况下无法使用const。

import argparse
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 32 --bar --baz'.split())
print(args)

>>>Namespace(bar=False, baz=False, foo=True)

4.‘append’ - 存储一个列表,并且将每个参数值追加到列表中。在允许多次使用选项时很有用。

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='append')
args = parser.parse_args('--foo 1 --foo 2'.split())
print(args)

>>>Namespace(foo=['1', '2'])

5.‘append_const’ - 这存储一个列表,并将 const 命名参数指定的值追加到列表中。'append_const' 动作一般在多个参数需要在同一列表中存储常数时会有用。

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--str',dest='types',  action='append_const', const=12)
parser.add_argument('--int', dest='types', action='append_const', const=int)
parser.add_argument('--float', dest='types', action='append_const', const=float)
args = parser.parse_args('--str --int --float'.split())
print(args)

>>>Namespace(types=[12, <class 'int'>, <class 'float'>])

6.‘count’ - 计算一个关键字参数出现的数目或次数。例如,对于一个增长的详情等级来说有用:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--verbose', '-t', action='count')
parser.add_argument('-f')
args = parser.parse_args(['--verbose','-t'])
print(args)

>>>Namespace(f=None, verbose=2)

7.‘help’ - 打印所有当前解析器中的选项和参数的完整帮助信息,然后退出。默认情况下,一个 help 动作会被自动加入解析器。

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--verbose',help = 'help me count numbers')
parser.add_argument('-f')
args = parser.parse_args()

>>>python test.py -h
usage: test.py [-h] [--verbose VERBOSE] [-f F]

optional arguments:
  -h, --help         show this help message and exit
  --verbose VERBOSE  help me count numbers
  -f F

8.‘version’ - 期望有一个 version= 命名参数在 add_argument() 调用中,并打印版本信息并在调用后退出:

import argparse
parser = argparse.ArgumentParser(prog='Test')
parser.add_argument('--version', action='version', version='%(prog)s 2.0')
args = parser.parse_args(['--version'])
print(args)

>>>Test 2.0

9.‘extend’ - 这会存储一个列表,并将每个参数值加入到列表中,不过当前版本好像被删了

nargs

ArgumentParser 对象通常关联一个单独的命令行参数到一个单独的被执行的动作。 nargs 命名参数关联不同数目的命令行参数到单一动作。支持的值有:

1.N (一个整数):命令行中的 N 个参数会被聚集到一个列表中。

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs=2)
parser.add_argument('bar', nargs=1)
args = parser.parse_args('--foo c a b'.split())
print(args)

>>>Namespace(bar=['b'], foo=['c', 'a'])

2.’?’:会从命令行中消耗一个参数,并产生一个单一项,若无参数,则会产生一个default值。对于选项,则会返回const值。

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs='?', const='c', default='d')
parser.add_argument('bar', nargs='?', default='d')
parser.add_argument('car', nargs='?', default='c')
args = parser.parse_args(['2','--foo'])
print(args)

>>>Namespace(bar='2', car='c', foo='c')

nargs=’?’ 的一个更普遍用法是允许可选的输入或输出文件:

import argparse
import sys
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)
args = parser.parse_args(['input.txt', 'output.txt'])
# args = parser.parse_args([])
print(args)

>>>Namespace(infile=<_io.TextIOWrapper name='input.txt' mode='r' encoding='cp936'>, outfile=<_io.TextIOWrapper name='output.txt' mode='w' encoding='cp936'>)

3.’*’:所有当前命令行参数被聚集到一个列表中,不过这个才做通常没有意义:

import argparse
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)

>>>Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])

4.’+’:和’*'类似,但是必须要有一个命令行参数,否则报错。

import argparse
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'.split())
print(args)

>>>Namespace(bar=None, baz=['a', 'b'], foo=['x', 'y'])

如果不适用nargs,则消耗的命令行参数一般由action决定,即一般只消耗一个参数。

const

add_argument() 的const 参数用于保存不从命令行中读取但被各种 ArgumentParser 动作需求的常数值。

default

默认值为 None,指定了在命令行参数未出现时应当使用的值。对于选项, default 值在选项未在命令行中出现时使用。

type

默认情况下,解析器会将命令行参数当作简单字符串读入。可以配合choice使用,则只能选择choice中指定的目标。

choices

某些命令行参数应当从一组受限值中选择,可以搭配type使用。

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('num', type = int ,choices=range(0,4))
print(parser.parse_args(['2']))

>>>Namespace(num=2)

required

通常,argparse 模块会认为 -f 和 --bar 等旗标是指明 可选的 参数。可以使用required=True某个成为必须的。

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo','-f', required=True)
print(parser.parse_args([]))

>>>
usage: test.py [-h] --foo FOO
test.py: error: the following arguments are required: --foo/-f

help

help 值是一个包含参数简短描述的字符串,当用户请求帮助时(一般是通过在命令行中使用 -h 或 --help 的方式),这些 help 描述将随每个参数一同显示:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo','-f',help='you want to check me?')
print(parser.parse_args(['-h']))

>>>
usage: test.py [-h] [--foo FOO]

optional arguments:
  -h, --help         show this help message and exit
  --foo FOO, -f FOO  you want to check me?

dest

dest关键字用于确定 ArgumentParser动作会添加一些值作为 parse_args() 所返回对象的一个属性

对于位置参数动作,dest 通常会作为 add_argument() 的第一个参数提供;对于可选参数动作,dest 的值通常取自选项字符串。 ArgumentParser 会通过接受第一个长选项字符串并去掉开头的 – 字符串来生成 dest 的值。 如果没有提供长选项字符串,则 dest 将通过接受第一个短选项字符串并去掉开头的 - 字符来获得。 任何内部的 - 字符都将被转换为 _ 字符以确保字符串是有效的属性名称。

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-f', '--foo-bar', '--foo')
parser.add_argument('bar')
print(parser.parse_args(['none','-f','big']))

>>>Namespace(bar='none', foo_bar='big')

也可以使用dest给属性命名:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-f', '--foo-bar', '--foo', dest='BIG')
parser.add_argument('bar')
print(parser.parse_args(['none','-f','big']))

>>>Namespace(BIG='big', bar='none')

Action 类

Action 类实现了 Action API,它是一个返回可调用对象的可调用对象,返回的可调用对象可处理来自命令行的参数。

class argparse.Action(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)

Action 的实例应当为可调用对象,因此所有子类都必须重载 __call__ 方法,该方法应当接受四个形参:

1.parser - 包含此动作的 ArgumentParser 对象。
2.namespace - 将由 parse_args() 返回的 Namespace 对象。 大多数动作会使用 setattr() 为此对象添加属性。
3.values - 已关联的命令行参数,并提供相应的类型转换。 类型转换由 add_argument() 的 type 关键字参数来指定。
4.option_string - 被用来发起调用此动作的选项字符串。 option_string 参数是可选的,且此参数在动作关联到位置参数时将被略去。

__call__ 方法可以执行任意动作,但通常将基于 dest 和 values 来设置 namespace 的属性。

parse_args() 方法

将参数字符串转换为对象并将其设为命名空间的属性。 返回带有成员的命名空间。

ArgumentParser.parse_args(args=None, namespace=None)

选项值语法

parse_args() 方法支持多种指定选项值的方式:

  1. 选项和它的值是作为两个单独参数传入的
  2. 对于长选项(名称长度超过一个字符的选项),选项和值也可以作为单个命令行参数传入,使用 = 分隔它们即可
  3. 对于短选项(长度只有一个字符的选项),选项和它的值可以拼接在一起
  4. 有些短选项可以使用单个 - 前缀来进行合并
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-x')
parser.add_argument('--foo')
args1 = parser.parse_args(['--foo', 'FOO'])
args2 = parser.parse_args(['--foo=FOO'])
args3 = parser.parse_args(['-xX'])
print(args1,args2,args3)

>>>Namespace(foo='FOO', x=None) Namespace(foo='FOO', x=None) Namespace(foo=None, x='X')

无效的参数

在解析命令行时,parse_args() 会检测多种错误,包括有歧义的选项、无效的类型、无效的选项、错误的位置参数个数等等。

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-x',type = int)
args = parser.parse_args(['-x', 'train'])
print(args)

>>>
usage: test.py [-h] [-x X]
test.py: error: argument -x: invalid int value: 'train'

包含 - 的参数

parse_args() 方***在用户明显出错时尝试给出错误信息,但某些情况本身就存在歧义。例如,命令行参数 -1 可能是尝试指定一个选项也可能是尝试提供一个位置参数。

参数缩写(前缀匹配)

parse_args() 方法 在默认情况下 允许将长选项缩写为前缀,如果缩写无歧义(即前缀与一个特定选项相匹配)的话:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-barcar',type = int)
args = parser.parse_args(['-bar', '-1'])
print(args)

>>>Namespace(barcar=-1)

命名空间对象

class argparse.Namespace

可以实现让 ArgumentParser 为一个已存在对象而不是为一个新的 Namespace 对象的属性赋值。 这可以通过指定 namespace= 关键字参数来实现:

import argparse
class c():
    pass
c = c()
parser = argparse.ArgumentParser()
parser.add_argument('-barcar',type = int)
args = parser.parse_args(['-bar', '-1'],namespace=c)
print(c.barcar)

>>>-1

其它实用工具

子命令

许多程序都会将其功能拆分为一系列子命令,例如,svn 程序包含的子命令有 svn checkout, svn update 和 svn commit。

ArgumentParser.add_subparsers([title][, description][, prog][, parser_class][, action][, option_string][, dest][, required][, help][, metavar])

形参的描述:

1.title - 输出帮助的子解析器分组的标题;如果提供了描述则默认为 “subcommands”,否则使用位置参数的标题

2.description - 输出帮助中对子解析器的描述,默认为 None

3.prog - 将与子命令帮助一同显示的用法信息,默认为程序名称和子解析器参数之前的任何位置参数。

4.parser_class - 将被用于创建子解析器实例的类,默认为当前解析器类(例如 ArgumentParser)

5.action - 当此参数在命令行中出现时要执行动作的基本类型

6.dest - 将被用于保存子命令名称的属性名;默认为 None 即不保存任何值

7.required - 是否必须要提供子命令,默认为 False (在 3.7 中新增)

8.help - 在输出帮助中的子解析器分组帮助信息,默认为 None

9.metavar - 帮助信息中表示可用子命令的字符串;默认为 None 并以 {cmd1, cmd2, …} 的形式表示子命令

FileType 对象

class argparse.FileType(mode='r', bufsize=-1, encoding=None, errors=None)

参数组

ArgumentParser.add_argument_group(title=None, description=None)

互斥

创建一个互斥组。 argparse 将会确保互斥组中只有一个参数在命令行中可用:

ArgumentParser.add_mutually_exclusive_group(required=False)

add_mutually_exclusive_group() 方法也接受一个 required 参数,表示在互斥组中至少有一个参数是需要的,若不设置required,则表示互斥,且不用至少存在一个参数。

import argparse
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group(required = True)
group.add_argument('--bar',type = int)
group.add_argument('--car',type = int)
args = parser.parse_args([])
print(args)

>>>
usage: test.py [-h] (--bar BAR | --car CAR)
test.py: error: one of the arguments --bar --car is required

解析器默认值

ArgumentParser.set_defaults(**kwargs)
ArgumentParser.get_default(dest)
import argparse
parser = argparse.ArgumentParser()
parser.set_defaults(bar=42, baz='badger')
parser.add_argument('--car',type = int)
parser.add_argument('--foo', default='badger')
args = parser.parse_args([])
print(args,parser.get_default('foo'))

>>>Namespace(bar=42, baz='badger', car=None, foo='badger') badger

部分解析

有时一个脚本可能只解析部分命令行参数,而将其余的参数继续传递给另一个脚本或程序。

ArgumentParser.parse_known_args(args=None, namespace=None)
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('bar',type = str)
parser.add_argument('--foo', action='store_true')
args = parser.parse_known_args(['--foo', '--badger', '-BAR', 'spam'])
print(args)

>>>(Namespace(bar='spam', foo=True), ['--badger', '-BAR'])

自定义文件解析

从文件读取的参数将是一行读取一个参数,以空格分开。

ArgumentParser.convert_arg_line_to_args(arg_line)

退出方法

此方法将终结程序,退出时附带指定的 status,并且如果给出了 message 则会在退出前将其打印输出。

ArgumentParser.exit(status=0, message=None)
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('bar',type = str)
parser.add_argument('--foo', action='store_true')
args = parser.parse_known_args(['--foo', '--badger', '-BAR', 'spam'])
parser.error(message='error')
print(args)

>>>
usage: test.py [-h] [--foo] bar
test.py: error: error

ps:本博客参考网站进行学习。