【argparse】模块[综合]——参数配置argparse模块

93 阅读 0 评论 62 点赞

我是靠谱客的博主炙热背包，最近开发中收集的这篇文章主要介绍【argparse】模块[综合]——参数配置argparse模块，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

参考链接：https://my.oschina.net/u/4072026/blog/3033616

argparse模块

一、定义

1.1 定义：argparse是python标准库里面用来处理命令行参数的库
1.2 命令行参数分为位置参数和选项参数：

位置参数就是程序根据该参数出现的位置来确定的
如：[root@openstack_1 /]# ls root/ #其中root/是位置参数
参数是应用程序已经提前定义好的参数，不是随意指定的
如：[root@openstack_1 /]# ls -l # -l 就是ls命令里的一个选项参数

二、使用步骤：

（1）import argparse 首先导入模块
（2）parser = argparse.ArgumentParser（） 创建一个解析器
（3）parser.add_argument() 向该解析器中添加你要关注的命令行参数和选项
（4）parser.parse_args() 进行解析

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--config", type=str, help='configuration file')
# 参数类型为字符串，参数存储的是’参数文件名‘
parser.add_argument("--test", action="store_true", help="test program")
parser.add_argument("--plot", help="plot network graph", action="store_true")
parser.add_argument("--save", action="store_true", help="save model")
args = parser.parse_args()
print(args)

out:Namespace(config=None, plot=False, save=False, test=False)

三、`argparse.ArgumentParser（）`

3.1 函数`argparse.ArgumentParser（）`的参数

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)

prog=None - 程序名
description=None, - help时显示的开始文字
epilog=None, - help时显示的结尾文字
parents=[], -若与其他参数的一些内容一样，可以继承
formatter_class=argparse.HelpFormatter, - 自定义帮助信息的格式
prefix_chars='-', - 命令的前缀，默认是‘-’
fromfile_prefix_chars=None, - 命令行参数从文件中读取
argument_default=None, - 设置一个全局的选项缺省值，一般每个选项单独设置
conflict_handler='error', - 定义两个add_argument中添加的选项名字发生冲突时怎么处理，默认处理是抛出异常
add_help=True - 是否增加-h/–help选项，默认是True)

3.2 类 `class ArgumentParser` 的方法

add_subparsers(self, **kwargs)
convert_arg_line_to_args(self, arg_line)
error(self, message)
exit(self, status=0, message=None) 退出方式
format_help(self)
format_usage(self)
parse_args(self, args=None, namespace=None)命令行参数解析方法
parse_intermixed_args(self, args=None, namespace=None)
parse_known_args(self, args=None, namespace=None)
parse_known_intermixed_args(self, args=None, namespace=None)

3.3 提示

在notebook中传入一个位置参数示例

import argparse
parser = argparse.ArgumentParser(description='命令行中传入一个数字')
parser.add_argument('integers', type=str, help='传入的数字')

对象解析方式一

args = parser.parse_args()
print(args)

out：ipykernel_launcher.py: error: unrecognized arguments: -f不能够识别参量

对象解析方式二

args=parser.parse_known_args()[0]
print(args)

out:Namespace(integers='C:\Users\hp\AppData\Roaming\jupyter\runtime\kernel-d4842032-2222-45eb-b84f-55a35a95cff3.json')解析出正确的参数位置

3.4 `parse_args()`和`parse_known_args()`的区别

参考链接：https://blog.csdn.net/qyhaill/article/details/102615164

可以看出parse_args()函数返回的是一个命名空间（NameSpace），这个NameSpace中有一些变量，就是我们add_argument()的那些参数。
可以看出parse_known_args()返回的是一个有两个元素的元组，第一个元素是NameSpace，和parge_args()返回的NameSpace完全相同，第二个是一个空列表.当在命令比add_argument()的多了一个参数，但是并没有报错。命令行中多的参数以空格为分节符，以字符串的形式存放在列表中

3. 5 `add_argument()`方法参数

add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])

