Python 3.7.1 模块 argparse 命令行解析

最新推荐文章于 2022-03-01 16:38:40 发布

百年da孤独

最新推荐文章于 2022-03-01 16:38:40 发布

阅读量1.7k

点赞数 3

分类专栏： Python 3.7 模块翻译文章标签： argparse 命令行解析

翻译同时被 3 个专栏收录

54 篇文章 0 订阅

订阅专栏

Python 3.7

19 篇文章 1 订阅

订阅专栏

模块

11 篇文章 0 订阅

订阅专栏

python 3.2 新模块
源码：Lib/argparse.py

未完待续…

该模块可以轻松编写用户友好的命令行界面。该程序定义了它需要的参数，argparse 将弄清楚如何解析sys.argv。当用户给程序提供无效参数时，该模块还会自动生成帮助和使用消息并发出错误。

简单教程
此页面包含API参考信息。有关Python命令行解析的更简单的介绍，请查看 argparse教程。

1. 例子

以下代码是一个Python程序，它获取一个整数列表并生成总和或其中的最大值：

import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
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)')

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

假设上面的Python代码保存到一个名为 prog.py 的文件中，它可以在命令行运行并提供有用的帮助消息：

在这里插入图片描述
使用适当的参数运行时，它会输出命令行整数的总和或最大值：

如果传入无效参数，则会发出错误：

以下部分将引导您完成此示例。

1.1 创建解析器

使用argparse的第一步是创建一个 ArgumentParser对象：

>>>
>>> parser = argparse.ArgumentParser(description='Process some integers.')

ArgumentParser对象将包含将命令行解析为Python数据类型所需的所有信息。

1.2 添加参数

ArgumentParser通过调用add_argument()方法来填充有关程序参数的信息。通常，这些调用告诉 ArgumentParser 如何在命令行上获取字符串并将它们转换为对象。这些信息会存储，以便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()将返回具有两个属性的对象，integers和accumulate。integers属性将是一个或多个整数的列表，accumulate属性将是sum()函数（如果在命令行中指定--sum），或者max()函数（如果不指定--sum）。

1.3 解析参数

ArgumentParser通过 parse_args() 方法解析参数。这将检查命令行，将每个参数转换为适当的类型，然后调用相应的操作。在大多数情况下，这意味着将从命令行解析的属性构建一个简单Namespace的对象：

>>>
>>> parser.parse_args(['--sum', '7', '-1', '42'])
Namespace(accumulate=<built-in function sum>, integers=[7, -1, 42])

在脚本中，parse_args()通常会在没有参数的情况下调用，并且ArgumentParser会自动从sys.argv中确定命令行参数。

2. 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)

创建一个新ArgumentParser对象。所有参数都应作为关键字参数传递。每个参数下面都有自己更详细的描述，但简而言之，它们是：

prog - 程序的名称（默认：sys.argv[0]）
usage - 描述程序用法的字符串（默认值：从添加到解析器的参数生成）
description - 参数help之前显示的文本（默认值：none）
epilog - 参数help后显示的文本（默认值：none）
parents - 一个ArgumentParser对象列表，这里面的内有也加进来
formatter_class - 用于自定义帮助输出的类
prefix_chars - 可选前缀参数的字符集（默认值：'-'）
fromfile_prefix_chars -额外的前缀字符参数从文件中读出来（默认值：None）
argument_default -为参数的全局默认值（默认值：None）
conflict_handler - 解决冲突选项的策略（通常是不需要的）
add_help -添加-h/--help选项解析器（默认值：True）
allow_abbrev - 如果缩写是明确的，则允许缩写长选项。（默认值：True）

版本3.5中已更改：添加了allow_abbrev参数。

以下部分描述了如何使用这些方法。

prog

默认情况下，ArgumentParser对象用sys.argv[0]确定如何在帮助消息中显示程序的名称。此默认值几乎总是可取的，因为它将使帮助消息与命令行上调用程序的方式相匹配。例如，考虑使用以下代码名为myprogram.py的文件：

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo', help='foo help')
args = parser.parse_args()

