Python语法学习记录（8）：argparse的用法

PYTHON中argparse的用法

文章目录

PYTHON中argparse的用法

文章目录

基础语法

argparse.ArgumentParser()

add_argument()

创建 ArgumentParser() 对象

调用 add_argument() 方法添加参数

使用 parse_args() 解析添加的参数

import argparse
# 创建 ArgumentParser() 对象
parser = argparse.ArgumentParser()
# 调用 add_argument() 方法添加参数
parser.add_argument("a")
# 使用 parse_args() 解析添加的参数
args = parser.parse_args()
# 可以打印出最终存储的参数空间属性
print(args)
# 打印参数空间中的变量
pring(args.a)
# 打印针对这个添加参数模块的使用方法
parser.print_usage()
# 打印针对这个添加参数模块的使用帮助说明（此处会打印出使用方法）
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

image-20200915144348712

备注之后所有的变量输入我们都有如下方式进行

args = parser.parse_args(''.split())
  • 1

不同参数的输入

定位参数

一定要输入不是可选项 按照固定的顺序一个一个填入下面所属的变量

import argparse
parser = argparse.ArgumentParser()

parser.add_argument("a")# 获取的是字符串
parser.add_argument("b", type=int, help='display an integer')#获取的是数字

args = parser.parse_args('100 200'.split())
print(args)
print(args.a)#可以进行变量的引用
print(args.b)
parser.print_usage()
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

image-20200915144323976

可选参数

所谓可选参数，也就是命令行参数是可选的 可以不输入

一般-后面跟缺省变量名字，–后面跟完整变量名字。

同时出现多个变量的名字命名时候如下的efgh情况分析：

1存储在哪个变量名下预输入的时候选取哪种方式无关 见efh

2同时出现-和–时候 输入存储在–变量名后面（与变量名字长短无关）见ef

3仅同时出现两个-时存储在变量名较长的后面 见g

4仅同时出现两个–时存储在变量名较长的后面 见i

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-b",type=int)
parser.add_argument("--c",type=int)
#可选参数在输入过程中没有输入时候，自动赋值为None
parser.add_argument("-d",type=int)

parser.add_argument("-e", "--eee",type=int)#不论输入存在eee
parser.add_argument("-fff", "--f",type=int)#不论输入存在f
parser.add_argument("-ggg", "-g",type=int)#不论输入存在ggg
parser.add_argument("-hhh", "--h",type=int)#不论输入存在h
parser.add_argument("--iii", "--i",type=int)#不论输入存在iii

args = parser.parse_args('-b 100 --c 200  -e 400 -fff 500 -g 600 --h 700 --i 800'.split())
print(args)# Namespace中有变量名的信息
parser.print_usage()
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

image-20200915144648457

混合使用

定位参数和选项参数可以混合使用

定位参数按照顺序输入即可 可选参数会自动选择赋值进去1

import argparse
parser = argparse.ArgumentParser()

parser.add_argument('x')
parser.add_argument('-y')
parser.add_argument('-z')
args = parser.parse_args('-y 200 100'.split())
print(args)
parser.print_usage()
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

image-20200915144707510

定位参数和选项参数可以混合使用，看下面一个例子，给一个整数序列，输出它们的和或最大值（默认）：

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('integers', metavar='N', type=int, nargs='+',help='an integer for the accumulator')
parser.add_argument('--sum', dest='function', action='store_const',const=sum, default=max,help='sum the integers (default: find the max)')
x = parser.parse_args('1 2 3 4 5 --sum'.split())
print(x)
print(x.function(x.integers))
x = parser.parse_args('1 2 3 4 5'.split())
print(x)
print(x.function(x.integers))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

image-20200915144724331

add_argument参数输入的选项

name or flags

选项字符串的名字或者列表，例如 a 或者 -f, --fff

action

命令行遇到参数时的动作

store

action的默认值

只是保存参数的值。这是默认的动作。

可选参数不输入的时候默认保存None

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('storetest1')
parser.add_argument('-storetest2')
parser.add_argument('-storetest3')
args = parser.parse_args('100 -storetest2 200'.split())
print(args)
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

image-20200915144744156

store_const

表示赋值为const

保存由const关键字参数指出的值。（注意const关键字参数默认是几乎没有帮助的None。）此动作最常用于指定某种标记的可选参数。（一般不用于定位参数）

有这一项就会吧const里面的值存储在变量里面 如果没有 那么变量就是None

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('test1', action='store_const', const=42)
parser.add_argument('-test2', action='store_const', const=42)
parser.add_argument('-test3', action='store_const', const=42)
args = parser.parse_args('-test2'.split())
print(args)
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

image-20200915144801729

store_true和store_false

