Python命令行插件ArgumentParser

最新推荐文章于 2024-03-11 21:36:27 发布

tmccmt

最新推荐文章于 2024-03-11 21:36:27 发布

阅读量1.7k

点赞数 2

分类专栏： python 文章标签： python linux

本文链接：https://blog.csdn.net/weixin_44856211/article/details/124454218

版权

python 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

ArgumentParser使用介绍

1. 介绍

argparse是python用于解析命令行参数和选项的标准模块，用于代替已经过时的optparse模块。argparse模块的作用是用于解析命令行参数。很多时候，需要用到解析命令行参数的程序。

2. 使用步骤

常常可以把argparse的使用简化成下面四个步骤

import argparse

# 创建解析对象
parser = argparse.ArgumentParser()
# 添加命令行参数和选项，每一个add_argument方法对应一个参数或选项
parser.add_argument()
# 调用parse_args()方法进行解析；解析成功之后即可使用
parser.parse_args()

3. 例子

import argparse


def main():
    
    description = "you should add those parameter"
    parser = argparse.ArgumentParser(prog="argparse-test", description=description)
    help = "the path of address"
    parser.add_argument('--addresses', help=help)
    args_ = parser.parse_args()
    return args_


if __name__ == '__main__':
    args = main()
    # 参数解析完成后，可以直接通过args.addresses的草参数值，
    # 亦可以通过vars(args_)或者args_.__dict__转换成dict进行取值
    print(args.addresses)

4. 参数详解

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

prog : 程序的名称（默认：sys.argv[0]）
usage: 描述程序用途的字符串（默认值：从添加到解析器的参数生成）
description: 在参数帮助文档之前显示的文本（默认值：无）
epilog: 在参数帮助文档之后显示的文本（默认值：无）
parents: 一个ArgumentParser对象的列表，它们的参数也应包含在内
formatter_class: 用于自定义帮助文档输出格式的类
prefix_chars: 可选参数的前缀字符集合（默认值：’-’），若更改则对应选项前的字符也许修改，传参也修改
fromfile_prefix_chars: 当需要从文件中读取其他参数时，用于标识文件名的前缀字符集合（默认值：None）
argument_default: 参数的全局默认值（默认值： None）
conflict_handler: 解决冲突选项的策略（通常是不必要的）
add_help: 为解析器添加一个 -h/–help 选项（默认值： True）
allow_abbrev: 如果缩写是无歧义的，则允许缩写长选项（默认值：True）

4.2 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: 在使用方法消息中使用的参数值示例
dest: 被添加到 parse_args() 所返回对象上的属性名

4.2.1 add_argument() 参数的详细介绍

4.2.1.1 name or flags 参数

选项名称，如果直接写名称是一个必填参数；如果是 flags 就要带上 - 或者 –

import argparse


def main():
    parser = argparse.ArgumentParser(prog="argparse-test",
                                     epilog=epilog,
                                     description="you should add those parameter")
    # 此处--address，并且无required=True条件，表示address参数为非必传参数；若required=True，则必传参数（与address效果类似）
    # 此处若为address，则表示参数为必传参数
    parser.add_argument('--address',
                        help="the path of address")
    args_ = parser.parse_args()
    return args_


if __name__ == '__main__':
    args = main()
    print(args.address)