该程序的帮助将显示myprogram.py为程序名称（无论程序从何处调用）：
在这里插入图片描述

要更改此默认行为，可以为ArgumentParser使用prog=参数提供另一个值：

>>>
>>> parser = argparse.ArgumentParser(prog='myprogram')
>>> parser.print_help()
usage: myprogram [-h]

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

请注意，程序名称（无论是从参数sys.argv[0]确定还是从 prog=参数确定）可用于使用%(prog)s格式说明符来帮助消息显示。

>>>
>>> parser = argparse.ArgumentParser(prog='myprogram')
>>> parser.add_argument('--foo', help='foo of the %(prog)s program')
>>> parser.print_help()
usage: myprogram [-h] [--foo FOO]

optional arguments:
 -h, --help  show this help message and exit
 --foo FOO   foo of the myprogram program

usage

默认情况下，ArgumentParser根据其包含的参数给出usage信息：

>>>
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--foo', nargs='?', help='foo help')
>>> parser.add_argument('bar', nargs='+', help='bar help')
>>> parser.print_help()
usage: PROG [-h] [--foo [FOO]] bar [bar ...]

positional arguments:
 bar          bar help

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

可以使用usage=keyword参数覆盖默认消息：

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

大多数对ArgumentParser构造函数的调用都将使用 description=关键字参数。该参数简要描述了程序的功能和工作原理。在帮助消息中，描述显示在命令行用法字符串和各种参数的帮助消息之间：

>>>
>>> parser = argparse.ArgumentParser(description='A foo that bars')
>>> parser.print_help()
usage: argparse.py [-h]

A foo that bars

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

默认情况下，描述将是换行的，以便它适合给定的空间。要更改此行为，请参阅 formatter_class 参数。

epilog

有些程序喜欢在参数描述后显示程序的其他描述。可以使用以下epilog=参数为ArgumentParser指定此类文本：

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

与description参数一样，epilog=默认情况下文本是换行的，但可以使用 formatter_class 参数调整此行为。

parents

有时，几个解析器共享一组共同的参数。可以使用具有所有共享参数并传递给parents=参数的单个解析器，而不是重复这些参数。parents=参数获取ArgumentParser 对象列表，从中收集所有位置和可选操作，并将这些操作添加到ArgumentParser正在构造的对象中：

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

>>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])
>>> bar_parser.add_argument('--bar')
>>> bar_parser.parse_args(['--bar', 'YYY'])
Namespace(bar='YYY', parent=None)

请注意，大多数父解析器都会指定add_help=False。否则， ArgumentParser将看到两个-h/--help选项（一个在父项中，一个在子项中）并引发错误。

注意
您必须在通过parents=传递解析器之前完全初始化解析器。如果在子解析器之后更改父解析器，则这些更改将不会反映在子解析器中。↑

formatter_class

ArgumentParser对象允许通过指定备用格式化类来自定义帮助格式。目前，有四个这样的类：

.1 class argparse.RawDescriptionHelpFormatter

RawDescriptionHelpFormatter和RawTextHelpFormatter更好地控制文本描述的显示方式。默认情况下，ArgumentParser对象在命令行帮助消息中对 description 和 epilog文本进行换行：

>>> parser = argparse.ArgumentParser(
...     prog='PROG',
...     description='''this description
...         was indented weird
...             but that is okay''',
...     epilog='''
...             likewise for this epilog whose whitespace will
...         be cleaned up and whose words will be wrapped
...         across a couple lines''')
>>> parser.print_help()
usage: PROG [-h]

this description was indented weird but that is okay

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

likewise for this epilog whose whitespace will be cleaned up and whose words
will be wrapped across a couple lines

通过RawDescriptionHelpFormatter作为formatter_class=参数中的参数表示description 和 epilog已经正确格式化且不应该用一行输出：