它们是’store_const’ 的特殊情形，分别用于保存值True和False。另外，它们分别会创建默认值False 和True。#无输入的时候就是一个相反的初始值

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-test1', action='store_true')
parser.add_argument('-test2', action='store_false')
parser.add_argument('-test3', action='store_false')
args = parser.parse_args('-test1 -test2'.split())
print(args)
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

image-20200915144818194

append

将遇到的值存储成列表，也就是如果参数重复则会保存多个值。保存一个列表，并将每个参数值附加在列表的后面。这对于允许指定多次的选项很有帮助。

import argparse
parser = argparse.ArgumentParser()

parser.add_argument('-test',type = int ,action='append')
args = parser.parse_args('-test 1 -test 2'.split())
print(args)
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

image-20200915144831652

append_const

将参数规范中定义的一个值保存到一个列表；保存一个列表，并将const关键字参数指出的值附加在列表的后面。（注意const关键字参数默认None。）

append_const动作在多个参数需要保存常量到相同的列表时特别有用。需要指定目标列表

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--str', dest='types1', action='append_const', const=str)
parser.add_argument('--int', dest='types1', action='append_const', const=int)
parser.add_argument('--float', dest='types2', action='append_const', const=float)
args = parser.parse_args('--str --int --float'.split())
print(args)
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

image-20200915144844131

count

存储遇到的次数；此外，也可以继承 argparse.Action 自定义参数解析；这可用于增加详细的级别

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--verbose', '-v', action='count')
args = parser.parse_args('-v -v -v -v --verbose'.split())
print(args)
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

image-20200915144905005

version

期待version=参数出现在add_argument()调用中，在调用时打印出版本信息并退出

import argpars
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('--version', action='version', version='%(prog)s =2.0')
args = parser.parse_args('--version'.split())
  • 1
  • 2
  • 3
  • 4

image-20200915144917719

nargs

如果没有提供nargs关键字参数，读取的参数个数取决于action。

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

这个入参可以设置一个 参数后面可以接收几个值，而且提供了类似于正则的符号来通配一些行为。

应该读取的命令行参数个数，可以是具体的数字，或者是?号，当不指定值时对于 Positional argument 使用 default，对于 Optional argument 使用 const；或者是 * 号，表示 0 或多个参数；或者是 + 号表示 1 或多个参数。

nargs = N

N（一个整数）。命令行中的N个参数将被一起收集在一个列表中。

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs=5)
parser.add_argument('bar', nargs=1)
x = parser.parse_args('--foo a b c a b c'.split()) #自动分配的感觉
print(x)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

image-20200915144931979

注意nargs=1生成一个只有一个元素的列表。这和默认的行为是不一样的，默认情况下生成的是元素自己。

nargs=’?’

如果有的话就从命令行读取一个参数并生成一个元素。如果没有对应的命令行参数，则产生一个来自default的值。注意，对于可选参数，有另外一种情况 - 有选项字符串但是后面没有跟随命令行参数。在这种情况下，将生成一个来自const的值。用一些例子加以解释：

有可选参数 时候使用输入的值

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-test1', nargs='?', const='c', default='d')
parser.add_argument('test2', nargs='?', default='d')
args = parser.parse_args('XX -test1 YY'.split())#有可选参数 时候使用输入的值
print(args)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

image-20200915144946802

只输入可选参数 没有输入参数值的时候 使用存储的常量

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-test1', nargs='?', const='c', default='d')
parser.add_argument('test2', nargs='?', default='d')
args = parser.parse_args('XX -test1'.split()) #只输入可选参数 没有输入参数值的时候 使用存储的常量
print(args)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

image-20200915145002477

针对必选参数 没有输入参数值的时候 使用存储的常量 输入的时候使用输入的值

针对可选参数 没有输入可选参数 使用的是默认值

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-test1', nargs='?', const='c', default='d')
parser.add_argument('test2', nargs='?', default='d')
args = parser.parse_args(''.split()) #没有输入可选参数 使用的是默认值
print(args)#针对必选参数 没有输入参数值的时候 使用存储的常量  输入的时候使用输入的值
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

image-20200915145014075

nargs=’?'的一种更常见的用法是允许可选的输入和输出文件：

import argparse
import sys
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)
args = parser.parse_args(['input.txt', 'output.txt'])   # 输入即为'input.txt output.txt'.split()
print(args)
print(args.infile)
print(args.outfile)
args = parser.parse_args([])
print(args)
print(args.infile)
print(args.outfile)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

image-20200915145035185

nargs=’*’

出现的所有命令行参数都被收集到一个列表中。

注意，一般情况下具有多个带有nargs=’*'的位置参数是不合理的，

但是多个带有nargs=’*'的可选参数是可能的。

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-test1', nargs='*')
parser.add_argument('-test2', nargs='*')
parser.add_argument('test3', nargs='*')
args = parser.parse_args('a b -test1 x y'.split())
print(args)
args = parser.parse_args(' -test1 x y -test2 1 2 3'.split())
print(args)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