name or flags：指定参数的形式，想写几个写几个，不过我们一般就写两个，一个短参数一个长参数，例如 ”-f”, “–file”；
action：命令行遇到参数时的动作，默认值是 store；
nargs ：指定这个参数后面的value有多少个；
const ： action 和 nargs 所需要的常量值；
default ：不指定参数时的默认值；
type ：命令行参数应该被转换成的类型；
choices ：参数可允许的值的一个容器；
required ：可选参数是否可以省略 (仅针对可选参数)；
help ：参数的帮助信息，当指定为 argparse.SUPPRESS 时表示不显示该参数的帮助信息；
metavar ：在 usage 说明中的参数名称，对于必选参数默认就是参数名称，对于可选参数默认是全大写的参数名称；
dest ：解析后的参数名称，默认情况下，对于可选参数选取最长的名称，中划线转换为下划线；

详细解释：

action 表示值赋予键的方式，这里用到的是bool类型，action意思是当读取的参数中出现指定参数的时候的行为
required - 必需参数，通常-f这样的选项是可选的，但是如果required=True那么就是必须的了
required标签就是说–ver参数是必需的，并且类型为int，输入其它类型会报错
parser.add_argument('--ver', '-v', required = True, type = int)
choices - 设置参数的范围，如果choice中的类型不是字符串，要指定type.表示该参数能接受的值只能来自某几个值候选值中，除此之外会报错，用choice参数即可

parser.add_argument('file', choices = ['test1', 'test2'])
args = parser.parse_args()
print('read in %s'%(args.file))

nargs - 指定这个参数后面的value有多少个，默认为1

# 表示脚本可以读入两个整数赋予num键（此时的值为2个整数的数组）
parser.add_argument('filename', nargs = 2, type = int)
args = parser.parse_args()
print('read in %s'%(args.filename))

分析：nargs还可以’*‘用来表示如果有该位置参数输入的话，之后所有的输入都将作为该位置参数的值；‘+’表示读取至少1个该位置参数。’?'表示该位置参数要么没有，要么就只要一个。（PS：跟正则表达式的符号用途一致。）

parser.add_argument('filename', nargs = '+', type = int)
args = parser.parse_args()
print('read in %s'%(args.filename))

dest - 设置这个选项的value解析出来后放到哪个属性中

parser.add_argument('-file', choices = ['test1', 'test2'], dest = 'world')
args = parser.parse_args()
print('read in %s'%(args.world))

四、`命令提示符`·传参`cm`

4.1 建立python文件

位置：C:Usershpanaconda3python.exe C:/Users/hp/Desktop/propycharm/venv/1019.py
内容：

import argparse
parser = argparse.ArgumentParser(description='姓名')
parser.add_argument('param1', type=str,help='姓')
parser.add_argument('param2', type=str,help='名')
args = parser.parse_args()
#打印姓名
print(args.param1+args.param2)

4.2 打开`cm`

定位.py所在的文件夹cd Desktop/propycharm/venv
打开文件并查看信息python 1019.py -h 一定要加python，不是直接写文件名,结果为：

usage: 1019.py [-h] param1 param2
姓名
positional arguments:
param1
姓
param2
名
optional arguments:
-h, --help
show this help message and exit

传入参数python 1019.py 张三

定位到python 1019.py 后空一格
传入2个参数，两个参数中间用空格隔开
在help中提示到，这两个参数都是位置参数

五、参数变量的`cm`传参

5.1位置参数对应一个值

python 文件位置同上，内容如下：

import argparse
parser = argparse.ArgumentParser(description='命令行中传入一个数字')
#type是要传入的参数的数据类型
help是该参数的提示信息
parser.add_argument('integers', type=str, help='传入的数字')
args = parser.parse_args()
#获得传入的参数
print(args)

cm中查看参量的命令为：python 1019.py -h
结果为：

命令行中传入一个数字
positional arguments:
integers
传入的数字
optional arguments:
-h, --help
show this help message and exit

cm中传入一个参数：python 1019.py 5
结果为：Namespace(integers='5')

5.2 位置参数对应多个值

当下对同一个文件1019.py,内容不改的话，在cm中输入:python 1019.py 1 2 3 4,注意到，多个值之间用空格隔开的,运行报错为：

usage: 1019.py [-h] integers
1019.py: error: unrecognized arguments: 2 3 4

分析：不能识别2 3 4，看源代码我们知道integers这个参数是位置参数，说明第一个数1是能识别。这里我们需要重新更改1019.py 的代码

改内容

import argparse
parser = argparse.ArgumentParser(description='命令行中传入一个数字')
parser.add_argument('integers', type=str, nargs='+',help='传入的数字')
args = parser.parse_args()
print(args.integers)

cm传多值：python 1019.py 1 2 3 4
结果为：['1', '2', '3', '4']
分析：nargs是用来说明传入的参数个数，’+’ 表示传入至少一个参数。

