原文地址：https://pythoncaff.com/docs/pymotw/argparse-command-line-option-and-argument-parsing/166

https://docs.python.org/3/library/argparse.html?highlight=argparse#module-argparse-------argparse 官网

http://www.cnblogs.com/arkenstone/p/6250782.html------Python3 -- argparse模块

http://blog.csdn.net/WIinter_FDd/article/details/75786410

https://oldpan.me/archives/argparse-python-order-command--------Argparse-parser模块:python快捷实现命令行操作

这是一篇社区协同翻译的文章，你可以点击右边区块信息里的『改进』按钮向译者提交改进建议。

目标:命令行选项和参数解析

argparse 模块包含了用于创建命令行参数和选项程序的工具。它在 Python 2.7 中加入并作为 optparse 模块的替代者。argparse 模块的实现支持那些在 optparse 中不容易实现的特征，这也导致了向后不兼容的 API 改变，所以是一个新的模块被加入到标准库中。optparse 现在已经被废弃。

创建一个解析器##

使用 argparse 的第一步是创建一个解析器对象然后告诉它要接收什么参数。解析器随后可以在程序运行时用于处理命令行参数。解析器对象 (ArgumentParser) 的构造器接收一些参数来构建用于帮助文本的简介和其他全局表现设置。

  1. import argparse
  2. parser = argparse.ArgumentParser(
  3.     description='This is a PyMOTW sample program',
  4. )

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

定义参数##

arpparse 是一个完整的参数处理库。参数可以触发不同动作，这可以通过 add_argument() 的 action 参数来声明。支持的动作包括储存参数值（单独地或这作为列表的一部分存储），当使用一个参数时（包括特殊 true/false 的布尔型数值转换处理）存储一个常数，对参数出现次数进行计数和使用回调函数来使用定制的处理指令。

默认的动作是存储参数值。如果指定了参数类型，参数值会在被储存前转换。如果提供了 dest 参数，命令行参数被解析时参数值会以 dest 参数提供的变量名存储。

解析一个命令行##

在所有参数都被定义后，通过传递一组参数字符串序列给 parse_args() 来解析参数。默认情况下，所有参数从 sys.argv[1:] 中取得，但也可以使用一个字符串列表。选项使用 GNU/POSIX 语法处理，所以选项和参数值在序列里是混合的。

parse_args() 的返回值是一个包含命令参数的 Namespace。这个对象将参数值作为属性保存，所以如果参数的 dest 被设为 "myoption"，参数值可以通过 args.myoption 的方式获取。

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

简单的例子##

以下是一个有三个不同选项的例子：一个布尔型选项 (-a), 一个简单的字符串选项 (-b), 和一个整数选项 (-c) 。

argparse_short.py

  1. import argparse
  3. parser = argparse.ArgumentParser(description='Short sample app')
  5. parser.add_argument('-a', action="store_true", default=False)
  6. parser.add_argument('-b', action="store", dest="b")
  7. parser.add_argument('-c', action="store", dest="c", type=int)
  9. print(parser.parse_args(['-a', '-bval', '-c', '3']))

单字符选项传值有几种方式。前面的例子展示了两种不同的方式，-bval 和 -c val。

  1. $ python3 argparse_short.py
  3. Namespace(a=True, b='val', c=3)

与 c 相关的值在输出中是一个整数，这是因为 ArgumentParser 被告知在保存这个参数之前要进行转换。

名称多于一个字符的选项，也就是“长”选项也是以这样的方式处理的。

argparse_long.py

  1. import argparse
  3. parser = argparse.ArgumentParser(
  4.     description='Example with long option names',
  5. )
  7. parser.add_argument('--noarg', action="store_true",
  8.                     default=False)
  9. parser.add_argument('--witharg', action="store",
  10.                     dest="witharg")
  11. parser.add_argument('--witharg2', action="store",
  12.                     dest="witharg2", type=int)
  14. print(
  15.     parser.parse_args(
  16.         ['--noarg', '--witharg', 'val', '--witharg2=3']
  17.     )
  18. )

结果是类似的。

  1. $ python3 argparse_long.py
  3. Namespace(noarg=True, witharg='val', witharg2=3)

argparse 是一个完整的命令行参数解析工具，可以处理可选参数和必须参数。

argparse_arguments.py

  1. import argparse
  3. parser = argparse.ArgumentParser(
  4.     description='Example with nonoptional arguments',
  5. )
  7. parser.add_argument('count', action="store", type=int)
  8. parser.add_argument('units', action="store")
  10. print(parser.parse_args())

在这个例子中，count 参数值是一个整数，unit 参数值以一个字符串保存。如果命令行中缺少了两个参数中任何一个，或者传递的值不能被转换为正确的类型，将会抛出错误。

  1. $ python3 argparse_arguments.py 3 inches
  3. Namespace(count=3, units='inches')
  5. $ python3 argparse_arguments.py some inches
  7. usage: argparse_arguments.py [-h] count units
  8. argparse_arguments.py: error: argument count: invalid int value:
  9. 'some'
  11. $ python3 argparse_arguments.py
  13. usage: argparse_arguments.py [-h] count units
  14. argparse_arguments.py: error: the following arguments are
  15. required: count, units

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

参数动作##

当一个参数被传递时可以触发任何6个内建动作的任何一个。

store

选择性地转换为一个不同的类型后保存参数值。如果没有特别声明动作时这是默认动作。

store_const

保存一个在参数声明时定义的值，而非解析参数时得到的值。这通常被用于实现非布尔型数值的命令行标志。

store_true / store_false

保存相应的布尔型数值，这个动作被用于实现布尔值开关。

append

将参数值保存在一个列表中。如果参数重复了，那么多个参数值将会被保存。

append_const

将参数值保存在参数声明时指定的列表中。

version

打印程序版本详情然后退出

这个示例程序演示了让每个动作类型能够工作的最少配置。