4.2.1.1.1 name

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('add')
_StoreAction(option_strings=[], dest='add', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>>
# 若选项名称前未加--标志，则是一个必传参数（位置参数），且使用命令行执行时候，无需进行写前缀
>>> parser.parse_args('text'.split())
Namespace(add='text')
>>>
>>> parser.parse_args('add text'.split())
usage: [-h] add
: error: unrecognized arguments: text

4.2.1.1.2 flags

>>> import argparse
>>> parser = argparse.ArgumentParser()
# 添加- 或者 -- 效果一致，-即为简写；同时默认都不是必传参数（可选参数），添加required=True则变为必传参数
>>> parser.add_argument('-a', '--add')
_StoreAction(option_strings=['-a', '--add'], dest='add', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.parse_args('-a text'.split())
Namespace(add='text')
>>> parser.parse_args('--add text'.split())
Namespace(add='text')
>>> parser.parse_args(''.split())
Namespace(add=None)

4.2.2.2 action 参数

4.2.2.2.1 store

# 'store'：只是保存参数的值。这是默认的动作
>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--address')
_StoreAction(option_strings=['--address'], dest='address', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.parse_args('--address 1'.split())
Namespace(address='1')

4.2.2.2.2 store_const

# 'store_const'：保存由const关键字参数指出的值（const关键字参数默认是None。）
# 'store_const'最常用于指定某种标记的可选参数

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--address', action='store_const', const=23)
_StoreConstAction(option_strings=['--address'], dest='address', nargs=0, const=23, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.parse_args('--address'.split())
Namespace(address=23)

4.2.2.2.3 store_true/store_false

# 'store_true'和'store_false'：是'store_const' 的特殊情形，分别用于保存值True和False。且分别会创建默认值False 和True。

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--add1', action='store_true')
_StoreTrueAction(option_strings=['--add1'], dest='add1', nargs=0, const=True, default=False, type=None, choices=None, help=None, metavar=None)
>>> parser.add_argument('--add2', action='store_false')
_StoreFalseAction(option_strings=['--add2'], dest='add2', nargs=0, const=False, default=True, type=None, choices=None, help=None, metavar=None)
>>> parser.add_argument('--add3', action='store_false')
_StoreFalseAction(option_strings=['--add3'], dest='add3', nargs=0, const=False, default=True, type=None, choices=None, help=None, metavar=None)
>>> parser.parse_args('--add1 --add2'.split())
Namespace(add1=True, add2=False, add3=True)

4.2.2.2.4 append

# 'append'：保存一个列表，并将每个参数值附加在列表的后面。这对于允许指定多次的选项很有帮助。

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--add', action='append')
_AppendAction(option_strings=['--add'], dest='add', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.parse_args('--add 1 --add 2 --add 3'.split())
Namespace(add=['1', '2', '3'])

4.2.2.2.5 append_const

# 'append_const'：保存一个列表，并将const关键字参数指出的值附加在列表的后面。（const关键字参数默认是None。）
# 'append_const' 在多个参数需要保存常量到相同的列表时特别有用。

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

4.2.2.2.6 count

# 'count'：计算关键字参数出现的次数。可用于增加详细的级别

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--add', '-a', action='count')
>>> parser.parse_args('-aaa'.split())
Namespace(verbose=3)

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--add', action='count')
_CountAction(option_strings=['--add'], dest='add', nargs=0, const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.parse_args('--add --add'.split())
Namespace(add=2)

4.2.2.2.7 help

4.2.2.2.8 version

4.2.2.4 nargs 参数

ArgumentParser对象通常将一个动作与一个命令行参数关联。nargs关键字参数将一个动作与不同数目的命令行参数关联在一起

4.2.2.4.1 N

# 命令行中的N个参数将被一起收集在一个列表中

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('add1', nargs=1)
_StoreAction(option_strings=[], dest='add1', nargs=1, const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.add_argument('--add2', nargs=2)
_StoreAction(option_strings=['--add2'], dest='add2', nargs=2, const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.parse_args('ha --add2 ha1 ha2'.split())
Namespace(add1=['ha'], add2=['ha1', 'ha2'])

4.2.2.4.2 ?

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('add1', nargs='?', default='ha', const='he')
_StoreAction(option_strings=[], dest='add1', nargs='?', const='he', default='ha', type=None, choices=None, help=None, metavar=None)
>>> parser.add_argument('--add2', nargs='?', default='ha2', const='he2')
_StoreAction(option_strings=['--add2'], dest='add2', nargs='?', const='he2', default='ha2', type=None, choices=None, help=None, metavar=None)
# 有参数从命令行读取一个参数并生成一个元素
>>> parser.parse_args('ax --add2 qwe'.split())
Namespace(add1='ax', add2='qwe')
# 如果没有对应的命令行参数，则产生一个来自default的值
>>> parser.parse_args(''.split())
Namespace(add1='ha', add2='ha2')
# 注意，对于可选参数，有选项字符串但是后面没有跟随命令行参数。在这种情况下，将生成一个来自const的值。
>>> parser.parse_args('ax --add2'.split())
Namespace(add1='ax', add2='he2')


# 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=<open file 'input.txt', mode 'r' at 0x...>,
          outfile=<open file 'output.txt', mode 'w' at 0x...>)
>>> parser.parse_args([])
Namespace(infile=<open file '<stdin>', mode 'r' at 0x...>,
          outfile=<open file '<stdout>', mode 'w' at 0x...>)

4.2.2.4.3 *

# 出现的所有命令行参数都被收集到一个列表中。注意，一般情况下具有多个带有nargs='*'的位置参数是不合理的，但是多个带有nargs='*'的可选参数是可能的。
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('add1', nargs='*')
_StoreAction(option_strings=[], dest='add1', nargs='*', const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.add_argument('--add2', nargs='*')
_StoreAction(option_strings=['--add2'], dest='add2', nargs='*', const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.parse_args('ax1 ax2 --add2 qwe1 qwe2'.split())
Namespace(add1=['ax1', 'ax2'], add2=['qwe1', 'qwe2'])

4.2.2.4.3 +

# '+'。和'*'一样，出现的所有命令行参数都被收集到一个列表中。除此之外，如果没有至少出现一个命令行参数将会产生一个错误信息
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--add2', nargs='+')
_StoreAction(option_strings=[], dest='--add2', nargs='+', const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.parse_args('--add2 qwe2'.split())
Namespace(add2=['qwe2'])
>>>
>>> parser.parse_args('--add2'.split())
usage: [-h] [--add2 ADD2 [ADD2 ...]]
: error: argument --add2: expected at least one argument

4.2.2.4.4 argparse.REMAINDER

# 所有剩余的命令行参数都被收集到一个列表中。这通常用于命令行工具分发命令到其它命令行工具
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--add2')
_StoreAction(option_strings=['--add2'], dest='add2', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.add_argument('add1')
_StoreAction(option_strings=[], dest='add1', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.add_argument('args', nargs=argparse.REMAINDER)
_StoreAction(option_strings=[], dest='args', nargs='...', const=None, default=None, type=None, choices=None, help=None, metavar=None)
# 此种情况需要将位置参数写在可选参数后才会生效
>>> parser.parse_args('ax --add2 qwe1 --add3 iuer bjkh'.split())
Namespace(add1='ax', add2=None, args=['--add2', 'qwe1', '--add3', 'iuer', 'bjkh'])
>>>
>>> parser.parse_args('--add2 qwe1 abc --add3 iuer bjkh'.split())
Namespace(add1='abc', add2='qwe1', args=['--add3', 'iuer', 'bjkh'])

4.2.2.5 const 参数

# const 参数在某些特定的action会被使用（详见action参数讲解），
# 另外nargs是 '?' 的时候会优先使用const里面的值

4.2.2.6 default 参数

# default的值用于选项字符串没有出现在命令行中的时候

4.2.2.7 type 参数

# 设置传入参数要求的类型

4.2.2.8 choices 参数

4.2.2.9 require 参数

# 有此参数，如果传入的时候没有将报出一个错误
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--add', required=True)
_StoreAction(option_strings=['--add'], dest='add', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>> parser.parse_args('--add ha'.split())
Namespace(add='ha')
>>> parser.parse_args('--add'.split())
usage: [-h] --add ADD
: error: argument --add: expected one argument

4.2.2.10 help 参数

# 填写该参数背后的一些帮助信息

4.2.2.11 metavar

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument(add1", help="位置参数"))
_StoreAction(option_strings=[], dest='add1', nargs=None, const=None, default=None, type=None, choices=None, help='\xe4\xbd\x8d\xe7\xbd\xae\xe5\x8f\x82\xe6\x95\xb0', metavar=None)
>>> parser.add_argument("--add2", help="可选参数")
_StoreAction(option_strings=['--add2'], dest='add2', nargs=None, const=None, default=None, type=None, choices=None, help='\xe5\x8f\xaf\xe9\x80\x89\xe5\x8f\x82\xe6\x95\xb0', metavar=None)

# 当未添加metavar时，当显示help信息时候，默认会显示选项的大写，再现help内容
>>> parser.print_help()
usage: [-h] [--add2 ADD2] add1

positional arguments:
  add1         位置参数

optional arguments:
  -h, --help   show this help message and exit
  --add2 ADD2  可选参数


>>> parser = argparse.ArgumentParser()
>>> parser.add_argument("add1", metavar="the address one", help="位置参数")
_StoreAction(option_strings=[], dest='add1', nargs=None, const=None, default=None, type=None, choices=None, help='\xe4\xbd\x8d\xe7\xbd\xae\xe5\x8f\x82\xe6\x95\xb0', metavar='the address one')
>>> parser.add_argument("--add2", metavar="the address two",help="可选参数")
_StoreAction(option_strings=['--add2'], dest='add2', nargs=None, const=None, default=None, type=None, choices=None, help='\xe5\x8f\xaf\xe9\x80\x89\xe5\x8f\x82\xe6\x95\xb0', metavar='the address two')
>>>
# 当添加metavar时，当显示help信息时候，会显metavar内容，再现help内容（注意metavar只会改变显示出来的名字）
>>> parser.print_help()
usage: [-h] [--add2 the address two] the address one

positional arguments:
  the address one       位置参数

optional arguments:
  -h, --help            show this help message and exit
  --add2 the address two
                        可选参数

4.2.2.12 dest 参数

ArgumentParser()给parse_args()返回对象的某个属性添加某些值。该属性的名字由add_argument()的dest关键字参数决定

# 对于位置参数的动作，dest 通常作为第一个参数提供给add_argument()
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('bar')
>>> parser.parse_args('XXX'.split())
Namespace(bar='XXX')

# 对于可选参数的动作，dest的动作通常从选项字符串推导出来。
# ArgumentParser生成的dest的值是将第一长的选项字符串前面的--字符串去掉
# 如果没有提供长选项字符串，dest的获得则是将第一个短选项字符串前面的-字符去掉。任何内部的-将被转换为字符 _ 以确保字符串是合法的属性名字

# 自定义dest值
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument("--add2",dest="dc")
_StoreAction(option_strings=['--add2'], dest='dc', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)
>>>
>>> parser.parse_args('--add adccc'.split())
Namespace(dc='adccc')