5.3 位置参数的特点

1019.py 的位置不变，内容改为：

import argparse
parser = argparse.ArgumentParser(description='姓名')
parser.add_argument('param1', type=str,help='姓')
parser.add_argument('param2', type=str,help='名')
args = parser.parse_args()
#打印姓名
print(args.param1+args.param2)

假设 cm 传参的顺序不同时

在命令行中分别输入python demo.py 张三和python demo.py 三张，得到的运行结果分别为
张三和三张
在python内容中修改参数的添加顺序，即第三行和第四行互换。在命令行中输入python demo.py 张三结果为三张

因此，位置参数的的传入与顺序相关，顺序错了，则参数的值就会传错。

5.4 可选参数

为了在命令行中避免上述位置参数的bug（容易忘了顺序），可以使用可选参数，这个有点像关键词传参，但是需要在关键词前面加--，例如

import argparse
parser = argparse.ArgumentParser(description='姓名')
parser.add_argument('--family', type=str,help='姓')
parser.add_argument('--name', type=str,help='名')
args = parser.parse_args()
#打印姓名
print(args.family+args.name)

cm中传参：python 1019.py --name=三 --family=张
out:张三
解析：可选参数虽然写法比较繁琐，但是增加了命令行中的可读性，不容易因为参数传入顺序导致数据错乱。

5.5 传参中的默认值

