python 标准库 argparse 续

继续学习 argparse模块

add_arguments 方法

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 frobbled

optional arguments:
 -h, --help  show this help message and exit
 --foo   foo the bars before frobbling

帮助信息字符串可以包含多种类型格式化声明,避免和默认参数相混淆。这里包括 %(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

help 字符串支持 %格式化方式,如果你不希望在帮助字符串附近出现%,最好避免使用%%逃逸字符。

argparse 支持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

metavar

当 ArgumentParser 生成帮助消息时，它需要一些方法来引用每个预期的参数。默认情况下，参数分析器对象使用dest 值作为每个对象的”名称”值。默认情况下，对于位置参数操作，直接使用dest 值，对于可选参数操作，dest 值是大写字母。因此，带有dest_bar'bar的单一位置参数将称为”bar”。单个可选参数”-foo”，后面应跟一个命令行参数，将称为”FOO”。例如：

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> parser.add_argument('bar')
>>> parser.parse_args('X --foo Y'.split())
Namespace(bar='X', foo='Y')
>>> parser.print_help()
usage:  [-h] [--foo FOO] bar

positional arguments:
 bar

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

可以使用元变量指定替代名称：

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', metavar='YYY')
>>> parser.add_argument('bar', metavar='XXX')
>>> parser.parse_args('X --foo Y'.split())
Namespace(bar='X', foo='Y')
>>> parser.print_help()
usage:  [-h] [--foo YYY] XXX

positional arguments:
 XXX

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

metavar 仅更改显示的名称 - parse_args() 对象上属性的名称仍由 dest 确定

nargs 的不同值可能会导致多次使用 dest 。提供 dest 的元组为每个参数指定不同的显示：

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

dest

大多数 ArgumentParser 操作添加一些值作为由 parse_args() 返回的对象的属性。此属性的名称由 add_argument() 的add_argument()关键字参数确定。对于位置参数操作，dest通常作为第一个参数提供给 add_argument():

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('bar')
>>> parser.parse_args(['XXX'])
Namespace(bar='XXX')

对于可选的参数操作，通常从选项字符串中推断出dest的值。 ArgumentParser生成dest的值，方法是提取第一个长选项字符串并去除初始--字符串。如果没有提供长选项字符串，则通过剥离开头的“-”字符，从第一个短选项字符串派生“ dest”。任何内部的-字符都将转换为_字符，以确保该字符串是有效的属性名称。下面的示例说明了此行为：

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('-f', '--foo-bar', '--foo')
>>> parser.add_argument('-x', '-y')
>>> parser.parse_args('-f 1 -x 2'.split())
Namespace(foo_bar='1', x='2')
>>> parser.parse_args('--foo 1 -y 2'.split())
Namespace(foo_bar='1', x='2')

dest 允许自定义可选属性的名字

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', dest='bar')
>>> parser.parse_args('--foo XXX'.split())
Namespace(bar='XXX')

Action classes

这是一个实现了可调用API的函数，该函数返回一个可调用的函数，该可处理函数从命令行处理参数。遵循此API的任何对象都可以作为操作参数传递给add_argument（）。

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

ArgumentParser对象使用动作对象表示从命令行的一个或多个字符串解析单个参数所需的信息。 Action类必须接受两个位置参数以及传递给ArgumentParser和argument().add_argument()，但action本身除外。

Action实例（或可调用action参数的任何返回值）应具有定义的属性dest，option_strings，default，type”，“ required，help等。确保定义这些属性的最简单方法是调用Action .__ init__。

Action 实例是可调用的，因此子类必须重写call方法，该方法应接受四个参数：

parser - ArgumentParser对象包含的动作
namespace - Namespace 对象通过 parse_args()方法返回. 大部分actions 通过 setattr()方法添加属性
values - 关联命令行参数,已应用任何类型转换，通过 add_argument()中的 type 关键字参数声明类型转换
option_string - 用于调用此操作的选项字符串。 option_string参数是可选的，如果该动作与位置参数相关联，则将不起作用。

parse_args() 方法

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

将参数字符串转换为对象，并将其分配为名称空间的属性。返回填充的名称空间。先前对add_argument（）的调用确定创建了哪些对象以及它们的分配方式。有关详细信息，请参见 add_argument() 。
- 要解析的字符串列表。默认值来自sys.argv。
- namespace）-带有属性的对象。默认为一个新的空的 Namespace 对象。

Option value syntax

parse_args()方法支持多种方法来指定选项的值（如果需要一个）。在最简单的情况下，选项及其值作为两个单独的参数传递：

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x')
>>> parser.add_argument('--foo')
>>> parser.parse_args(['-x', 'X'])
Namespace(foo=None, x='X')
>>> parser.parse_args(['--foo', 'FOO'])
Namespace(foo='FOO', x=None)

对于长选项（名称长于单个字符的选项），选项和值也可以作为单个命令行参数传递，使用=分隔它们：

1 2	>>> parser.parse_args(['--foo=FOO']) Namespace(foo='FOO', x=None)

对于短选项（选项仅一个字符长），可以将选项及其值连接在一起：

1 2	>>> parser.parse_args(['-xX']) Namespace(foo=None, x='X')

只要仅最后一个选项（或其中一个都不要求）需要一个值，几个短选项可以仅使用一个前缀-组合在一起。

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x', action='store_true')
>>> parser.add_argument('-y', action='store_true')
>>> parser.add_argument('-z')
>>> parser.parse_args(['-xyzZ'])
Namespace(x=True, y=True, z='Z')

无效的参数

parse_args() 检查各种错误，包括模棱两可的选项，无效的类型，无效的选项，错误的位置参数数量等。遇到此类错误时，它将退出并打印错误以及用法消息：

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--foo', type=int)
>>> parser.add_argument('bar', nargs='?')

>>> # invalid type
>>> parser.parse_args(['--foo', 'spam'])
usage: PROG [-h] [--foo FOO] [bar]
PROG: error: argument --foo: invalid int value: 'spam'

>>> # invalid option
>>> parser.parse_args(['--bar'])
usage: PROG [-h] [--foo FOO] [bar]
PROG: error: no such option: --bar

>>> # wrong number of arguments
>>> parser.parse_args(['spam', 'badger'])
usage: PROG [-h] [--foo FOO] [bar]
PROG: error: extra arguments found: badger

包含 `-` 的参数

parse_args()方法尝试在用户明显犯错时给出错误，但某些情况本质上是模棱两可的。例如，命令行参数-1可以是尝试指定选项，也可以是提供位置参数。 parse_args() 方法在这里非常谨慎：位置参数只能以-如果它们看起来像负数，并且解析器中没有选项看起来像负数：

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x')
>>> parser.add_argument('foo', nargs='?')

>>> # no negative number options, so -1 is a positional argument
>>> parser.parse_args(['-x', '-1'])
Namespace(foo=None, x='-1')

>>> # no negative number options, so -1 and -5 are positional arguments
>>> parser.parse_args(['-x', '-1', '-5'])
Namespace(foo='-5', x='-1')

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-1', dest='one')
>>> parser.add_argument('foo', nargs='?')

>>> # negative number options present, so -1 is an option
>>> parser.parse_args(['-1', 'X'])
Namespace(foo=None, one='X')

>>> # negative number options present, so -2 is an option
>>> parser.parse_args(['-2'])
usage: PROG [-h] [-1 ONE] [foo]
PROG: error: no such option: -2

>>> # negative number options present, so both -1s are options
>>> parser.parse_args(['-1', '-1'])
usage: PROG [-h] [-1 ONE] [foo]
PROG: error: argument -1: expected one argument

如果您的位置参数必须以-开头并且看起来不像负数，则可以插入伪参数'-'来告诉parse_args() 之后的所有内容都是位置参数：

1 2	>>> parser.parse_args(['--', '-f']) Namespace(foo='-f', one=None)

参数缩写（前缀匹配）

The parse_args() method by default allows long options to be abbreviated to a prefix, if the abbreviation is unambiguous (the prefix matches a unique option):

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-bacon')
>>> parser.add_argument('-badger')
>>> parser.parse_args('-bac MMM'.split())
Namespace(bacon='MMM', badger=None)
>>> parser.parse_args('-bad WOOD'.split())
Namespace(bacon=None, badger='WOOD')
>>> parser.parse_args('-ba BA'.split())
usage: PROG [-h] [-bacon BACON] [-badger BADGER]
PROG: error: ambiguous option: -ba could match -badger, -bacon

对于可能产生多个选项的参数会产生错误。可以通过将 allow_abbrev设置为False来禁用此功能。

Beyond `sys.argv`¶

有时让ArgumentParser解析除之外的参数可能会很有用。这可以通过将字符串列表传递给parse_args()来完成。这对于在交互式提示符下进行测试很有用：

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument(
...     'integers', metavar='int', type=int, choices=range(10),
...     nargs='+', help='an integer in the range 0..9')
>>> parser.add_argument(
...     '--sum', dest='accumulate', action='store_const', const=sum,
...     default=max, help='sum the integers (default: find the max)')
>>> parser.parse_args(['1', '2', '3', '4'])
Namespace(accumulate=<built-in function max>, integers=[1, 2, 3, 4])
>>> parser.parse_args(['1', '2', '3', '4', '--sum'])
Namespace(accumulate=<built-in function sum>, integers=[1, 2, 3, 4])

命名空间对象

class argparse.`Namespace`

默认情况下由parse_args() 使用的简单类来创建保存属性并返回的对象它。

此类是故意简化的，只是一个具有可读字符串表示形式的object子类。如果您希望对属性有类似dict的视图，可以使用标准的Python习惯用法vars()#vars）：

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> args = parser.parse_args(['--foo', 'BAR'])
>>> vars(args)
{'foo': 'BAR'}

让 ArgumentParser 将属性分配给已经存在的对象，而不是一个新的[ Namespace 对象。这可以通过指定namespace =关键字参数来实现：

>>> class C:
...     pass
...
>>> c = C()
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> parser.parse_args(args=['--foo', 'BAR'], namespace=c)
>>> c.foo
'BAR'