argparse_action.py

  1. import argparse
  3. parser = argparse.ArgumentParser()
  5. parser.add_argument('-s', action='store',
  6.                     dest='simple_value',
  7.                     help='Store a simple value')
  9. parser.add_argument('-c', action='store_const',
  10.                     dest='constant_value',
  11.                     const='value-to-store',
  12.                     help='Store a constant value')
  14. parser.add_argument('-t', action='store_true',
  15.                     default=False,
  16.                     dest='boolean_t',
  17.                     help='Set a switch to true')
  18. parser.add_argument('-f', action='store_false',
  19.                     default=True,
  20.                     dest='boolean_f',
  21.                     help='Set a switch to false')
  23. parser.add_argument('-a', action='append',
  24.                     dest='collection',
  25.                     default=[],
  26.                     help='Add repeated values to a list')
  28. parser.add_argument('-A', action='append_const',
  29.                     dest='const_collection',
  30.                     const='value-1-to-append',
  31.                     default=[],
  32.                     help='Add different values to list')
  33. parser.add_argument('-B', action='append_const',
  34.                     dest='const_collection',
  35.                     const='value-2-to-append',
  36.                     help='Add different values to list')
  38. parser.add_argument('--version', action='version',
  39.                     version='%(prog)s 1.0')
  41. results = parser.parse_args()
  42. print('simple_value     = {!r}'.format(results.simple_value))
  43. print('constant_value   = {!r}'.format(results.constant_value))
  44. print('boolean_t        = {!r}'.format(results.boolean_t))
  45. print('boolean_f        = {!r}'.format(results.boolean_f))
  46. print('collection       = {!r}'.format(results.collection))
  47. print('const_collection = {!r}'.format(results.const_collection))

-t 和 -f 选项用于设置修改不同选项值，每个保存 True 或 False。-A 和 -B 的 dest 参数值相同，所以它们的常量会被添加到相同的列表中。

  1. $ python3 argparse_action.py -h
  3. usage: argparse_action.py [-h] [-s SIMPLE_VALUE] [-c] [-t] [-f]
  4.                           [-a COLLECTION] [-A] [-B] [--version]
  6. optional arguments:
  7.   -h, --help       show this help message and exit
  8.   -s SIMPLE_VALUE  Store a simple value
  9.   -c               Store a constant value
  10.   -t               Set a switch to true
  11.   -f               Set a switch to false
  12.   -a COLLECTION    Add repeated values to a list
  13.   -A               Add different values to list
  14.   -B               Add different values to list
  15.   --version        show program's version number and exit
  17. $ python3 argparse_action.py -s value
  19. simple_value     = 'value'
  20. constant_value   = None
  21. boolean_t        = False
  22. boolean_f        = True
  23. collection       = []
  24. const_collection = []
  26. $ python3 argparse_action.py -c
  28. simple_value     = None
  29. constant_value   = 'value-to-store'
  30. boolean_t        = False
  31. boolean_f        = True
  32. collection       = []
  33. const_collection = []
  35. $ python3 argparse_action.py -t
  37. simple_value     = None
  38. constant_value   = None
  39. boolean_t        = True
  40. boolean_f        = True
  41. collection       = []
  42. const_collection = []
  44. $ python3 argparse_action.py -f
  46. simple_value     = None
  47. constant_value   = None
  48. boolean_t        = False
  49. boolean_f        = False
  50. collection       = []
  51. const_collection = []
  53. $ python3 argparse_action.py -a one -a two -a three
  55. simple_value     = None
  56. constant_value   = None
  57. boolean_t        = False
  58. boolean_f        = True
  59. collection       = ['one', 'two', 'three']
  60. const_collection = []
  62. $ python3 argparse_action.py -B -A
  64. simple_value     = None
  65. constant_value   = None
  66. boolean_t        = False
  67. boolean_f        = True
  68. collection       = []
  69. const_collection = ['value-2-to-append', 'value-1-to-append']
  71. $ python3 argparse_action.py --version
  73. argparse_action.py 1.0

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

选项前缀##

默认语法是基于使用前缀（“-”）表示命令行开关的Unix惯例。argparse 支持也其他前缀，所以程序可以使用符合本地操作系统默认的前缀（比如 windows 的 “'/'”）或者遵循不同的惯例。

argparse_prefix_chars.py

  1. import argparse
  3. parser = argparse.ArgumentParser(
  4.     description='Change the option prefix characters',
  5.     prefix_chars='-+/',
  6. )
  8. parser.add_argument('-a', action="store_false",
  9.                     default=None,
  10.                     help='Turn A off',
  11.                     )
  12. parser.add_argument('+a', action="store_true",
  13.                     default=None,
  14.                     help='Turn A on',
  15.                     )
  16. parser.add_argument('//noarg', '++noarg',
  17.                     action="store_true",
  18.                     default=False)
  20. print(parser.parse_args())