>>> parser = argparse.ArgumentParser(
...     prog='PROG',
...     formatter_class=argparse.RawDescriptionHelpFormatter,
...     description=textwrap.dedent('''\
...         Please do not mess up this text!
...         --------------------------------
...             I have indented it
...             exactly the way
...             I want it
...         '''))
>>> parser.print_help()
usage: PROG [-h]

Please do not mess up this text!
--------------------------------
   I have indented it
   exactly the way
   I want it

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

.2 class argparse.RawTextHelpFormatter

RawTextHelpFormatter为各种帮助文本维护空格，包括参数描述。但是，多个新行被替换为一行。如果要保留多个空行，请在换行符之间添加空格。

译者注：
在这里插入图片描述

.3 class argparse.ArgumentDefaultsHelpFormatter

ArgumentDefaultsHelpFormatter 自动将有关默认值的信息添加到每个参数帮助消息中：

>>>
>>> parser = argparse.ArgumentParser(
...     prog='PROG',
...     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
>>> parser.add_argument('--foo', type=int, default=42, help='FOO!')
>>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')
>>> parser.print_help()
usage: PROG [-h] [--foo FOO] [bar [bar ...]]

positional arguments:
 bar         BAR! (default: [1, 2, 3])

optional arguments:
 -h, --help  show this help message and exit
 --foo FOO   FOO! (default: 42)

.4 class argparse.MetavarTypeHelpFormatter

MetavarTypeHelpFormatter 使用每个参数的type参数的名称作为其值的显示名称（而不是像常规格式化程序的dest那样使用）：

>>>
>>> parser = argparse.ArgumentParser(
...     prog='PROG',
...     formatter_class=argparse.MetavarTypeHelpFormatter)
>>> parser.add_argument('--foo', type=int)
>>> parser.add_argument('bar', type=float)
>>> parser.print_help()
usage: PROG [-h] [--foo int] float

positional arguments:
  float

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

prefix_chars

大多数命令行选项将-用作前缀，例如-f/--foo。需要支持不同或附加前缀字符的解析器，例如像+f或/foo等选项，可以使用prefix_chars=参数指定它们：

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

prefix_chars=参数默认为'-'。提供一组不包含-的字符将导致不允许选项-h/--help。
在这里插入图片描述

fromfile_prefix_chars

有时，例如在处理特别长的参数列表时，将参数列表保存在文件中而不是在命令行输入它可能是有意义的。如果fromfile_prefix_chars=赋值给 ArgumentParser构造函数，那么以任何指定字符开头的参数将被视为文件，并将被它们包含的参数替换。例如：

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

默认情况下，从文件读取的参数必须是每行一个（但也可以参见 convert_arg_line_to_args()），并且它们被视为与命令行上的原始文件引用参数位于同一位置。因此，在上面的示例中，表达式['-f', 'foo', '@args.txt']被认为等同于表达式['-f', 'foo', '-f', 'bar']。

该fromfile_prefix_chars=参数默认为None，这意味着参数就永远不会从文件引用处理。

argument_default

通常，参数默认值通过**add_argument()传递或通过set_defaults()**使用一组特定的 名称 - 值 对来指定。但是，有时为参数指定单个解析器范围的默认值可能很有用。这可以通过传递 argument_default=关键字参数来完成。例如，要全局禁止在parse_args() 调用上创建属性，我们提供argument_default=SUPPRESS：

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

allow_abbrev

通常，当您将参数列表传递给parse_args()方法时，它会识别长选项的缩写。

可以通过设置allow_abbrev为False：禁用此功能：

>>>
>>> parser = argparse.ArgumentParser(prog='PROG', allow_abbrev=False)
>>> parser.add_argument('--foobar', action='store_true')
>>> parser.add_argument('--foonley', action='store_false')
>>> parser.parse_args(['--foon'])
usage: PROG [-h] [--foobar] [--foonley]
PROG: error: unrecognized arguments: --foon

版本3.5中的新功能。

效果图：
在这里插入图片描述

conflict_handler

ArgumentParser对象不允许两个具有相同选项字符串的操作。默认情况下，如果尝试使用已在使用的选项字符串创建参数，则对象会引发异常：

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

有时（例如，当使用parents参数时），使用相同的选项字符串简单地覆盖任何旧参数可能是有用的。要执行此行为，可以让conflict_handler='resolve'：

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

请注意，ArgumentParser对象仅在覆盖其所有选项字符串时才删除操作。因此，在上面的示例中，旧的-f/--foo 操作将保留为-f，因为只覆盖了--foo选项字符串。

add_help

默认情况下，ArgumentParser对象添加一个选项，只显示解析器的帮助消息。例如，考虑一个名为myprogram.py的文件：

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo', help='foo help')
args = parser.parse_args()

如果在命令行中提供-h或--help，将打印帮助：

$ python myprogram.py --help
usage: myprogram.py [-h] [--foo FOO]

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

有时，禁用添加此帮助选项可能很有用。这可以通过传递来add_help=False来实现：

>>>
>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)
>>> parser.add_argument('--foo', help='foo help')
>>> parser.print_help()
usage: PROG [--foo FOO]

