python学习笔记06-命令行参数

目录

1. 使用步骤

使用步骤如下:

#导入模块
import argparse
import sys

class CDemo(object):

    def __init__(self):
        self.o_args = self._parse_args()

    def _parse_args(self):

        #----------------------
        #获取parser, description文本会显示在help信息中
        #----------------------
        _o_parser = argparse.ArgumentParser(description='args discription')

        #----------------------
        #添加选项, 各选项具体说明见后面各节
        #----------------------
        #选项有几种分类:
        #  1. 按选项名长度分:
        #       位置选项(没有选项名),
        #       短选项(选项名是一个字符),
        #       长选项(选项名多个字符)
        #       (短选项名和长选项名可以都声明)
        #  2. 按选项值类型分:
        #       0值选项, flag选项, 只有选项名, 没有选项值, 值为True或false
        #       单值选项, 这是默认情况
        #       列表值选项, 值是一个list, list中可以有0到多个元素.
        #  3. 按选项是否必须声明分:
        #       必选选项, 默认是必须声明的选项
        #       可选选项, 通过设置默认值来实现
        #  4. 未知选项, add_argument没有指定的, 会进入到"未知选项"


        #位置选项, 要出现在所有命令行选项最前面.
        #列表值选项, 选项值是一个list,
        #可选选项, 选项默认值是空list,
        _o_parser.add_argument('vfiles', type=str, default=[], nargs='*')

        #短选项,
        #flag选项, 通过action=store_true实现,
        #可选选项, 声明为True, 不声明(默认)为False
        _o_parser.add_argument('-a', action='store_true', default=False)

        #短选项+长选项, 长短选项可同时声明, 内部只能使用o_args.b_long_opt获取, o_args.b获取不到,
        #单值选项, 默认行为, 声明多个值会出错, 
        #必选选项, required=True实现,
        _o_parser.add_argument('-b', '--b_long_opt', type=str, required=True)

        #与-b选项相同, 区别是通过dest='c_new_name'指定内部选项名,  内部只能使用o_args.c_new_name获取, o_args.c和o_args.c_long_opt都获取不到
        _o_parser.add_argument('-c', '--c_long_opt', type=str, required=True, dest='c_new_name')

        #----------------------
        #解析命令行的选项
        #----------------------
        _o_args = _o_parser.parse_args(sys.argv[1:])

        #----------------------
        #使用选项, 假设命令行为: $0 vf0 vf1 -b b0 -c c0
        #----------------------
        print(f'vfiles: {_o_args.vfiles}')      # ['vf0', 'vf1']
        print(f'-a    : {_o_args.a}')           # False
        print(f'-b    : {_o_args.b_long_opt}')  # b0
        print(f'-c    : {_o_args.c_new_name}')  # c0

        return _o_args

if __name__=='__main__':
    o_demo = CDemo()

对sys.argv[1:]的说明:

sys.argv         # 一个列表，存储命令行参数.  
sys.argv[0]      # 脚本名.  
sys.argv[1:]     # 命令行参数.  
sys.argv[1][2:]  # 截取第一个参数第2bit之后的内容；

2. 选项分类: 按选项名长度分

2.1 选项名长度为0: 位置选项

位置选项可以实现类似于vcs a.v b.v的选项处理,
命令行指定选项时不需要使用'-vfile 或者-xx'这种形式指定选项内容, 直接把选项值列上就行.

>>> import os
>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> 
>>> # vfiles是位置选项.
>>> # default=[], 这是个列表值选项, 默认为空;
>>> # nargs='*',  可以是0个或多个参数;
>>> parser.add_argument('vfiles', type=str, default=[], nargs='*')
_StoreAction(option_strings=[], dest='vfiles', nargs='*', const=None, default=[], type=<class 'str'>, choices=None, help=None, metavar=None)
>>>
>>> # 默认是0个元素的list
>>> args = parser.parse_args([])
>>> args.vfiles
[]
>>>
>>> # 指定一个值, 则list中包含一个元素
>>> args = parser.parse_args(['vf0'])
>>> args.vfiles
['vf0']
>>>
>>> # 指定两个值, 则list中包含两个元素
>>> args = parser.parse_args(['vf0', 'vf1'])
>>> args.vfiles
['vf0', 'vf1']

