【Python】Python脚本命令行解析

Python脚本命令行解析

argparse 模块
使用 argparse 模块可以方便的编写出友好的命令行接口。程序定义需要的参数，然后 argparse 将从sys.argv解析出那些参数。argparse 模块还可以自动生成帮助手册和使用手册。并在用户给程序传入无效参数时报出错误信息。

1. 一个简单的示例

prog.py 文件：

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))
1
2
3
4
5
6
7
8
9
10
11

脚本执行：

• 在命令行中执行该文件，返回帮助信息：

zzz@ubuntu:~/my_learning$ python3 prog.py -h
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)
zzz@ubuntu:~/my_learning$
1
2
3
4
5
6
7
8
9
10
11
12

• 使用适当参数运行，脚本会返回输入命令行传入整数的总和或最大值

zzz@ubuntu:~/my_learning$ python3 prog.py 1 3 2 6
6
zzz@ubuntu:~/my_learning$ python3 prog.py 1 3 2 6 --sum
12
zzz@ubuntu:~/my_learning$ 
1
2
3
4
5

脚本简析：

1. 使用 argparse创建一个 ArgumentParse 对象。该对象将包含命令行解析成Python数据类型所需的全部信息。

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

2. 给 ArgumentParse 对象添加程序参数信息，通过调用 add_argument()方法完成。指定 ArgumentParser 如何获取命令行字符串并将其转换为对象。

>>> 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)')
1
2
3
4
5

3. 这些信息在parse_args()调用时被存储和使用。 ArgumentParse 对象通过调用 parse_args() 方法解析参数。该方法将检查命令行，把每个参数转换为适当的类型然后调用相应的操作。

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

parse_args()返回一个具有两个属性（‘integers’ 和 ‘accumulate’）的对象。integers属性将是一个包含一个或多个整数的列表，而 accumulate 属性当命令行中指定了 --sum 参数时将是 sum() 函数，否则则是 max() 函数。

2. ArgumentParser 对象

class argparse.ArgumentParser(
	prog=None,	# 程序名，默认为脚本文件名。
	usage=None, # 根据它包含的参数来构建用法消息。
	description=None, # 简约描述程序的功能。
	epilog=None,
	parents=[],
	formatter_class=argparse.HelpFormatter,
	prefix_chars='-', 
	romfile_prefix_chars=None,
	argument_default=None,
	conflict_handler='error', 
	add_help=True, 
	allow_abbrev=True,
	 exit_on_error=True
	)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3. ArgumentParser.add_argument() 方法

ArgumentParser.add_argument(
		name or flags
		[, action]
		[, nargs]
		[, const]
		[, default]
		[, type]
		[, choices]
		[, required]
		[, help]
		[, metavar]
		[, dest]
		)
1
2
3
4
5
6
7
8
9
10
11
12
13

参数结束：

• name or flags，选项或位置参数
  • 选项创建
  • 位置参数创建：以 - 前缀识别，其它识别为位置参数

>>>parser.add_argument('-f', '--foo')
>>>parser.add_argument('bar')
1
2

• action，指定对应的命令行参数应当如何处理，可选项有：
  • store-存储参数的值。默认动作。

    >>> parser.add_argument('--foo')
    1

  • store_const-存储被const命名参数指定的值。通常用在选项中来指定一些标志。

    >>> parser.add_argument('--foo', action='store_true')
    >>> parser.add_argument('--bar', action='store_false')
    >>> parser.add_argument('--baz', action='store_false')
    1
    2
    3

  • store_true and store_false-store-const的用于存储True和False的特殊用例，默认值为True和False。
  • append-存储一个列表，并且将每个参数追加到列表中。

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

  • append_const-存储一个列表，并将const命名参数指定的值追加到列表中。
  • count-计算一个关键字参数出现的数目或次数。

    >>> parser.add_argument('--verbose', '-v', action='count', default=0)
    1

  • help-打印所有当前解析器中的选项和参数都的完整帮助信息。
  • version-期望有一个version命令参数在调用中，并打印版本信息。
  • extend-这会存储一个列表，并将每个参数值加入到列表中

    >>> parser.add_argument('--foo', action=argparse.BooleanOptionalAction)
    >>> parser.parse_args(['--no-foo'])
    Namespace(foo=False)
    1
    2
    3

• 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'])
    1
    2
    3
    4
    5

  • ‘?’。如果可能的话，会从命令行中消耗一个参数，并产生一个单一项。如果当前没有命令行参数，则会产生 default 值。注意，对于选项，有另外的用例 - 选项字符串出现但没有跟随命令行参数，则会产生 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')
    1
    2
    3
    4
    5
    6
    7
    8
    9

  • ‘*’。将当前命令行参数集到一个列表中。和’+'类似。

    >>> 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'])
    1
    2
    3
    4
    5
    6

• const，用于保存不从命令行中读取但被需求的常数值。常见的两种用途：
  • 当add_argument()使用 action='store_const' 或 action='append_const 调用时。这些动作将 const 值添加到 parse_args() 返回的对象的属性中。
  • 当 add_argument() 通过选项（例如 -f 或 --foo）调用并且 nargs='?' 时。这会创建一个可以跟随零个或一个命令行参数的选项。当解析命令行时，如果选项后没有参数，则将用 const 代替。
• default，当选项或位置参数被忽略时，可以指定在命令行参数未出现时应当使用的值。

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

• type，命令行参数默认当作字符串读入，type可以使用普通内置类型和函数或者自定义的函数作为类型转化器。

  parser = argparse.ArgumentParser()
  parser.add_argument('count', type=int)
  parser.add_argument('distance', type=float)
  parser.add_argument('street', type=ascii)
  parser.add_argument('code_point', type=ord)
  parser.add_argument('source_file', type=open)
  parser.add_argument('dest_file', type=argparse.FileType('w', encoding='latin-1'))
  parser.add_argument('datapath', type=pathlib.Path)
  1
  2
  3
  4
  5
  6
  7
  8

• choices，某些参数应从一组限定值中选择，此时可以使用choices参数。

  >>> parser = argparse.ArgumentParser(prog='game.py')
  >>> parser.add_argument('move', choices=['rock', 'paper', 'scissors'])
  >>> parser.parse_args(['rock'])
  Namespace(move='rock')
  1
  2
  3
  4

• required，'-'标记的选项参数一般可以被忽略，如果需要将其标志位必须，则可以使用该关键字为True来说明。

  >>> parser = argparse.ArgumentParser()
  >>> parser.add_argument('--foo', required=True)
  >>> parser.parse_args(['--foo', 'BAR'])
  Namespace(foo='BAR')
  1
  2
  3
  4

• metavar
• dest

4. ArgumentParser.parse_args() 方法

将参数字符串转换为对象并将其设为命名空间的属性。 add_argument() 添加了对象及其赋值。

ArgumentParser.parse_args(
		args=None,    # 要解析的字符串列表。默认值从 sys.argv获取。
		namespace=None # 要获取属性的对象。默认值是一个新的空Namespace对象。
		)
1
2
3
4