optional arguments:
 --foo FOO  foo help

通常是帮助选项时 -h/--help。例外情况是prefix_chars=的参数不包括-，在这种情况下-h/--help将不是有效的选项。在这种情况下，第一个字符prefix_chars用于为帮助选项添加前缀：

>>>
>>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='+/')
>>> parser.print_help()
usage: PROG [+h]

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

3. 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 - usage 消息中参数的名称。
dest - 要添加到 parse_args() 返回的对象的属性的名称。

以下部分描述了如何使用这些方法。

name or flags

add_argument()方法必须知道是否需要可选参数，如-f或--foo，或位置参数，如文件名列表。因此传递给add_argument()的第一个参数必须是一系列标志或简单的参数名称。例如，可以创建一个可选参数，如：

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

而位置参数可以创建如下：

>>>
>>> parser.add_argument('bar')

当parse_args()被调用时，可选的参数从-前缀被识别，而其余的参数将被认为是位置：

>>>
>>> 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: the following arguments are required: bar

action

ArgumentParser对象将命令行参数与action相关联。这些操作可以使用与它们关联的命令行参数执行任何操作，但大多数操作只是向 parse_args()返回的对象添加属性。action关键字参数指定的命令行参数应该如何处理。提供的action种类是：

'store' - 只是存储参数的值。这是默认操作。例如：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> parser.parse_args('--foo 1'.split())
Namespace(foo='1')

‘store_const’- 它存储const关键字参数指定的值。该’store_const’操作最常用于指定某种标志的可选参数。例如：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action='store_const', const=42)
>>> parser.parse_args(['--foo'])
Namespace(foo=42)

'store_true'和'store_false'-这些是'store_const'的特殊情况下用于存储值True和False 分别。例如：

>>>
>>> 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(foo=True, bar=False, baz=True)

译者注：不提供参数的时候，以相反的值存储
在这里插入图片描述

'append' - 它存储一个列表，并将每个参数值附加到列表中。这对于允许多次指定选项很有用。用法示例：

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

'append_const'- 它存储一个列表，并将const关键字参数指定的值附加到列表中。（请注意，const关键字参数默认为None。）当多个参数需要将常量存储到同一列表时，该操作通常很有用。例如：

>>>
>>> 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=[<class 'str'>, <class 'int'>])

'count' - 计算关键字参数出现的次数。例如，这对于增加详细级别很有用：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--verbose', '-v', action='count')
>>> parser.parse_args(['-vvv'])
Namespace(verbose=3)

'help' - 这将打印当前解析器中所有选项的完整帮助消息，然后退出。默认情况下，帮助操作会自动添加到解析器中。有关如何创建输出的详细信息，请参阅ArgumentParser。
'version'- version=关键字参数 ，打印版本信息并在调用时退出：

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

您还可以通过传递Action子类或实现相同接口的其他对象来指定任意操作。建议的方法是扩展Action，覆盖__call__方法和可选的__init__方法。

自定义Action的示例：