2.2 选项名长度为1: 短选项

短选项可以实现-a a0 -b b0这种样式的选项.

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> 
>>> #添加-a和-b两个选项, 不指定默认值时, 默认为None.
>>> parser.add_argument('-a', type=str)
_StoreAction(option_strings=['-a'], dest='a', nargs=None, const=None, default=None, type=<class 'str'>, choices=None, help=None, metavar=None)
>>> parser.add_argument('-b', type=str)
_StoreAction(option_strings=['-b'], dest='b', nargs=None, const=None, default=None, type=<class 'str'>, choices=None, help=None, metavar=None)
>>>
>>> #不指定值时, 默认值为None.
>>> args = parser.parse_args([])
>>> args.a
>>> args.b
>>>
>>> #指定值时, 值为-a或-b后面跟的值:
>>> args = parser.parse_args(['-a', 'a0', '-b', 'b0'])
>>> args.a
'a0'
>>> args.b
'b0'
>>>
>>> # 如果只指定选项, 不指定值, 会报错退出:
>>> args = parser.parse_args(['-a', '-b', 'b0'])
usage: [-h] [-a A] [-b B]
: error: argument -a: expected one argument

2.3 选项名长度大于1: 长选项

短选项可以实现 --b_long_opt b0这种样式的选项.
长选项需要使用双短线才能使用.

>>> import argparse
>>>
>>> parser = argparse.ArgumentParser()
>>>
>>> parser.add_argument(  
...     '-e'           , # 短选项和长选项可以同时都加上, 命令行使用-e和--e_long_opt都可以, 但内部只能使用o_args.e_long_opt获取.
...     '--e_long_opt' , # 表示长选项  
...     type=str       , #   
...     required=False , #  
...     default=[]     , #  
...     nargs='+'      , # 表示--e_long_opt这个选项后面可以有多个参数  
)  
_StoreAction(option_strings=['-e', '--e_long_opt'], dest='e_long_opt', nargs='+', const=None, default=[], type=<class 'str'>, choices=None, help=None, metavar=None)
>>> 
>>> #不声明选项时, 默认为空list.
>>> args = parser.parse_args([])
>>> args.e_long_opt
[]
>>> 
>>> #声明选项时, 值为指定的list.
>>> args = parser.parse_args(['--e_long_opt', 'e0', 'e1'])
>>> args.e_long_opt
['e0', 'e1']
>>> 
>>> #同时指定了长短选项名, 命令行可以使用-e和--e_long_opt, 但内部只能使用args.e_long_opt, 不能使用args.e:
>>> args.e
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Namespace' object has no attribute 'e'
>>>

2.4 指定内部使用的选项名

在命令行使用的选项名称 与 内部使用的名称可以不一致.
通过dest='new_name'实现.

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>>
>>> #添加-a选项, 但指定内部使用名称a_new_name来访问
>>> parser.add_argument('-a', type=str, default='ax', dest='a_new_name')
_StoreAction(option_strings=['-a'], dest='a_new_name', nargs=None, const=None, default='ax', type=<class 'str'>, choices=None, help=None, metavar=None)
>>>
>>> #命令行使用-a选项名
>>> args = parser.parse_args(['-a', 'a0'])
>>>
>>> #内部使用dest指定的新名称a_new_name
>>> args.a_new_name
'a0'
>>>
>>> #args.a不存在.
>>> args.a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Namespace' object has no attribute 'a'
>>>

3. 选项分类: 按选项值类型分

3.1 〇值选项, flag选项