你可以把 ArgumentParser 的 prefix_chars 参数设置为一个包含所有允许的前缀的字符串。重要的一点是要理解尽管 prefix_chars 明确了允许的开关字符，但参数定义时指明了该参数的可用前缀。这样可以精确地控制选项功能，使用不同前缀可能仅仅是选项的别名（比如说平台依赖的命令行语法）或者其他意义（比如使用 '+' 来表示打开某个选项，'-' 来表示关闭某选项）。在上面的例子中，+a 和 -a 是不同的参数，而 //noarg 可以使用 ++noarg 样式，但不能是 --noarg。

  1. $ python3 argparse_prefix_chars.py -h
  3. usage: argparse_prefix_chars.py [-h] [-a] [+a] [//noarg]
  5. Change the option prefix characters
  7. optional arguments:
  8.   -h, --help        show this help message and exit
  9.   -a                Turn A off
  10.   +a                Turn A on
  11.   //noarg, ++noarg
  13. $ python3 argparse_prefix_chars.py +a
  15. Namespace(a=True, noarg=False)
  17. $ python3 argparse_prefix_chars.py -a
  19. Namespace(a=False, noarg=False)
  21. $ python3 argparse_prefix_chars.py //noarg
  23. Namespace(a=None, noarg=True)
  25. $ python3 argparse_prefix_chars.py ++noarg
  27. Namespace(a=None, noarg=True)
  29. $ python3 argparse_prefix_chars.py --noarg
  31. usage: argparse_prefix_chars.py [-h] [-a] [+a] [//noarg]
  32. argparse_prefix_chars.py: error: unrecognized arguments: --noarg

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

参数来源##

目前的例子里，解析器接收的参数列表来自于显式传递的一个列表，或默认从 sys.argv 中获取。显示传递一个列表给解析器在使用 argparse 来处理不来自命令行的但像命令行一样的指令（比如该命令来自配置文件）很有用。

argparse_with_shlex.py

  1. import argparse
  2. from configparser import ConfigParser
  3. import shlex
  5. parser = argparse.ArgumentParser(description='Short sample app')
  7. parser.add_argument('-a', action="store_true", default=False)
  8. parser.add_argument('-b', action="store", dest="b")
  9. parser.add_argument('-c', action="store", dest="c", type=int)
  11. config = ConfigParser()
  12. config.read('argparse_with_shlex.ini')
  13. config_value = config.get('cli', 'options')
  14. print('Config  :', config_value)
  16. argument_list = shlex.split(config_value)
  17. print('Arg List:', argument_list)
  19. print('Results :', parser.parse_args(argument_list))

这个例子使用 configparser 读取配置文件。

  1. [cli]
  2. options = -a -b 2

shlex 可以让拆开配置文件中的字符串变得容易。

  1. $ python3 argparse_with_shlex.py
  3. Config  : -a -b 2
  4. Arg List: ['-a', '-b', '2']
  5. Results : Namespace(a=True, b='2', c=None)

在应用程序代码中处理配置文件的另一个方案是使用 fromfile_prefix_chars 告诉 argparse 识别一个特殊参数，这个参数指明了包涵需要处理的参数的文件。

argparse_fromfile_prefix_chars.py

  1. import argparse
  2. import shlex
  4. parser = argparse.ArgumentParser(description='Short sample app',
  5.                                  fromfile_prefix_chars='@',
  6.                                  )
  8. parser.add_argument('-a', action="store_true", default=False)
  9. parser.add_argument('-b', action="store", dest="b")
  10. parser.add_argument('-c', action="store", dest="c", type=int)
  12. print(parser.parse_args(['@argparse_fromfile_prefix_chars.txt']))

这个例子的代码会在发现一个 @ 前缀的参数时停下，然后读取该文件来找到更多参数。这个文件应该每行包含一个参数，如下面例子所示。

argparse_fromfile_prefix_chars.txt

  1. -a
  2. -b
  3. 2

解析 argparse_from_prefix_chars.txt 的输出如下。

  1. $ python3 argparse_fromfile_prefix_chars.py
  3. Namespace(a=True, b='2', c=None)

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

帮助内容##

自动生成的帮助文本##

如果配置为这样做，argparse 会自动生成选项的帮助文本。ArgumentParser 的 add_help 参数可以控制相关选项。

argparse_with_help.py

  1. import argparse
  3. parser = argparse.ArgumentParser(add_help=True)
  5. parser.add_argument('-a', action="store_true", default=False)
  6. parser.add_argument('-b', action="store", dest="b")
  7. parser.add_argument('-c', action="store", dest="c", type=int)
  9. print(parser.parse_args())

帮助选项（-h 和 --help ）默认会被自动添加，可以设置 add_help 为 False 来停用这个功能。

argparse_without_help.py

  1. import argparse
  3. parser = argparse.ArgumentParser(add_help=False)
  5. parser.add_argument('-a', action="store_true", default=False)
  6. parser.add_argument('-b', action="store", dest="b")
  7. parser.add_argument('-c', action="store", dest="c", type=int)
  9. print(parser.parse_args())

尽管 -h 和 --help 是请求帮助选项的事实标准，一些应用或某些 argparse 的用法不需要提供帮助内容或这两个选项另有他用。

  1. $ python3 argparse_with_help.py -h
  3. usage: argparse_with_help.py [-h] [-a] [-b B] [-c C]
  5. optional arguments:
  6.   -h, --help  show this help message and exit
  7.   -a
  8.   -b B
  9.   -c C
  11. $ python3 argparse_without_help.py -h
  13. usage: argparse_without_help.py [-a] [-b B] [-c C]
  14. argparse_without_help.py: error: unrecognized arguments: -h

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

定制帮助内容##

对于需要直接处理帮助内容的应用，ArgumentParser 的一些实用方法在创建 定制动作 来打印带有额外信息的帮助文本时很有用。

argparse_custom_help.py

  1. import argparse
  3. parser = argparse.ArgumentParser(add_help=True)
  5. parser.add_argument('-a', action="store_true", default=False)
  6. parser.add_argument('-b', action="store", dest="b")
  7. parser.add_argument('-c', action="store", dest="c", type=int)
  9. print('print_usage output:')
  10. parser.print_usage()
  11. print()
  13. print('print_help output:')
  14. parser.print_help()

print_usage() 打印参数解析器的简略使用信息，print_help() 会打印完整帮助文本。

  1. $ python3 argparse_custom_help.py
  3. print_usage output:
  4. usage: argparse_custom_help.py [-h] [-a] [-b B] [-c C]
  6. print_help output:
  7. usage: argparse_custom_help.py [-h] [-a] [-b B] [-c C]
  9. optional arguments:
  10.   -h, --help  show this help message and exit
  11.   -a
  12.   -b B
  13.   -c C

ArgumentParser 使用一个格式化类来控制帮助文本的显示样式。要改变格式化类，可以在实例化 ArgumentParser 时传递 formatter_class 参数。

例如，RawDescriptionHelpFormatter 会绕过程序默认提供的换行。

argparse_raw_description_help_formatter.py

  1. import argparse
  3. parser = argparse.ArgumentParser(
  4.     add_help=True,
  5.     formatter_class=argparse.RawDescriptionHelpFormatter,
  6.     description="""
  7.     description
  8.         not
  9.            wrapped""",
  10.     epilog="""
  11.     epilog
  12.       not
  13.          wrapped""",
  14. )
  16. parser.add_argument(
  17.     '-a', action="store_true",
  18.     help="""argument
  19.     help is
  20.     wrapped
  21.     """,
  22. )
  24. parser.print_help()

命令的介绍和结语的帮助文本会原封不动地打印。

  1. $ python3 argparse_raw_description_help_formatter.py
  3. usage: argparse_raw_description_help_formatter.py [-h] [-a]
  5.     description
  6.         not
  7.            wrapped
  9. optional arguments:
  10.   -h, --help  show this help message and exit
  11.   -a          argument help is wrapped
  13.     epilog
  14.       not
  15.          wrapped

RawTextHelpFormatter 视所有帮助文本都是预格式化好的。

argparse_raw_text_help_formatter.py

  1. import argparse
  3. parser = argparse.ArgumentParser(
  4.     add_help=True,
  5.     formatter_class=argparse.RawTextHelpFormatter,
  6.     description="""
  7.     description
  8.         not
  9.            wrapped""",
  10.     epilog="""
  11.     epilog
  12.       not
  13.          wrapped""",
  14. )
  16. parser.add_argument(
  17.     '-a', action="store_true",
  18.     help="""argument
  19.     help is not
  20.     wrapped
  21.     """,
  22. )
  24. parser.print_help()

-a 的帮助文本不会再别整齐地包装起来。

  1. $ python3 argparse_raw_text_help_formatter.py
  3. usage: argparse_raw_text_help_formatter.py [-h] [-a]
  5.     description
  6.         not
  7.            wrapped
  9. optional arguments:
  10.   -h, --help  show this help message and exit
  11.   -a          argument
  12.                   help is not
  13.                   wrapped
  15.     epilog
  16.       not
  17.          wrapped

原始格式化类可能用于改变帮助文本的格式可能会让例子失效的应用程序中。

MetavarTypeHelpFormatter 还会打印每个选项的类型而非仅有目标变量名称，这个格式化类可用于有很多不同类型选项的应用程序。

argparse_metavar_type_help_formatter.py

  1. import argparse
  3. parser = argparse.ArgumentParser(
  4.     add_help=True,
  5.     formatter_class=argparse.MetavarTypeHelpFormatter,
  6. )
  8. parser.add_argument('-i', type=int, dest='notshown1')
  9. parser.add_argument('-f', type=float, dest='notshown2')
  11. parser.print_help()

除了显示 dest 的值，与选项相关的参数值类型也会被打印。

  1. $ python3 argparse_metavar_type_help_formatter.py
  3. usage: argparse_metavar_type_help_formatter.py [-h] [-i int] [-f
  4.  float]
  6. optional arguments:
  7.   -h, --help  show this help message and exit
  8.   -i int
  9.   -f float

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

组织解析器##

为了让实现解析器或提高帮助文本的可用性， argparse 模块提供几个功能来组织参数解析器。

分享解析规则##

程序员通常需要实现一套命令行工具，这个工具接收一组参数，并以某特定方式使用这组参数。例如，一些程序需要在真正执行动作前对用户进行认证，它们都需要支持 --user 和 --password 选项。除了单独地向每个 ArgumentParser 都添加这两个选项外，先定义一个带有共享参数的父解析器，接着继承父解析器并编写用于某特定程序的参数解析器也是一种可能的方案。

第一步是建立有共享参数解析器。由于后续使用父解析器的用户会尝试添加相同的帮助选项，这将会抛出错误，所以父解析器自动生成帮助文本特性被关闭了。

argparse_parent_base.py

  1. import argparse
  3. parser = argparse.ArgumentParser(add_help=False)
  5. parser.add_argument('--user', action="store")
  6. parser.add_argument('--password', action="store")

接下来创建一个使用共享 parents 参数集的解析器:

argparse_uses_parent.py

  1. import argparse
  2. import argparse_parent_base
  4. parser = argparse.ArgumentParser(
  5.     parents=[argparse_parent_base.parser],
  6. )
  8. parser.add_argument('--local-arg',
  9.                     action="store_true",
  10.                     default=False)
  12. print(parser.parse_args())

最后程序会有所有的三个选项。

  1. $ python3 argparse_uses_parent.py -h
  3. usage: argparse_uses_parent.py [-h] [--user USER]
  4.                                [--password PASSWORD]
  5.                                [--local-arg]
  7. optional arguments:
  8.   -h, --help           show this help message and exit
  9.   --user USER
  10.   --password PASSWORD
  11.   --local-arg

冲突选项##

上面的例子指出添加两个参数名相同的选项会导致异常。冲突解决行为可以通过传递一个 confilct_handler 来改变。两个内建的处理器是 error （默认）和 resolve ，这处理器会根据同名参数的添加顺序选择参数处理器，即后续同名参数会覆盖之前的同名参数。

argparse_conflict_handler_resolve.py

  1. import argparse
  3. parser = argparse.ArgumentParser(conflict_handler='resolve')
  5. parser.add_argument('-a', action="store")
  6. parser.add_argument('-b', action="store", help='Short alone')
  7. parser.add_argument('--long-b', '-b',
  8.                     action="store",
  9.                     help='Long and short together')
  11. print(parser.parse_args(['-h']))

在这个例子中，由于最后一个参数处理器使用了已经定义过的参数名，单独选项 -b 会被 --long-b 的别名掩盖。

  1. $ python3 argparse_conflict_handler_resolve.py
  3. usage: argparse_conflict_handler_resolve.py [-h] [-a A]
  4. [--long-b LONG_B]
  6. optional arguments:
  7.   -h, --help            show this help message and exit
  8.   -a A
  9.   --long-b LONG_B, -b LONG_B
  10.                         Long and short together

交换 add_argument() 的调用顺序可以独立的 -b 不被掩盖：

argparse_conflict_handler_resolve2.py

  1. import argparse
  3. parser = argparse.ArgumentParser(conflict_handler='resolve')
  5. parser.add_argument('-a', action="store")
  6. parser.add_argument('--long-b', '-b',
  7.                     action="store",
  8.                     help='Long and short together')
  9. parser.add_argument('-b', action="store", help='Short alone')
  11. print(parser.parse_args(['-h']))

现在两个选项可以一起使用了。

  1. $ python3 argparse_conflict_handler_resolve2.py
  3. usage: argparse_conflict_handler_resolve2.py [-h] [-a A]
  4.                                              [--long-b LONG_B]
  5.                                              [-b B]
  7. optional arguments:
  8.   -h, --help       show this help message and exit
  9.   -a A
  10.   --long-b LONG_B  Long and short together
  11.   -b B             Short alone

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

参数组##

argparse 把参数定义组合为 “参数组” 。默认情况下，它使用两个参数组，一个用于可选参数，一个用于位置参数。

argparse_default_grouping.py

  1. import argparse
  3. parser = argparse.ArgumentParser(description='Short sample app')
  5. parser.add_argument('--optional', action="store_true",
  6.                     default=False)
  7. parser.add_argument('positional', action="store")
  9. print(parser.parse_args())

位置参数和可选参数的分组反映在帮助文本的不同区块。

  1. $ python3 argparse_default_grouping.py -h
  3. usage: argparse_default_grouping.py [-h] [--optional] positional
  5. Short sample app
  7. positional arguments:
  8.   positional
  10. optional arguments:
  11.   -h, --help  show this help message and exit
  12.   --optional

分组可以改变以让帮助文本更有逻辑性，这样可以让相关的选项和参数值会被一起归档。之前的共享选项例子可以使用定制分组以让认证选项一起出现在帮助文本中。

使用 add_argument_group 创建 “authentication” 分组，然后向分组添加认证相关选项到这个分组中，而非基础解析器。

argparse_parent_with_group.py

  1. import argparse
  3. parser = argparse.ArgumentParser(add_help=False)
  5. group = parser.add_argument_group('authentication')
  7. group.add_argument('--user', action="store")
  8. group.add_argument('--password', action="store")

正如之前的用法，程序可以使用基于分组的父解析器作为 parents 的值。

argparse_uses_parent_with_group.py

  1. import argparse
  2. import argparse_parent_with_group
  4. parser = argparse.ArgumentParser(
  5.     parents=[argparse_parent_with_group.parser],
  6. )
  8. parser.add_argument('--local-arg',
  9.                     action="store_true",
  10.                     default=False)
  12. print(parser.parse_args())

现在帮助文本会把认证选项显示在一起。

  1. $ python3 argparse_uses_parent_with_group.py -h
  3. usage: argparse_uses_parent_with_group.py [-h] [--user USER]
  4.                                           [--password PASSWORD]
  5.                                           [--local-arg]
  7. optional arguments:
  8.   -h, --help           show this help message and exit
  9.   --local-arg
  11. authentication:
  12.   --user USER
  13.   --password PASSWORD

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

互斥选项##

定义互斥选项是使用分组特性的特殊情况，这时需要使用 add_mutually_exclusive_group() 而不是 add_argument_group()。

argparse_mutually_exclusive.py

  1. import argparse
  3. parser = argparse.ArgumentParser()
  5. group = parser.add_mutually_exclusive_group()
  6. group.add_argument('-a', action='store_true')
  7. group.add_argument('-b', action='store_true')
  9. print(parser.parse_args())

argparse 会保证互斥性，这会让组内只有一个选项可以使用。

  1. $ python3 argparse_mutually_exclusive.py -h
  3. usage: argparse_mutually_exclusive.py [-h] [-a | -b]
  5. optional arguments:
  6.   -h, --help  show this help message and exit
  7.   -a
  8.   -b
  10. $ python3 argparse_mutually_exclusive.py -a
  12. Namespace(a=True, b=False)
  14. $ python3 argparse_mutually_exclusive.py -b
  16. Namespace(a=False, b=True)
  18. $ python3 argparse_mutually_exclusive.py -a -b
  20. usage: argparse_mutually_exclusive.py [-h] [-a | -b]
  21. argparse_mutually_exclusive.py: error: argument -b: not allowed
  22. with argument -a

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

嵌套解析器##

之前介绍的使用父解析器是在相关命令之间共享选项的一种方法。一个替代方案是将这些命令组合到单个程序中，使用子解析器来处理命令行的每个部分。这样程序就如 svn，hg 和其他有多个命令动作作或子命令的程序一样工作。

一个处理系统目录的程序可能会定义创建，删除和列举目录内容的命令。

argparse_subparsers.py

  1. import argparse
  3. parser = argparse.ArgumentParser()
  5. subparsers = parser.add_subparsers(help='commands')
  7. # 一个列举命令
  8. list_parser = subparsers.add_parser(
  9.     'list', help='List contents')
  10. list_parser.add_argument(
  11.     'dirname', action='store',
  12.     help='Directory to list')
  14. # 一个创建命令
  15. create_parser = subparsers.add_parser(
  16.     'create', help='Create a directory')
  17. create_parser.add_argument(
  18.     'dirname', action='store',
  19.     help='New directory to create')
  20. create_parser.add_argument(
  21.     '--read-only', default=False, action='store_true',
  22.     help='Set permissions to prevent writing to the directory',
  23. )
  25. # 一个删除命令
  26. delete_parser = subparsers.add_parser(
  27.     'delete', help='Remove a directory')
  28. delete_parser.add_argument(
  29.     'dirname', action='store', help='The directory to remove')
  30. delete_parser.add_argument(
  31.     '--recursive', '-r', default=False, action='store_true',
  32.     help='Remove the contents of the directory, too',
  33. )
  35. print(parser.parse_args())

帮助输出将命名的子解析器显示为“命令”，这个“命令”可以在命令行中将其指定为位置参数。

  1. $ python3 argparse_subparsers.py -h
  3. usage: argparse_subparsers.py [-h] {list,create,delete} ...
  5. positional arguments:
  6.   {list,create,delete}  commands
  7.     list                List contents
  8.     create              Create a directory
  9.     delete              Remove a directory
  11. optional arguments:
  12.   -h, --help            show this help message and exit

每个子解析器也可用拥有它自己的帮助文本，用于介绍该命令的参数选项。

  1. $ python3 argparse_subparsers.py create -h
  3. usage: argparse_subparsers.py create [-h] [--read-only] dirname
  5. positional arguments:
  6.   dirname      New directory to create
  8. optional arguments:
  9.   -h, --help   show this help message and exit
  10.   --read-only  Set permissions to prevent writing to the directo
  11. ry

当解析参数时，parse_args() 返回的 Namespace 对象只包含命令相关的值。

  1. $ python3 argparse_subparsers.py delete -r foo
  3. Namespace(dirname='foo', recursive=True)

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

高级参数处理##

目前的例子展示了简单的布尔标志，字符串选项或数值参数，还有位置参数。argparse 也支持用于变长参数列表，枚举和常量的复杂参数定义。

变长参数列表##

单个参数定义可以被配置于用来接收来自命令行的多个参数。根据需要或期望的参数个数把 nargs 设为下面表格中的一个。

argparse 变长参数定义标志

值 含义
N 参数确切个数（比如 3 个）
? 0 或 1 个参数
* 0 或更多参数
+ 至少有一个参数

argparse_nargs.py

  1. import argparse
  3. parser = argparse.ArgumentParser()
  5. parser.add_argument('--three', nargs=3)
  6. parser.add_argument('--optional', nargs='?')
  7. parser.add_argument('--all', nargs='*', dest='all')
  8. parser.add_argument('--one-or-more', nargs='+')
  10. print(parser.parse_args())

解析器强制执行参数计数指令，并生成确切的语法图作为命令帮助文本的一部分。

  1. $ python3 argparse_nargs.py -h
  3. usage: argparse_nargs.py [-h] [--three THREE THREE THREE]
  4.                 [--optional [OPTIONAL]]
  5.                 [--all [ALL [ALL ...]]]
  6.                 [--one-or-more ONE_OR_MORE [ONE_OR_MORE ...]]
  8. optional arguments:
  9.   -h, --help            show this help message and exit
  10.   --three THREE THREE THREE
  11.   --optional [OPTIONAL]
  12.   --all [ALL [ALL ...]]
  13.   --one-or-more ONE_OR_MORE [ONE_OR_MORE ...]
  15. $ python3 argparse_nargs.py
  17. Namespace(all=None, one_or_more=None, optional=None, three=None)
  19. $ python3 argparse_nargs.py --three
  21. usage: argparse_nargs.py [-h] [--three THREE THREE THREE]
  22.                 [--optional [OPTIONAL]]
  23.                 [--all [ALL [ALL ...]]]
  24.                 [--one-or-more ONE_OR_MORE [ONE_OR_MORE ...]]
  25. argparse_nargs.py: error: argument --three: expected 3
  26. argument(s)
  28. $ python3 argparse_nargs.py --three a b c
  30. Namespace(all=None, one_or_more=None, optional=None,
  31. three=['a', 'b', 'c'])
  33. $ python3 argparse_nargs.py --optional
  35. Namespace(all=None, one_or_more=None, optional=None, three=None)
  37. $ python3 argparse_nargs.py --optional with_value
  39. Namespace(all=None, one_or_more=None, optional='with_value',
  40. three=None)
  42. $ python3 argparse_nargs.py --all with multiple values
  44. Namespace(all=['with', 'multiple', 'values'], one_or_more=None,
  45. optional=None, three=None)
  47. $ python3 argparse_nargs.py --one-or-more with_value
  49. Namespace(all=None, one_or_more=['with_value'], optional=None,
  50. three=None)
  52. $ python3 argparse_nargs.py --one-or-more with multiple values
  54. Namespace(all=None, one_or_more=['with', 'multiple', 'values'],
  55. optional=None, three=None)
  57. $ python3 argparse_nargs.py --one-or-more
  59. usage: argparse_nargs.py [-h] [--three THREE THREE THREE]
  60.                 [--optional [OPTIONAL]]
  61.                 [--all [ALL [ALL ...]]]
  62.                 [--one-or-more ONE_OR_MORE [ONE_OR_MORE ...]]
  63. argparse_nargs.py: error: argument --one-or-more: expected
  64. at least one argument

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

参数类型##

argparse 将所有参数视为字符串，除非被告知要将参数转换为其他类型。add_argument() 的 type() 参数定义了一个转换函数，这个函数会被 ArgumentParser 用来把参数值转换为其他类型。

argparse_type.py

  1. import argparse
  3. parser = argparse.ArgumentParser()
  5. parser.add_argument('-i', type=int)
  6. parser.add_argument('-f', type=float)
  7. parser.add_argument('--file', type=open)
  9. try:
  10.     print(parser.parse_args())
  11. except IOError as msg:
  12.     parser.error(str(msg))

任何接收一个字符串的可调用对象都可以被传递为 type，包括内建类型比如 int 和 float 甚至 open()。

  1. $ python3 argparse_type.py -i 1
  3. Namespace(f=None, file=None, i=1)
  5. $ python3 argparse_type.py -f 3.14
  7. Namespace(f=3.14, file=None, i=None)
  9. $ python3 argparse_type.py --file argparse_type.py
  11. Namespace(f=None, file=<_io.TextIOWrapper
  12. name='argparse_type.py' mode='r' encoding='UTF-8'>, i=None)

如果类型转换失败，argparser 会抛出一个异常。TypeError 和 ValueError 会被自动捕捉并转换为简单的错误信息提供给用户。其他错误，比如下面例子里输入文件不存在导致的 IOError 必须由调用者处理。

  1. $ python3 argparse_type.py -i a
  3. usage: argparse_type.py [-h] [-i I] [-f F] [--file FILE]
  4. argparse_type.py: error: argument -i: invalid int value: 'a'
  6. $ python3 argparse_type.py -f 3.14.15
  8. usage: argparse_type.py [-h] [-i I] [-f F] [--file FILE]
  9. argparse_type.py: error: argument -f: invalid float value:
  10. '3.14.15'
  12. $ python3 argparse_type.py --file does_not_exist.txt
  14. usage: argparse_type.py [-h] [-i I] [-f F] [--file FILE]
  15. argparse_type.py: error: [Errno 2] No such file or directory:
  16. 'does_not_exist.txt'

要限制参数值为预先定义的一组值，可以使用 choices 参数。

argparse_choices.py

  1. import argparse
  3. parser = argparse.ArgumentParser()
  5. parser.add_argument(
  6.     '--mode',
  7.     choices=('read-only', 'read-write'),
  8. )
  10. print(parser.parse_args())

如果 --mode 的参数值不是允许值之一，程序会抛出错误并停止。

  1. $ python3 argparse_choices.py -h
  3. usage: argparse_choices.py [-h] [--mode {read-only,read-write}]
  5. optional arguments:
  6.   -h, --help            show this help message and exit
  7.   --mode {read-only,read-write}
  9. $ python3 argparse_choices.py --mode read-only
  11. Namespace(mode='read-only')
  13. $ python3 argparse_choices.py --mode invalid
  15. usage: argparse_choices.py [-h] [--mode {read-only,read-write}]
  16. argparse_choices.py: error: argument --mode: invalid choice:
  17. 'invalid' (choose from 'read-only', 'read-write')

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

文件参数##

尽管 file 对象可以通过一个字符串参数实例化，但这个对象没有包含访问模式参数。FileType 提供了一种更灵活的方式来指定一个参数是文件，并且包含了访问模式和缓冲区大小。

argparse_FileType.py

  1. import argparse
  3. parser = argparse.ArgumentParser()
  5. parser.add_argument('-i', metavar='in-file',
  6.                     type=argparse.FileType('rt'))
  7. parser.add_argument('-o', metavar='out-file',
  8.                     type=argparse.FileType('wt'))
  10. try:
  11.     results = parser.parse_args()
  12.     print('Input file:', results.i)
  13.     print('Output file:', results.o)
  14. except IOError as msg:
  15.     parser.error(str(msg))

解析后的参数值是被打开文件的句柄。应用程序要负责不需要文件后关闭文件。

  1. $ python3 argparse_FileType.py -h
  3. usage: argparse_FileType.py [-h] [-i in-file] [-o out-file]
  5. optional arguments:
  6.   -h, --help   show this help message and exit
  7.   -i in-file
  8.   -o out-file
  10. $ python3 argparse_FileType.py -i argparse_FileType.py -o tmp_\
  11. file.txt
  13. Input file: <_io.TextIOWrapper name='argparse_FileType.py'
  14. mode='rt' encoding='UTF-8'>
  15. Output file: <_io.TextIOWrapper name='tmp_file.txt' mode='wt'
  16. encoding='UTF-8'>
  18. $ python3 argparse_FileType.py -i no_such_file.txt
  20. usage: argparse_FileType.py [-h] [-i in-file] [-o out-file]
  21. argparse_FileType.py: error: argument -i: can't open
  22. 'no_such_file.txt': [Errno 2] No such file or directory:
  23. 'no_such_file.txt'

Rookie 翻译于 5个月前
 
由 Summer 审阅
 

定制动作##

除了之前介绍的内建动作，还可以通过提供实现 Action API 的对象来定义自定义动作。传递给 add_argument() 作为 action 的对象应该接受被定义参数的所有参数（也就是传递给 add_argument 的所有参数）并返回一个可调用对象，这个可调用对象接收 parser 作为参数解析器，namespace 持有参数解析结果，value 为参数值，和触发动作的 option_string。

一个 Action 类提供了定义新动作的便捷起点。Action 的构造器会处理参数定义，所以子类只需要重写 __call__()。

argparse_custom_action.py

  1. import argparse
  3. class CustomAction(argparse.Action):
  4.     def __init__(self,
  5.                  option_strings,
  6.                  dest,
  7.                  nargs=None,
  8.                  const=None,
  9.                  default=None,
  10.                  type=None,
  11.                  choices=None,
  12.                  required=False,
  13.                  help=None,
  14.                  metavar=None):
  15.         argparse.Action.__init__(self,
  16.                                  option_strings=option_strings,
  17.                                  dest=dest,
  18.                                  nargs=nargs,
  19.                                  const=const,
  20.                                  default=default,
  21.                                  type=type,
  22.                                  choices=choices,
  23.                                  required=required,
  24.                                  help=help,
  25.                                  metavar=metavar,
  26.                                  )
  27.         print('Initializing CustomAction')
  28.         for name, value in sorted(locals().items()):
  29.             if name == 'self' or value is None:
  30.                 continue
  31.             print('  {} = {!r}'.format(name, value))
  32.         print()
  33.         return
  35.     def __call__(self, parser, namespace, values,
  36.                  option_string=None):
  37.         print('Processing CustomAction for {}'.format(self.dest))
  38.         print('  parser = {}'.format(id(parser)))
  39.         print('  values = {!r}'.format(values))
  40.         print('  option_string = {!r}'.format(option_string))
  42.         # 对输入值做一些处理
  43.         if isinstance(values, list):
  44.             values = [v.upper() for v in values]
  45.         else:
  46.             values = values.upper()
  47.         # 以传递给构造器的目标变量保存结果
  48.         # variable given to our constructor.
  49.         setattr(namespace, self.dest, values)
  50.         print()
  52. parser = argparse.ArgumentParser()
  54. parser.add_argument('-a', action=CustomAction)
  55. parser.add_argument('-m', nargs='*', action=CustomAction)
  57. results = parser.parse_args(['-a', 'value',
  58.                              '-m', 'multivalue',
  59.                              'second'])
  60. print(results)

value 的类型取决于 nargs 的值。如果参数运行多重值，value 将会是一个列表即使它只包含一个元素。

option_string 的值同样决定于原始参数定义。对于位置参数，option_string 一直是 None。

  1. $ python3 argparse_custom_action.py
  3. Initializing CustomAction
  4.   dest = 'a'
  5.   option_strings = ['-a']
  6.   required = False
  8. Initializing CustomAction
  9.   dest = 'm'
  10.   nargs = '*'
  11.   option_strings = ['-m']
  12.   required = False
  14. Processing CustomAction for a
  15.   parser = 4315836992
  16.   values = 'value'
  17.   option_string = '-a'
  19. Processing CustomAction for m
  20.   parser = 4315836992
  21.   values = ['multivalue', 'second']
  22.   option_string = '-m'
  24. Namespace(a='VALUE', m=['MULTIVALUE', 'SECOND'])

另见#

#

(转) argparse — 解析命令参数和选项的更多相关文章

  1. python argparse：命令行参数解析详解

    简介 本文介绍的是argparse模块的基本使用方法,尤其详细介绍add_argument内建方法各个参数的使用及其效果. 本文翻译自argparse的官方说明,并加上一些笔者的理解 import a ...

  2. argparse：命令行参数解析详解

    简介# 本文介绍的是argparse模块的基本使用方法,尤其详细介绍add_argument内建方法各个参数的使用及其效果. 本文翻译自argparse的官方说明,并加上一些笔者的理解 Copy im ...

  3. Python技法：用argparse模块解析命令行选项

    1. 用argparse模块解析命令行选项 我们在上一篇博客<Linux:可执行程序的Shell传参格式规范>中介绍了Linux系统Shell命令行下可执行程序应该遵守的传参规范(包括了各 ...

  4. argparse解析参数模块

    一.简介: argparse是python用于解析命令行参数和选项的标准模块,用于代替已经过时的optparse模块.argparse模块的作用是用于解析命令行参数,例如python parseTes ...

  5. python 解析命令行选项

    问题: 程序如何能够解析命令行选项 解决方案 argparse 模块可被用来解析命令行选项 argparse 模块 argparse 模块是标准库中最大的模块之一,拥有大量的配置选项 dest 参数指 ...

  6. 『Argparse』命令行解析

    一.基本用法 Python标准库推荐使用的命令行解析模块argparse 还有其他两个模块实现这一功能,getopt(等同于C语言中的getopt())和弃用的optparse.因为argparse是 ...

  7. python解析命令行参数

    常常需要解析命令行参数,经常忘记,好烦,总结下来吧. 1.Python 中也可以所用 sys 的 sys.argv 来获取命令行参数: sys.argv 是命令行参数列表 参数个数:len(sys.a ...

  8. Shell 参数(2) --解析命令行参数工具：getopts/getopt

    getopt 与 getopts 都是 Bash 中用来获取与分析命令行参数的工具,常用在 Shell 脚本中被用来分析脚本参数. 两者的比较 (1)getopts 是 Shell 内建命令,geto ...

  9. C语言中使用库函数解析命令行参数

    在编写需要命令行参数的C程序的时候,往往我们需要先解析命令行参数,然后根据这些参数来启动我们的程序. C的库函数中提供了两个函数可以用来帮助我们解析命令行参数:getopt.getopt_long. ...

随机推荐

  1. openstack之flavor管理

    概览 [root@cc07 ~]# nova help | grep flavor flavor-access-add Add flavor access for the given tenant. ...

  2. es6函数的新语法

    函数的默认值 function(x,y=10){ //赋予了y就有了默认值为10,如果y赋值了,就回被覆盖,否则就是默认值10 变量已经有默认值了,所以不用再次用let或者const声明啦 }

  3. jquery取消事件冒泡的三种方法展示

    jquery取消事件冒泡的三种方法展示 html代码 <!doctype html> <html> <head> <meta charset="ut ...

  4. MIT Molecular Biology 笔记6 转录的调控

    视频  https://www.bilibili.com/video/av7973580?from=search&seid=16993146754254492690 教材 Molecular ...

  5. Android学习指南之三十八：Android手势操作编程[转]

    手势操作在我们使用智能设备的过程中奉献了不一样的体验.Android开发中必然会进行手势操作方面的编程.那么它的原理是怎样的呢?我们如何进行手势操作编程呢? 手势操作原理 首先,在Android系统中 ...

  6. 位图bitbucket

    问题:假设有500w条数据,数据是在2^32-1的范围内,数据重复,如何减少内存对数字进行统计呢? 如果用字典来标记数字是否已经统计过来,数字做为key, value仅为0 or1,那么这样需要消耗 ...

  7. C(m,n)算法

    排列组合:C(m,n),m为给定数列,n为要从数列m中取元素的数量,GetResult()获取所有不重复的组合. public class MathCombination<T> { Lis ...

  8. 20145232 韩文浩 《Java程序设计》第8周学习总结

    教材学习内容总结 14 NIO与NIO2 NIO使用频道(channel)来衔接数据节点,对数据区的标记提供了clear(),rewind(),flip(),compact()等高级操作. 想要取得c ...

  9. java类与继承(转载)

    关于java的类与继承面链接是一个网友总结的,还有列子我个人觉得很详细 固拿来收藏,需要的朋友可从这里访问: http://www.cnblogs.com/dolphin0520/p/3803432. ...

  10. Hdu2841 Visible Trees 2017-06-27 22:13 24人阅读 评论(0) 收藏

    Visible Trees Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) To ...