`add_argument中有一个default参数``有的时候需要对某个参数设置默认值，即如果命令行中没有传入该参数的值，程序使用默认值。如果命令行传入该参数，则程序使用传入的值。具体请看下面的例子

import argparse
parser = argparse.ArgumentParser(description='姓名')
parser.add_argument('--family', type=str, default='张',help='姓')
parser.add_argument('--name', type=str, default='三', help='名')
args = parser.parse_args()
#打印姓名
print(args.family+args.name)

在命令行中输:入 python demo.py,结果为：张三
在命令行中输入： python demo.py --family=李 ，结果为：李三

5.6 传参中的必须参数

add_argument有一个required参数可以设置该参数是否必需。

import argparse
parser = argparse.ArgumentParser(description='姓名')
parser.add_argument('--family', type=str, help='姓')
parser.add_argument('--name', type=str, required=True, default='', help='名')
args = parser.parse_args()
#打印姓名
print(args.family+args.name)

在命令行中输入 python demo.py --family=张，运行结果

usage: demo.py [-h] [--family FAMILY] --name NAME
demo.py: error: the following arguments are required: --name

因为可选参数name的required=True，所以必须要传入。如果我们将其更改为False，程序运行结果

张

六、parse_args的传参

6.1 空格隔开

-的可选参数

import argparse
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('-x')
parser.add_argument('--foo')
opt=parser.parse_args('-x X'.split())
print(opt)

out:Namespace(foo=None, x='X')

--的可选参数

import argparse
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('-x')
parser.add_argument('--foo')
opt=parser.parse_args('-x X'.split())
opt=parser.parse_args('--foo Foo'.split())
print(opt)

同时解析多个参数

import argparse
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('-x')
parser.add_argument('--foo')
opt=parser.parse_args('--foo Foo -x X'.split())
print(opt)

提示

短参，长参都可以用空格传参
parse_args多次用时，只保留最后一次
可以同时传递多个参数变量的值

6.2 长项可以用`=`分开

 parser.parse_args('--foo=FOO'.split())

out:Namespace(foo='FOO', x=None)

6.3 短项可以写在一起

parser.parse_args('-xX'.split())

out:Namespace(foo=None, x='X')

七、parser.parse_args()字典

7.1 `args.参数名`

在5.1中得到的结果Namespace(integers='5')是一种类似于python字典的数据类型。

使用 parser.parse_args().参数名来提取这个参数

import argparse
parser = argparse.ArgumentParser(description='命令行中传入一个数字')
#type是要传入的参数的数据类型
help是该参数的提示信息
parser.add_argument('integers', type=str, help='传入的数字')
args = parser.parse_args()
#获得integers参数
print(args.integers)

在命令行中运行 python demo.py 5 , 运行结果为5

7.2 `parse_args`的返回值化字典

parse_args()方法的返回值为namespace，可以用vars()内建函数化为字典：

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

out:{'foo': 'BAR'}

附录1：ArgumentParser（）详解

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)

这些参数都有默认值，当调用parser.print_help()或者运行程序时由于参数不正确(此时python解释器其实也是调用了pring_help()方法)时，会打印这些描述信息，一般只需要传递description参数，如上。

prog

程序的名字，默认为sys.argv[0]，用来在help信息中描述程序的名称。

>>> parser = argparse.ArgumentParser(prog='myprogram')
>>> parser.print_help()
usage: myprogram [-h]
optional arguments:
-h, --help
show this help message and exit

usage

描述程序用途的字符串

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

description

help信息前的文字。

epilog

help信息之后的信息

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

parents

由ArgumentParser对象组成的列表，它们的arguments选项会被包含到新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)

formatter_class

help信息输出的格式.

prefix_chars

参数前缀，默认为’-’

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

fromfile_prefix_chars

前缀字符，放在文件名之前

>>> with open('args.txt', 'w') as fp:
...
fp.write('-fnbar')
>>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')
>>> parser.add_argument('-f')
>>> parser.parse_args(['-f', 'foo', '@args.txt'])
Namespace(f='bar')

当参数过多时，可以将参数放到文件中读取，例子中parser.parse_args([’-f’, ‘foo’, ‘@args.txt’])解析时会从文件args.txt读取，相当于 [’-f’, ‘foo’, ‘-f’, ‘bar’]。

argument_default

参数的全局默认值。例如，要禁止parse_args时的参数默认添加，我们可以：

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

当parser.parse_args()时不会自动解析foo和bar了。

conflict_handler

解决冲突的策略，默认情况下冲突会发生错误：

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

我们可以设定冲突解决策略：

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

add_help

设为False时，help信息里面不再显示-h --help信息。

附录2：方法add_argument 参数详解

add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])
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)')

name or flags

命令行参数名或者选项，如上面的address或者-p,–port.其中命令行参数如果没给定，且没有设置defualt，则出错。但是如果是选项的话，则设置为None,如果是多个参数(短参数和长参数)表示同一个意义的话,可用,隔开

一共有两种,位置参数和可选参数.

添加可选参数:

>>> 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: too few arguments

action

默认为store

store_const，值存放在const中：

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action='store_const', const=42)
>>> parser.parse_args('--foo'.split())
Namespace(foo=42)

store_true和store_false，值存为True或False:

>>> 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(bar=False, baz=True, foo=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关键参数进行添加：

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

count：统计参数出现的次数

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--verbose', '-v', action='count')
>>> parser.parse_args('-vvv'.split())
Namespace(verbose=3)

version：版本

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

nargs

命令行参数的个数，一般使用通配符表示，其中，’?‘表示只用一个，’*‘表示0到多个，’+'表示至少一个

值可以为整数N(N个)，*(任意多个)，+(一个或更多)

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

值为？时，首先从命令行获得参数，若没有则从const获得，然后从default获得：

>>> 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'.split())
Namespace(bar='XX', foo='YY')
>>> parser.parse_args('XX --foo'.split())
Namespace(bar='XX', foo='c')
>>> parser.parse_args(''.split())
Namespace(bar='d', foo='d')

获取参数顺序:命令行–>const–>default

更常用的情况是允许参数为文件:

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

const

保存一个常量

default

默认值,上面刚介绍过

choices

可供选择的值

>>> parser = argparse.ArgumentParser(prog='doors.py')
>>> parser.add_argument('door', type=int, choices=range(1, 4))
>>> print(parser.parse_args(['3']))
Namespace(door=3)
>>> parser.parse_args(['4'])
usage: doors.py [-h] {1,2,3}
doors.py: error: argument door: invalid choice: 4 (choose from 1, 2, 3)

type

参数的类型，默认是字符串string类型，还有float、int等类型

required

是否必选

desk

可作为参数名

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', dest='bar')
>>> parser.parse_args('--foo XXX'.split())
Namespace(bar='XXX')

help

和ArgumentParser方法中的参数作用相似，出现的场合也一致

最后

以上就是炙热背包为你收集整理的【argparse】模块[综合]——参数配置argparse模块的全部内容，希望文章能够帮你解决【argparse】模块[综合]——参数配置argparse模块所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：# python 模块
浏览次数：93 次浏览
发布日期：2024-01-03 04:55:22
本文链接：https://www.kaopuke.com/article/k-p-k_13_u_23_ocf3_14__7__10_4.html