flag类型选项本身无参数, 根据"命令行是否有该选项" 和 "该选项声明值/默认值" 来决定选项实际值.
注意, 并不是"声明选项为True, 不声明为False", 而是内部可配置.
通过action='store_true' 或 action='store_false'实现.

举例:

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>>
>>> # -a 声明选项则为True, 不声明则为False.
>>> parser.add_argument('-a', action='store_true', default=False)
_StoreTrueAction(option_strings=['-a'], dest='a', nargs=0, const=True, default=False, type=None, choices=None, help=None, metavar=None)
>>> 
>>> # -b 声明选项则为False, 不声明则为True.
>>> parser.add_argument('-b', action='store_false', default=True)
_StoreFalseAction(option_strings=['-b'], dest='b', nargs=0, const=False, default=True, type=None, choices=None, help=None, metavar=None)
>>>
>>> # -c 声明选项则为True, 不声明还为True, 这种感觉没意义.
>>> parser.add_argument('-c', action='store_true', default=True)
_StoreTrueAction(option_strings=['-c'], dest='c', nargs=0, const=True, default=True, type=None, choices=None, help=None, metavar=None)
>>>
>>> # -d 声明选项则为False, 不声明还为False, 这种感觉没意义.
>>> parser.add_argument('-d', action='store_false', default=False)
_StoreFalseAction(option_strings=['-d'], dest='d', nargs=0, const=False, default=False, type=None, choices=None, help=None, metavar=None)
>>> 
>>> #测试一下-a, -b, -c, -d:
>>> 
>>> # 都不声明, 查看默认值
>>> args = parser.parse_args([])
>>> args.a ;# False
>>> args.b ;# True
>>> args.c ;# True
>>> args.d ;# False
>>> 
>>> # 声明-a, -b, -c, -d
>>> args = parser.parse_args(['-a', '-b', '-c', '-d'])
>>> args.a ;# True
>>> args.b ;# False
>>> args.c ;# True, 与不声明时一样
>>> args.d ;# False, 与不声明时一样
>>>

3.2 一值选项(默认是一值)

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> 
>>> # 指定一值选项-a, 它只能有一个值.
>>> parser.add_argument('-a', type=str)
_StoreAction(option_strings=['-a'], dest='a', nargs=None, const=None, default=None, type=<class 'str'>, choices=None, help=None, metavar=None)
>>>
>>> # 正常指定一个值:
>>> args = parser.parse_args(['-a', 'a0'])
>>> args.a
'a0'
>>> 
>>> # 指定多于一个值, 会报错退出:
>>> args = parser.parse_args(['-a', 'a0', 'a1'])
usage: [-h] [-a A]
: error: unrecognized arguments: a1

3.3 列表值选项(值为一个list, 可以有0到多个值)

通过nargs='+'实现, 表示当前选项可以有多个参数, 这些参数组成一个list.
疑问: nargs='+'和nargs='*'有什么区别?

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> 
>>> #-a选项可以对应多个值
>>> parser.add_argument('-a', type=str, default=[], nargs='+')
_StoreAction(option_strings=['-a'], dest='a', nargs='+', const=None, default=[], type=<class 'str'>, choices=None, help=None, metavar=None)
>>>
>>> # 默认是空list
>>> args = parser.parse_args([])
>>> args.a
[]
>>>
>>> # 指定一个值, 则list中包含一个元素
>>> args = parser.parse_args(['-a', 'a0'])
>>> args.a
['a0']
>>>
>>> # 指定两个值, 则list中包含两个元素
>>> args = parser.parse_args(['-a', 'a0', 'a1'])
>>> args.a
['a0', 'a1']
>>>
>>> # 指定0个值, 会报错退出
>>> args = parser.parse_args(['-a'])
usage: [-h] [-a A [A ...]]
: error: argument -a: expected at least one argument

4. 选项分类: 按是否可选分

分为必选选项和可选选项.
默认是可选选项.
通过required=True/False实现.