>>>
>>> class FooAction(argparse.Action):
...     def __init__(self, option_strings, dest, nargs=None, **kwargs):
...         if nargs is not None:
...             raise ValueError("nargs not allowed")
...         super(FooAction, self).__init__(option_strings, dest, **kwargs)
...     def __call__(self, parser, namespace, values, option_string=None):
...         print('%r %r %r' % (namespace, values, option_string))
...         setattr(namespace, self.dest, values)
...
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action=FooAction)
>>> parser.add_argument('bar', action=FooAction)
>>> args = parser.parse_args('1 --foo 2'.split())
Namespace(bar=None, foo=None) '1' None
Namespace(bar='1', foo=None) '2' '--foo'
>>> args
Namespace(bar='1', foo='2')

有关详细信息，请参阅Action。

nargs

ArgumentParser对象通常将单个命令行参数与要采取的单个action相关联。nargs关键字参数与单个action不同数量的命令行参数。支持的值是：

N（一个整数）。命令行中的N参数将一起收集到一个列表中。例如：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', nargs=2)
>>> parser.add_argument('bar', nargs=1)
>>> parser.parse_args('c --foo a b'.split())
Namespace(bar=['c'], foo=['a', 'b'])

请注意，nargs=1生成一个项目的一个列表。这与默认情况不同，在默认情况下，项目由其自身生成。

'?'。如果可能，将从命令行使用一个参数，并将其作为单个项生成。如果不存在命令行参数，则将生成默认值。请注意，对于可选参数，还有一种情况 - 选项字符串存在但后面没有命令行参数。在这种情况下，将生成const的值。一些例子来说明这一点：

>>>
>>> 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'])
Namespace(bar='XX', foo='YY')
>>> parser.parse_args(['XX', '--foo'])
Namespace(bar='XX', foo='c')
>>> parser.parse_args([])
Namespace(bar='d', foo='d')

nargs='?'其中一个更常见的用途是允许可选的输入和输出文件：

>>>
>>> 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=<_io.TextIOWrapper name='input.txt' encoding='UTF-8'>,
          outfile=<_io.TextIOWrapper name='output.txt' encoding='UTF-8'>)
>>> parser.parse_args([])
Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>,
          outfile=<_io.TextIOWrapper name='<stdout>' encoding='UTF-8'>)

'*'存在的所有命令行参数都收集到列表中。请注意，nargs='*'的时候使用多个位置参数通常没有多大意义，但可以使用多个可选参数。例如：

>>>
>>> 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'])

'+'。就像'*'，所有存在的命令行参数都被收集到一个列表中。此外，如果不存在至少一个命令行参数，将生成错误消息。例如：

>>>
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('foo', nargs='+')
>>> parser.parse_args(['a', 'b'])
Namespace(foo=['a', 'b'])
>>> parser.parse_args([])
usage: PROG [-h] foo [foo ...]
PROG: error: the following arguments are required: foo

argparse.REMAINDER。所有剩余的命令行参数都收集到一个列表中。这对于调度到其他命令行实用程序的命令行实用程序通常很有用：

>>>
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--foo')
>>> parser.add_argument('command')
>>> parser.add_argument('args', nargs=argparse.REMAINDER)
>>> print(parser.parse_args('--foo B cmd --arg1 XX ZZ'.split()))
Namespace(args=['--arg1', 'XX', 'ZZ'], command='cmd', foo='B')

如果未提供nargs关键字参数，则消耗的参数数由action确定。通常，这意味着将使用单个命令行参数，并且将生成单个项（不是列表）。

const

该const的参数是用来保存不从命令行中读取，但ArgumentParser的action所需要的各种常数值。它最常见的两个用途是：

当add_argument()方法被传递 action='store_const'或action='append_const'。这些操作将const值添加到parse_args() 返回的对象的某个属性中。有关示例，请参阅action说明。
当 add_argument()使用选项字符串（如-f或--foo）和nargs='?'。这将创建一个可选参数，后面可以跟零或一个命令行参数。解析命令行时，如果遇到选项字符串，后面没有命令行参数，c则将改为使用onst值。有关示例，请参阅nargs说明。

