python argparser 学习随笔

python argparser 学习随笔

ArgParser学习随笔
阅读时，打开两个标签页同时学习，一个关于ArgumentParser，另一个关于add_argument。

一些规范：

1 命令行参数（又称为选项），三类：必选参数（位置参数）、可选参数又叫选项字符串（短选项字符串（特征是以单杠开头）、长选项字符串（特征是以双杠开头））
2 ArgumentParser中定义参数，定义参数的方法比如add_argument，其中该方法中在定义命令行参数时，也包含方法本身的一些参数比如dest、const等，因此要区别哪些时命令行中的参数，哪些时方法中的参数。
3 命令行中的参数相对来说并不统一，因为含有-这种特殊字符，因此当解析之后，就会将其中的特殊字符去除，严谨的说是，开头的单或双杠去除，而字符串内部的单杠会被下划线代替。（这其实是在讲方法add_argument中的dest参数。）
4 有的时候定义命令行参数时，会罗列出很多的字符串，比如单杠或双杠都可能在定义同一个参数时出现，因此这时解析后的Namespace中该命令行参数对应的名称则以第一个出现的字符串为基准。除此之外，我们还可以通过dest参数进行自定义。见下例：

大多数 ArgumentParser 动作会添加一些值作为 parse_args() 所返回对象的一个属性。 该属性的名称由 add_argument() 的 dest 关键字参数确定。 对于位置参数动作，dest 通常会作为 add_argument() 的第一个参数提供:>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('bar')
>>> parser.parse_args(['XXX'])
Namespace(bar='XXX')
""""
""">>>
>>> 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')

1 add_argument

1. add_argument在介绍nargs参数 在取值为 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 会产生一个单元素列表。这和默认的元素本身是不同的。

这里说的注意是指 指定nargs=1时得到的时单元素列表，而不指定nargs时，某个参数读取到的虽然也是一个元素但是并不是列表的格式。

2. name or flags参数介绍时，提及：

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

这里的两个参数分别两类：必选参数和可选参数（特点是首个参数带有一个或两个-）。

第一步，不论两类参数谁先被定义，在解析式，都是必选类参数先进行参数值的赋值，其次才是可选类参数。
第二步，在每个类别中按照程序中参数定义的先后顺序，为对应参数赋值。默认情况下（不指定nargs参数时）每个参数读取一个值。而当指定nargs参数时，会视nargs的取值读取相应数目的元素。其中可选参数的参数值的读取，需要把可选参数的名字写出然后读取紧随其后的值。

3. dest参数

>>> 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'>])## -===================== 对应下面命令行 ====================## 
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action='store_const', const=42)
>>> parser.parse_args(['--foo'])
Namespace(foo=42)

dest的作用，替代name or flags参数对应的名称，作为解析后的parser.parse_args对应的NameSpace中正式的变量名称。

4. const参数

# 其实就是一个常数，对应的参数没有从命令行中取到值时，使用该值；但当遇到default时，以default的值优先。
>>> 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'>])

5. default
   特殊的一种使用。

# 提供 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')

6. type

"""
默认情况下，解析器会将命令行参数当作简单字符串读入。 然而，命令行字符串经常应当被解读为其他类型，例如 float 或 int。 add_argument() 的 type 关键字允许执行``任何必要的类型检查和类型转换。如果 type 关键字使用了 default 关键字，则类型转换器仅会在默认值为字符串时被应用。
"""

7. required
   该参数面向被指明是可选的参数，比如-f 和 --bar，但是既然是可选，又要强迫其变为不可选，其实并不是很合适。因此不建议用。

8. help
   help有三个点：
   1 help在调用时，不需要使用add_argument方法定义，因为它是内置的，聂可以通过在命令行中指定-h 或 -help以打印该解析器的描述内容。

2 与python中的格式化输出print一致，你可以选择类似的表达方式。