image-20200915145055097

nargs=’+’

‘+’。和’*'一样，出现的所有命令行参数都被收集到一个列表中。

除此之外，如果没有至少出现一个命令行参数将会产生一个错误信息。

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('test', nargs='+')
parser.add_argument('-test1', nargs='+')
args1 = parser.parse_args('a b -test1 a '.split())
print(args1)
#args2 = parser.parse_args(''.split())# 会报错
#print(args2)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

image-20200915145113858

nargs=argparse.REMAINDER

所有剩余的命令行参数都被收集到一个列表中。这通常用于命令行工具分发命令到其它命令行工具

import argparse
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('--foo')
parser.add_argument('command')
parser.add_argument('args', nargs=argparse.REMAINDER)
x = parser.parse_args('--foo B cmd 123 --arg1 XX ZZ'.split())#此时需要按照参数顺序输入否则会出现错误收集
print(x)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

image-20200915145126102

const

action 和 nargs 所需要的常量值。const 参数在某些特定的 action 上面已经介绍到了会被使用，还有就是 nargs 是 ‘?’ 的时候会优先使用 const 里面的值。

default

不指定参数时的默认值。对于参数，default的值用于选项字符串没有出现在命令行中的时候。

type

命令行参数应该被转换成的类型。可以设置传入参数要求的类型。

choices

参数可允许的值的一个容器。可以设置填入的参数在 choices 指定的范围内。

required

可选参数是否可以省略 (仅针对可选参数)。有此参数，如果传入的时候没有将报出一个错误。

help

参数的帮助信息，当指定为 argparse.SUPPRESS时表示不显示该参数的帮助信息。

打印当前解析器中所有选项的完整的帮助信息然后退出。默认情况下，help动作会自动添加到解析器中。参见ArgumentParser以得到如何生成输出信息。

metavar与dest

当ArgumentParser生成帮助信息时，它需要以某种方式引用每一个参数。

注意metavar只会改变显示出来的名字 - parse_args() 对象中属性的名字仍然由dest的值决定。

metavar

metavar是指定在 usage 说明中的参数名称，对于必选参数默认就是参数名称，对于可选参数默认是全大写的参数名称。

import argparse
parser = argparse.ArgumentParser()#可以用metavar指定另外一个名字
parser.add_argument('aa')#namespace中还是aa为目标
parser.add_argument('bb', metavar='bbb')#namespace中还是bb为目标
parser.add_argument('-cc')#namespace中还是cc为目标 usage中默认为CC
parser.add_argument('-dd', metavar='ddd')#namespace中还是dd为目标但不能用ddd作为可选参数输入#也可以用'-ddd'两者显示的时候是不一样的
args = parser.parse_args('A B -dd D '.split())
print(args)
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

image-20200915145146342

nargs的不同值可能导致metavar使用多次。传递一个列表给metavar将给每个参数指定一个不同的显示名字：

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-x', nargs=2)
parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5

image-20200915145202198

dest

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

默认情况下，ArgumentParser对象使用dest的值作为每个对象的“名字”。

对于位置参数的动作，dest 通常作为第一个参数提供给add_argument()。正如之前所有的abcd或者test字符串等。默认情况下，对于位置参数直接使用dest的值。

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

默认dest示范

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('a')
parser.add_argument('-b', '--bbb-bbb', '--bbb')#可选参数中有--的选项，选--中最长的去掉前面的--，把中间的-改写成_
parser.add_argument('-cccccccc', '--cc-cc', '-c')#可选参数-的ccccccc比--cc-cc长但是仍然选--cc-cc
parser.add_argument('-dddd', '-d-d','-d')#可选参数中没有--的选项，选-中最长的去掉前面的-，把中间的-改写成_
args = parser.parse_args('1 -b 2 -c 3 -d 4'.split())
print(args)#在namespace中可以看到存储的dest
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

image-20200915145212165

修改dest

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('a')# 定位参数不可以选择dest
parser.add_argument('-b', '--bbb-bbb',dest = 'b')
parser.add_argument('--cc-cc', '-c',dest = 'c')
args = parser.parse_args('1 -b 2 -c 3'.split())
print(args)#在namespace中可以看到存储的dest
parser.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

image-20200915145222466

argparse.ArgumentParser默认值的修改

import argparse
x = argparse.ArgumentParser(prog='It\'s a cool job!',
                            usage='正常使用我就可以了',
                            description='那你说个毛',
                            epilog='我是 EPILOG')
x.add_argument('-v', help='gg 斯密达')
x.parse_args()
x.print_help()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

image-20200915145234915

文章知识点与官方知识档案匹配，可进一步学习相关知识
Python入门技能树首页概览416623 人正在系统学习中
注：本文转载自blog.csdn.net的呆呆象呆呆的文章"https://blog.csdn.net/qq_41554005/article/details/93136076"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！