使用'store_const'和'append_const' actions，必须给出const 关键字参数。对于其他操作，默认为None。

default

可以在命令行中省略所有可选参数和一些位置参数。default默认为None。对于可选参数，在命令行中不存在选项字符串时使用该值：


>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', default=42)
>>> parser.parse_args(['--foo', '2'])
Namespace(foo='2')
>>> parser.parse_args([])
Namespace(foo=42)

如果default值是字符串，则解析器将解析该值，就好像它是命令行参数一样。特别是，在为Namespace返回值设置属性之前，解析器将执行任何参数类型转换（如果提供）。否则，解析器按原样使用该值：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--length', default='10', type=int)
>>> parser.add_argument('--width', default=10.5, type=int)
>>> parser.parse_args()
Namespace(length=10, width=10.5)

对于位置参数提供nargs='?'或nargs='*'，当没有命令行参数时使用该default值：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('foo', nargs='?', default=42)
>>> parser.parse_args(['a'])
Namespace(foo='a')
>>> parser.parse_args([])
Namespace(foo=42)

如果命令行参数不存在，default=argparse.SUPPRESS用来提供无添加属性的原因：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', default=argparse.SUPPRESS)
>>> parser.parse_args([])
Namespace()
>>> parser.parse_args(['--foo', '1'])
Namespace(foo='1')

type

默认情况下，ArgumentParser对象以简单字符串的形式读取命令行参数。但是，通常命令行字符串应该被解释为另一种类型，如float或int。 type关键字参数允许执行任何必要的类型检查和类型转换。常见的内置类型和函数可以直接用作type参数的值：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('foo', type=int)
>>> parser.add_argument('bar', type=open)
>>> parser.parse_args('2 temp.txt'.split())
Namespace(bar=<_io.TextIOWrapper name='temp.txt' encoding='UTF-8'>, foo=2)

为了方便使用多种类型的文件，argparse模块提供工厂类 FILETYPE，这个类需要提供和open()函数相同的参数，如mode=，bufsize=，encoding=， errors=。例如， FileType('w')可用于创建可写文件：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('bar', type=argparse.FileType('w'))
>>> parser.parse_args(['out.txt'])
Namespace(bar=<_io.TextIOWrapper name='out.txt' encoding='UTF-8'>)

type= 可以接受任何带有单个字符串参数的可调用函数并返回转换后的值：

>>>
>>> def perfect_square(string):
...     value = int(string)
...     sqrt = math.sqrt(value)
...     if sqrt != int(sqrt):
...         msg = "%r is not a perfect square" % string
...         raise argparse.ArgumentTypeError(msg)
...     return value
...
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('foo', type=perfect_square)
>>> parser.parse_args(['9'])
Namespace(foo=9)
>>> parser.parse_args(['7'])
usage: PROG [-h] foo
PROG: error: argument foo: '7' is not a perfect square

choices关键字参数可以更方便地进行类型检查，简单地核对值的范围：

>>>
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('foo', type=int, choices=range(5, 10))
>>> parser.parse_args(['7'])
Namespace(foo=7)
>>> parser.parse_args(['11'])
usage: PROG [-h] {5,6,7,8,9}
PROG: error: argument foo: invalid choice: 11 (choose from 5, 6, 7, 8, 9)

choices

应从一组受限制的值中选择某些命令行参数。这些可以通过将容器对象作为choices关键字参数传递。解析命令行时，将检查参数值，如果参数不是可接受的值之一，则会显示错误消息：

>>>
>>> parser = argparse.ArgumentParser(prog='game.py')
>>> parser.add_argument('move', choices=['rock', 'paper', 'scissors'])
>>> parser.parse_args(['rock'])
Namespace(move='rock')
>>> parser.parse_args(['fire'])
usage: game.py [-h] {rock,paper,scissors}
game.py: error: argument move: invalid choice: 'fire' (choose from 'rock',
'paper', 'scissors')