"""
help 字符串可包括各种格式描述符以避免重复使用程序名称或参数 default 等文本。 有效的描述符包括程序名称 %(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

3 由于帮助字符串支持 %-formatting，如果你希望在帮助字符串中显示 % 字面值，你必须将其转义为 %%。

9. dest 见本文最上部分。

10. metavar

"""
当 ArgumentParser 生成帮助消息时，它需要用某种方式来引用每个预期的参数。 默认情况下，ArgumentParser 对象使用 dest 值作为每个对象的 "name"。 默认情况下，对于位置参数动作，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] barpositional arguments:baroptional 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] XXXpositional arguments:XXXoptional arguments:-h, --help  show this help message and exit--foo YYY

重要的是：请注意 metavar 仅改变 显示的 名称 - parse_args() 对象的属性名称仍然会由 dest 值确定。
另外，这一点也仅仅在print_help方法中得到显示，而通过-h的方法似乎无法显示。

3 parse_args

1. 基本的情况
   ArgumentParser.parse_args(args=None, namespace=None)
   将参数字符串转换为对象并将其设为命名空间的属性。 返回带有成员的命名空间。

之前对 add_argument() 的调用决定了哪些对象（参数）被创建以及它们如何被赋值。

• args - 要解析的字符串列表。 默认值是从 sys.argv 获取。

• namespace - 用于获取属性的对象。 默认值是一个新的空 Namespace 对象，如果指定，会与当前定义的命名空间中的属性进行融合。

2. 包含 - 的参数
   包含 - 的参数 不是可选参数的特权，位置参数也可以使用，但是位置参数在如此格式命名时有及其严格的条件：位置参数只有在它们看起来像负数并且解析器中没有任何选项看起来像负数时才能以 - 打头。:。因此谨慎。

3. (很重要的一点：)parse_args方法中获取到的字符串列表默认来自sys.argv，但是除此之外，可以通过将一个字符串列表直接传给该方法。就像上面已经多次出现的例子。

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

4. Namespace类比较简单，是一个存放属性的对象，它可以通过vars方法实现对属性的展示，形式类似python中的字典形式。

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

5. Namespace类另一个用处是让 ArgumentParser 为一个已存在对象而不是为一个新的 Namespace 对象的属性赋值。 这可以通过指定 namespace= 关键字参数来实现。
   该函数中的取值的必选参数时列表，特殊的情况下可以作两个parser的命名空间的融合，比如：

# 如果目标命名空间已经有一个属性集，则 default 动作不会覆盖它:
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', default=42)
>>> parser.parse_args([], namespace=argparse.Namespace(foo=101))
Namespace(foo=101)

6. 如果想要调用某个参数的取值，可以直接通过namespace.参数的dest值的方式得到。

4 add_subparsers

1. 这一块主要看官网add_subparsers
2. 如果添加了该方法add_subparsers，则要选中是哪个子解析器，则需要在命令行中明确指定，在这种情况下，命令行中的参数就会分有以下策略：首先 子解析器的dest名称和自解析器平级的必选参数和可选参数（平级的状态下，又细分，首先必选参数 其次子解析器名称 最后 可选参数名称），第二 子解析器下的可选参数和必选参数（该级情况下，又细分为 首先考虑必选参数其次可选参数）！下例非常好：

>>> # create the top-level parser
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--foo', action='store_true', help='foo help')
>>> subparsers = parser.add_subparsers(help='sub-command help')
>>>
>>> # create the parser for the "a" command
>>> parser_a = subparsers.add_parser('a', help='a help')
>>> parser_a.add_argument('bar', type=int, help='bar help')
>>>
>>> # create the parser for the "b" command
>>> parser_b = subparsers.add_parser('b', help='b help')
>>> parser_b.add_argument('--baz', choices='XYZ', help='baz help')
>>>
>>> # parse some argument lists
>>> parser.parse_args(['a', '12'])
Namespace(bar=12, foo=False)
>>> parser.parse_args(['--foo', 'b', '--baz', 'Z'])
Namespace(baz='Z', foo=True)