>>> import argparse
>>> 
>>> parser = argparse.ArgumentParser()
>>>
>>> #-a, 指定为必选选项, 必须指定.
>>> parser.add_argument('-a', type=str, required=True)
_StoreAction(option_strings=['-a'], dest='a', nargs=None, const=None, default=None, type=<class 'str'>, choices=None, help=None, metavar=None)
>>> 
>>> #-b, 默认为可选选项, 默认值为bx.
>>> parser.add_argument('-b', type=str, default='bx')
_StoreAction(option_strings=['-b'], dest='b', nargs=None, const=None, default='bx', type=<class 'str'>, choices=None, help=None, metavar=None)
>>> 
>>> #-a和-b都声明, 得到的是指定的值.
>>> args = parser.parse_args(['-a', 'a0', '-b', 'b0'])
>>> args.a
'a0'
>>> args.b
'b0'
>>>
>>> # -b 不声明时, args.b得默认值bx.
>>> args = parser.parse_args(['-a', 'a0'])
>>> args.b
'bx'
>>>
>>> # -a 不声明时, 由于-a是必选选项, 会报错退出:
>>> args = parser.parse_args(['-b', 'b0'])
usage: [-h] -a A [-b B]
: error: the following arguments are required: -a

5. 选项值的数据类型

通过type=int/str指定.

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> 
>>> #-a选项对应的值为int类型
>>> parser.add_argument('-a', type=int, required=True)
_StoreAction(option_strings=['-a'], dest='a', nargs=None, const=None, default=None, type=<class 'int'>, choices=None, help=None, metavar=None)
>>> 
>>> #传给-a的值为str '3'
>>> args = parser.parse_args(['-a', '3'])
>>> args.a
3
>>> #传到内部后会转为int类型.
>>> type(args.a)
<class 'int'>
>>>
>>> #传给-a的值'a3'无法转为int类型, 会报错退出:
>>> args = parser.parse_args(['-a', 'a3'])
usage: [-h] -a A
: error: argument -a: invalid int value: 'a3'

6. 未知选项

如果sys.argv[1:]中出现了"位置选项123" 或 "命名选项-f 456",
但"123" 或"-f"选项没有定义在add_argument()中时，直接使用parser.parse_args()会报告错误：

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> 
>>> #指定了-a选项, 没指定-f选项或位置选项
>>> parser.add_argument('-a', type=str, default='ax')
_StoreAction(option_strings=['-a'], dest='a', nargs=None, const=None, default='ax', type=<class 'str'>, choices=None, help=None, metavar=None)
>>>
>>> # 直接使用-f选项, 会报错退出
>>> args = parser.parse_args(['-f', 'f0'])
usage: [-h] [-a A]
: error: unrecognized arguments: -f f0
>>>
>>> # 直接使用位置选项, 会报错退出
>>> args = parser.parse_args(['vf0', 'vf1'])
usage: [-h] [-a A]
: error: unrecognized arguments: vf0 vf1

这时需要使用parser.parse_known_args()这个方法(而不是parser.parse_args()这个方法)。

>>> import argparse
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('-a', type=str, default='ax')
_StoreAction(option_strings=['-a'], dest='a', nargs=None, const=None, default='ax', type=<class 'str'>, choices=None, help=None, metavar=None)
>>>
>>> # 使用parser.parse_known_args()
>>> args, unknown_args = parser.parse_known_args(['vf0', 'vf1', '-a', 'a0', '-f', 'f0'])
>>> args
Namespace(a='a0')
>>> args.a # args.a得到了-a指定的值
'a0'
>>> 
>>> #unknown_args是一个列表, 它得到了解析完-a选项剩下的选项.
>>> unknown_args
['vf0', 'vf1', '-f', 'f0']
>>>
posted @ 2020-07-03 10:42  编程驴子  阅读(270)  评论(0)    收藏  举报