请注意，检查choices发生在类型转换后，因此choice容器中的对象类型应与指定的类型匹配：
在这里插入图片描述
支持in运算符的任何对象都可以作为 choices 值传递，因此支持dict对象，set对象，自定义容器等。

required

通常，argparse模块假定标志类似-f，--bar 指示可选参数，这些参数总是可以在命令行中省略。要创建必需的选项，可以指定required= True：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', required=True)
>>> parser.parse_args(['--foo', 'BAR'])
Namespace(foo='BAR')
>>> parser.parse_args([])
usage: argparse.py [-h] [--foo FOO]
argparse.py: error: option --foo is required

如示例所示，如果选项标记为required，则在命令行中不存在该选项时将报告错误。

注意 required 选项通常被认为是不良形式，因为用户希望选项是可选的，因此应尽可能避免使用。

help

help值是一个包含参数简要描述的字符串。当用户请求帮助时（通常使用-h/--help），这些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

help字符串可以包括各种格式说明，以避免类似程序名称或参数默认值地重复。可用说明包括program name，%(prog)s和大多数关键字参数，如%(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

由于帮助字符串支持％-formatting，如果要在帮助字符串中显示百分号，则必须将其转义为%%。

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产生帮助信息，它需要一些方法针对指定的参数。默认情况下，ArgumentParser对象使用dest 值作为每个对象的“名称”。默认情况下，对于位置参数操作，直接使用dest值，对于可选参数操作，dest值是大写的。因此，单个位置参数 dest='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

可以使用以下metavar指定备用名称：

>>>
>>> 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可能导致metavar被多次使用。提供metavar一个元组来为每个参数指定不同的显示：

>>>
>>> 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()返回的对象的属性。该属性的名称由dest确定。对于位置参数， dest通常作为第一个参数提供给 add_argument()：

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

对于可选参数操作，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')

4. parse_args()方法

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

将参数字符串转换为对象并将其指定为命名空间的属性。返回填充的命名空间。

args - 要解析的字符串列表。默认值取自 sys.argv。
namespace - 获取属性的对象。默认值是一个新的空 Namespace对象。

选项和赋值

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)

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

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

对于短选项（选项只有一个字符长），可以连接选项及其值：

>>>
>>> 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()检查各种错误，包括不明确的选项，无效的类型，无效的选项，错误的位置参数数等。当遇到这样的错误时，它会退出并打印错误以及usage消息：

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

包含-字符的参数

命令行参数-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()那之后的所有内容都是位置参数：

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

参数缩写（前缀匹配）

parse_args()方法在默认情况下允许长选项被缩写为前缀，如果缩写是明确的（前缀匹配的唯一选项）：

>>>
>>> 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禁用。

不使用sys.argv

有时，使用其他方式（除sys.argv）提供参数可能非常有用。这可以通过为 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])

5. 其他方法

部分解析

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

有时，脚本只能解析一些命令行参数，将剩余的参数传递给另一个脚本或程序。在这些情况下，parse_known_args()方法可能是有用的。它和 parse_args() 的工作方式非常类似，只是在存在额外参数时不会产生错误。相反，它返回一个包含填充命名空间和剩余参数字符串列表的两项元组。

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action='store_true')
>>> parser.add_argument('bar')
>>> parser.parse_known_args(['--foo', '--badger', 'BAR', 'spam'])
(Namespace(bar='BAR', foo=True), ['--badger', 'spam'])

警告前缀匹配规则适用于 parse_known_args()。解析器可能会使用一个选项，即使它只是其已知选项之一的前缀，而不是将其留在剩余的参数列表中。

百年da孤独

关注

3
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
Python 3.7.1 模块 argparse 命令行解析

列表1. 例子1.1 创建解析器1.2 添加参数1.3 解析参数2. ArgumentParser 对象progusagedescriptionepilogparentsformatter_class.1 class argparse.RawDescriptionHelpFormatter.2 class argparse.RawTextHelpFormatter.3 class argparse...
复制链接

扫一扫

专栏目录