版本 3.2中的新功能。
源代码： Lib / argparse .py
教程
此页面包含API参考信息。有关Python命令行解析的更温和介绍，请查看 argparse教程。
该模块可以轻松编写用户友好的命令行界面。该程序定义了它需要的参数， 并将弄清楚如何解析它们。 当用户给程序提供无效参数时，该模块还会自动生成帮助和使用消息并发出错误。
示例
以下代码是一个Python程序，它获取整数列表并生成总和或最大值：
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，它可以在命令行运行并提供有用的帮助消息：
usage: prog.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)
使用适当的参数运行时，它会输出命令行整数的总和或最大值：
4
$ python prog.py 1 2 3 4 --sum
10
如果传入无效参数，则会发出错误：
usage: prog.py [-h] [--sum] N [N ...]
prog.py: error: argument N: invalid int value: 'a'
以下部分将引导您完成此示例。
创建解析器
使用它的第一步是创建一个对象：argparseArgumentParser
>>> parser = argparse.ArgumentParser(description='Process some integers.')
该ArgumentParser对象将包含将命令行解析为Python数据类型所需的所有信息。
添加参数
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()函数（如果不是）。
解析参数
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。
ArgumentParser对象
class （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 ）argparse.ArgumentParser
- 创建一个新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参数。
以下部分描述了如何使用这些方法。
编程
默认情况下，ArgumentParser对象用于sys.argv[0]确定如何在帮助消息中显示程序的名称。这个默认值几乎总是可取的，因为它会使帮助消息与命令行上调用程序的方式相匹配。例如，考虑myprogram.py使用以下代码命名的文件 ：
parser = argparse.ArgumentParser()
parser.add_argument('--foo', help='foo help')
args = parser.parse_args()
该程序的帮助将显示myprogram.py为程序名称（无论程序从何处调用）：
usage: myprogram.py [-h] [--foo FOO]
optional arguments:
-h, --help show this help message and exit
--foo FOO foo help
$ cd ..
$ python subdir/myprogram.py --help
usage: myprogram.py [-h] [--foo FOO]
optional arguments:
-h, --help show this help message and exit
--foo FOO foo help
要更改此默认行为，可以使用以下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
用法
默认情况下，ArgumentParser根据其包含的参数计算用法消息：
>>> 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
该%(prog)s格式说明可填写程序名称您的使用情况的信息。
说明
大多数对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= 参数指定此类文本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 参数调整此行为ArgumentParser。
parents
有时，几个解析器共享一组共同的参数。 可以使用具有所有共享参数并传递给parents=参数的单个解析器，而不是重复这些参数的定义ArgumentParser。该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对象允许通过指定备用格式化类来自定义帮助格式。目前，有四个这样的类：
- 类argparse.RawDescriptionHelpFormatter
- 类argparse.RawTextHelpFormatter
- 类argparse.ArgumentDefaultsHelpFormatter
- 类argparse.MetavarTypeHelpFormatter
RawDescriptionHelpFormatter并RawTextHelpFormatter更好地控制文本描述的显示方式。默认情况下，ArgumentParser对象在命令行帮助消息中换行描述和 结尾文本：
>>> 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
传递RawDescriptionHelpFormatteras formatter_class= 表示描述和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
RawTextHelpFormatter为各种帮助文本维护空格，包括参数描述。但是，多个新行被替换为一行。如果要保留多个空行，请在换行符之间添加空格。
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)
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=ArgumentParser构造函数的参数指定它们：
>>> 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=参数默认为’-’。提供一组不包含的字符-将导致-f/–foo不允许选项。
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=关键字参数来完成ArgumentParser。例如，要全局禁止在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
通常，当您将参数列表传递给a的 parse_args()方法时ArgumentParser，它会识别长选项的缩写。
可以通过设置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对象不允许两个具有相同选项字符串的操作。默认情况下，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
有时（例如，当使用父项时），使用相同的选项字符串简单地覆盖任何旧参数可能是有用的。要获得此行为，'resolve’可以将值 提供给以下conflict_handler=参数 ArgumentParser：
>>> 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包含以下代码的文件 ：
parser = argparse.ArgumentParser()
parser.add_argument('--foo', help='foo help')
args = parser.parse_args()
如果-h或–help在命令行提供，将打印ArgumentParser帮助：
usage: myprogram.py [-h] [--foo FOO]
optional arguments:
-h, --help show this help message and exit
--foo FOO foo help
有时，禁用添加此帮助选项可能很有用。这可以通过传递来实现False的add_help=参数 ArgumentParser：
>>> 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
add_argument（）方法
ArgumentParser.add_argument（名称或标志… [，行动] [，nargs ] [，const ] [，默认] [，类型] [，选项][，必需] [，帮助] [，metavar ] [，dest ] ）
定义应如何解析单个命令行参数。每个参数在下面都有自己更详细的描述，但简而言之，它们是：
名称或标志 - 选项字符串的名称或列表，例如foo 或。-f, --foo
action - 在命令行遇到此参数时要采取的基本操作类型。
nargs - 应该使用的命令行参数的数量。
const - 某些操作和nargs选择所需的常量值。
default - 如果命令行中不存在参数，则生成的值。
type - 应转换命令行参数的类型。
choices - 参数允许值的容器。
required - 是否可以省略命令行选项（仅限选项）。
help - 对参数的作用的简要说明。
metavar - 用法消息中参数的名称。
dest - 要添加到返回的对象的属性的名称 parse_args()。
以下部分描述了如何使用这些方法。
名称或标志
该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
动作
ArgumentParser对象将命令行参数与操作相关联。这些操作可以使用与它们关联的命令行参数执行任何操作，但大多数操作只是向返回的对象添加属性 parse_args()。该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 分别。此外，他们创造的默认值False，并 True分别。例如：
>>> 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。）'append_const’当多个参数需要将常量存储到同一列表时，该操作通常很有用。例如：
>>> 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=关键字参数 add_argument()，并打印版本信息并在调用时退出：
>>> 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__方法。
自定义操作的示例：
>>> 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对象通常将单个命令行参数与要采取的单个操作相关联。的nargs关键字参数与单个动作不同数量的命令行参数。支持的值是：
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=’’，但可以使用多个可选参数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未提供关键字参数，则消耗的参数数由操作确定。通常，这意味着将使用单个命令行参数，并且将生成单个项（不是列表）。
常量
该const的参数add_argument()是用来装未在命令行中读取，但所需要的各种常数值ArgumentParser的动作。它最常见的两个用途是：
当add_argument()被调用 action=‘store_const’或action=‘append_const’。这些操作将const值添加 到返回的对象的某个属性中 parse_args()。有关示例，请参阅操作说明。
何时add_argument()使用选项字符串（如-f或–foo）和nargs=’?’。这将创建一个可选参数，后跟零个或一个命令行参数。解析命令行时，如果遇到选项字符串，后面没有命令行参数，const则将改为使用值。有关示例，请参阅nargs说明。
使用’store_const’和’append_const’actions，const 必须给出关键字参数。对于其他操作，默认为None。
默认
可以在命令行中省略所有可选参数和一些位置参数。值默认为的default关键字参数 指定在命令行参数不存在时应使用的值。对于可选参数，在命令行中不存在选项字符串时使用该值：add_argument()Nonedefault
>>> 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等于?或的位置参数，当没有命令行参数时使用*该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')
类型
默认情况下，ArgumentParser对象以简单的字符串形式读取命令行参数。但是，通常命令行字符串应该被解释为另一种类型，如float或int。所述 type的关键字参数add_argument()允许执行任何必要的类型检查和类型转换。常见的内置类型和函数可以直接用作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)
有关何时将参数应用于默认参数的信息，请参阅default关键字参数 部分type。
为了方便使用多种类型的文件时，argparse模块提供工厂FILETYPE这需要的mode=，bufsize=，encoding=和errors=对的参数open()功能。例如， 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= 可以采用任何带有单个字符串参数的callable并返回转换后的值：
>>> 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
该选择关键字参数可以是用于类型检查，简单地核对值的范围更方便：
>>> 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)
有关详细信息，请参阅选项部分。
