python基础之命令行参数解析模块：argparse.ArgumentParser(add_argument)

---

前言

argparse.ArgumentParser：python命令行参数解析模块

reference：
https://docs.python.org/zh-cn/3/library/argparse.html
https://pypi.org/search/?q=argparse.ArgumentParser
usage:
解析命令行参数(windows: cmd窗口，Linux: shell窗口)
exp：
主要讲添加参数的add_argument方法

---

(一) 导入argparse模块

import argparse

(二) 不添加命令行参数

parser = argparse.ArgumentParser()  # 创建一个解析命令行参数的对象
opt = parser.parse_args()  # 解析参数，返回一个namespace
print(opt)  
# opt:  Namespace()

(三) 添加命令行参数参数（add_argument）

命令行参数可分为位置参数和可选参数
位置参数：字符串
可选参数：-字符串，- -字符串

3.1 添加命令行位置参数

对于位置参数，无法直接进行默认赋值，必须按顺序进行赋值 (注：“直接”，后续会讲到如何对位置参数进行默认赋值)

1, 不传入位置参数运行会直接报错。

parser = argparse.ArgumentParser()
parser.add_argument('name')
parser.add_argument('age')
parser.add_argument('height')
opt = parser.parse_args()
print(opt)  

out:
usage: argparse_exp.py [-h] name age height
argparse_exp.py: error: the following arguments are required: name, age, height

2, 传入位置参数并赋值运行则输出指定值

parser = argparse.ArgumentParser()
parser.add_argument('name')
parser.add_argument('age')
parser.add_argument('height')
opt = parser.parse_args(['jack', '18', '180'])
print(opt)

out: Namespace(name='jack', age='18', height='180')

3.2 添加命令行可选参数

对于命令行可选参数，可进行默认赋值，可不按顺序进行赋值

1, 不传入可选参数且不默认赋值运行，默认输出为None。

parser = argparse.ArgumentParser()
parser.add_argument('--name')
parser.add_argument('--age')
parser.add_argument('--height')
opt = parser.parse_args()
print(opt)  

out:  Namespace(name=None, age=None, height=None)

2, 不传入可选参数但默认赋值运行，输出为默认值。

parser.add_argument('--name', default='jack')
parser.add_argument('--age', default=18)
parser.add_argument('--height', default=180)
opt = parser.parse_args()
print(opt) 

out:  Namespace(name='jack', age=18, height=180)

3, 按顺序传入可选参数并赋值运行，按原顺序输出指定值。

parser = argparse.ArgumentParser()
parser.add_argument('--name', default='jack')
parser.add_argument('--age', default=18)
parser.add_argument('--height', default=180)
opt = parser.parse_args(['--name', 'tom', '--age', '20', '--height', '175'])
print(opt)

out:  Namespace(name='tom', age='20', height='175')

4, 不按顺序传入可选参数并赋值运行，一样按原顺序输出指定值。

parser = argparse.ArgumentParser()
parser.add_argument('--name', default='jack')
parser.add_argument('--age', default=18)
parser.add_argument('--height', default=180)
opt = parser.parse_args(['--age', '20', '--name', 'tom', '--height', '175'])
print(opt)

out: Namespace(name='tom', age='20', height='175')

3.3 添加其它参数

3.3.1，action

action可指定的参数：'store', 'store_true', 'store_false', 'store_const', 'append', 'append_const', 'count', 'extend', 'version', 'help'

1, store（默认值）：存储默认或指定参数的值。

parser = argparse.ArgumentParser()
parser.add_argument('--foo')
opt = parser.parse_args(['--foo', '1'])
print(opt)

out: Namespace(foo='1')

2, 'store_true' 和 'store_false'：默认分别存储False和True值。

parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='store_true')
parser.add_argument('--bar', action='store_false')
parser.add_argument('--baz', action='store_false')
opt = parser.parse_args(['--foo', '--bar'])
print(opt)

out: Namespace(foo=True, bar=False, baz=True)

3, 'store_const'：存储关键字参数const指定的值(默认为None), 最常与指定某种标志的可选参数一起使用。

parser.add_argument('--foo', action='store_const', const=45)
opt = parser.parse_args(['--foo'])
print(opt)

out: Namespace(foo=42)

4, 'append': 存储一个列表, 允许对同一个可选参数进行多次赋值, 并将赋的值依次append到列表中, 命令行的赋值(非空)append在默认值后面。

parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='append')
opt = parser.parse_args(['--foo', '1', '--foo', '2'])
print(opt)

out: Namespace(foo=['1', '2'])

5, 'append_const'：存储一个列表, 并将const关键字参数指定的值附加到列表; 请注意, const关键字参数默认为None. 当多个参数需要将常量存储到同一个列表时，该’append_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)
opt = parser.parse_args(['--str', '--int'])
print(opt)

out: Namespace(types=[<class 'str'>, <class 'int'>])

6, 'count': 计算一个关键字参数出现的数目或次数。例如，对于一个增长的详情等级来说有用。

parser = argparse.ArgumentParser()
parser.add_argument('--verbose', '-v', action='count', default=0)
opt = parser.parse_args(['-vvv'])
print(opt)

out: Namespace(verbose=3)
请注意, default 将为 None, 除非显式地设为 0。

7, 'extend': 这会存储一个列表，并将每个参数值加入到列表中。

parser = argparse.ArgumentParser()
parser.add_argument("--foo", action="extend", nargs="+", type=str)
opt = parser.parse_args(["--foo", "f1", "--foo", "f2", "f3", "f4"])
print(opt)

out: Namespace(foo=['f1', 'f2', 'f3', 'f4'])

8, 'version': 期望有一个 version= 命名参数在 add_argument() 调用中，并打印版本信息并在调用后退出。

parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('--version', action='version', version='%(prog)s 2.0')
opt = parser.parse_args(['--version'])
print(opt)

out: Namespace(PROG 2.0）

9, 'help': 打印所有当前解析器中的选项和参数的完整帮助信息，然后退出。默认情况下，一个 help 动作会被自动加入解析器。

parser = argparse.ArgumentParser()
parser.add_argument('name', help='print your name')
parser.add_argument('age', help='print your age')
parser.add_argument('height', help='print your height')
opt = parser.print_help()
print(opt )

out:
usage: argparse_exp.py [-h] name age height

positional arguments:
  name        print your name
  age         print your age
  height      print your height

optional arguments:
  -h, --help  show this help message and exit
None

parser = argparse.ArgumentParser()
parser.add_argument('--name', default='jack', help='print your name')
parser.add_argument('--age', default=18, help='print your age')
parser.add_argument('--height', default=180, help='print your height')
opt = parser.print_help()
print(opt)

out:
usage: argparse_exp.py [-h] [--name NAME] [--age AGE] [--height HEIGHT]

optional arguments:
  -h, --help       show this help message and exit
  --name NAME      print your name
  --age AGE        print your age
  --height HEIGHT  print your height
None

3.3.2，nargs

nargs可指定的参数：'N'（整数），'?'，'*'，'+'

1， 'N'（整数）：将N个命令行参数按顺序添加到一个列表中

①若有多个位置参数，默认按顺序添加

parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs=2)
parser.add_argument('bar', nargs=2)
parser.add_argument('car', nargs=1)
opt = parser.parse_args(['c', 'd', 'e', '--foo', 'a', 'b'])
print(opt)

out: Namespace(foo=['a', 'b'], bar=['c', 'd'], car=['e'])

②若既有位置参数和可选参数，命令行中参数输入的位置要对应但是可以不按顺序输入，输出的结果是和上面一致的

parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs=2)
parser.add_argument('bar', nargs=2)
parser.add_argument('car', nargs=1)
opt = parser.parse_args(['--foo','a', 'b', 'c', 'd', 'e'])
print(opt)

out: Namespace(foo=['a', 'b'], bar=['c', 'd'], car=['e'])

③当nargs=1，产生的是单元素列表，和默认是单元素是不同的

parser = argparse.ArgumentParser()
parser.add_argument('--car', nargs=1)
parser.add_argument('--bus', default=1)
opt = parser.parse_args(['--car' ,'2'])
print(opt)

out: Namespace(car=['2'], bus=1)

2， '?'：默认输入单个命令行参数，输出单个命令行参数

①对于位置参数
如2.3.1中所讲，我们无法直接对位置参数进行默认赋值，但是可通过nargs=’?'来进行默认赋值，若命令行不指定位置参数的值，则输出结果为默认值。

命令行指定值，结果为指定值

parser = argparse.ArgumentParser()
parser.add_argument('bar', nargs='?', default='b')
opt = parser.parse_args(['a'])
print(opt)

out: Namespace(bar='a')

命令行不指定值，结果为默认值

parser = argparse.ArgumentParser()
parser.add_argument('bar', nargs='?', default='b')
opt = parser.parse_args()
print(opt)

out: Namespace(bar='b')

②对于可选参数
对于命令行不指定值，可选参数有两种情况：
一是命令行不输入可选参数且不指定值，结果为default值；
而是命令行输入可选参数但不指定值，结果为const值。

当命令行指定值, 结果为指定的值

parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs='?', const='a', default='f')
opt = parser.parse_args(['--foo', 'd'])
print(opt)

out: Namespace(foo='d')

当命令行不输入可选参数且不指定值, 结果为default值

parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs='?', const='a', default='f')
opt = parser.parse_args()
print(opt)

out: Namespace(foo='f')

当命令行输入可选参数但不指定值, 结果为const值

parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs='?', const='a', default='f')
opt = parser.parse_args(['--foo'])
print(opt)

out: Namespace(foo='a')

3， ' * '：将0 或多个命令行参数添加到一个列表中。注意通过 nargs=’*’ 来实现多个位置参数通常没有意义，但可以多个可选参数。

parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs='*')
parser.add_argument('--bar', nargs='*')
parser.add_argument('baz', nargs='*')
opt = parser.parse_args(['a', 'b', '--foo', 'x', 'y', '--bar', '1', '2'])
print(opt)

out: Namespace(foo=['x', 'y'], bar=['1', '2'], baz=['a', 'b'])

4，' + '：将1 或多个命令行参数添加到一个列表中。当少于一个命令行参数时会报错。

parser = argparse.ArgumentParser()
parser.add_argument('foo', nargs='+')
opt = parser.parse_args(['a', 'b'])
print(opt)

out: Namespace(foo=['a', 'b'])

parser = argparse.ArgumentParser()
parser.add_argument('foo', nargs='+')
opt = parser.parse_args()
print(opt)

out: 
usage: argparse_exp.py [-h] foo [foo ...]
argparse_exp.py: error: the following arguments are required: foo

3.3.3，default

当我们想固定某个命令行参数的值，或者在命令行参数未指定值的时候使用的值，可使用default参数。

1，不指定命令行参数值，输出默认值。

parser = argparse.ArgumentParser()
parser.add_argument('--foo', default=42)
opt = parser.parse_args()
print(opt)

out: Namespace(foo=42)

2，指定命令行参数值，输出指定值。

parser = argparse.ArgumentParser()
parser.add_argument('--foo', default=42)
opt = parser.parse_args(['--foo', '2'])
print(opt)

out: Namespace(foo='2')

使用type来转换字符串为指定的type。若默认值为字符串的情况下不用type，则输出类型为字符串，若默认为其它类型则输出其它类型。

parser = argparse.ArgumentParser()
parser.add_argument('--length', default='10', type=int)
parser.add_argument('--width', default=10.5, type=int)
opt = parser.parse_args()
print(opt)

out: Namespace(length=10, width=10.5)

3，对于位置参数，当使用narg为“*”或者“+”时，可使用默认值，当命令行参数不指定值时，即为默认值。

parser = argparse.ArgumentParser()
parser.add_argument('foo', nargs='?', default=42)
opt = parser.parse_args(['a'])
print(opt)

out: Namespace(foo='a')

parser = argparse.ArgumentParser()
parser.add_argument('foo', nargs='?', default=42)
opt = parser.parse_args()
print(opt)

out: Namespace(foo=42)

3.3.4，const

const 参数用于保存常数值，该常数不从命令行中读取，但可用于各种 ArgumentParser 操作。 主要用法有 action='store_const'和 action='append_const'，详情可见action部分。

3.3.5，type

type 参数通常用于将输入字符串转换为特定的数据类型，其他类型不进行转换。默认情况下，解析器会将命令行参数传入的值当作字符串，但是实际情况中我们通常需要传入特定数据类型的值，例如int, float等，因此解析器在添加参数的时候可以通过type来执行数据类型检查和转换。

parser = argparse.ArgumentParser()
parser.add_argument('count', type=int)
opt = parser.parse_args(['a'])
print(opt)

out: Namespace(count=3)

parser = argparse.ArgumentParser()
parser.add_argument('count', type=int)
opt = parser.parse_args(['a'])
print(opt)

out: 
usage: argparse_exp.py [-h] count
argparse_exp.py: error: argument count: invalid int value: 'a'

3.3.6，choices

choices 参数通常用于指定一组序列，命令行参数的值从这组序列中进行选择。任何序列都可以作为choices进行值传递，例如列表、元组或者自定义序列。

parser = argparse.ArgumentParser(prog='game.py')
parser.add_argument('move', choices=['rock', 'paper', 'scissors'])
opt = parser.parse_args(['rock'])
print(opt)

out: Namespace(move='rock')

parser = argparse.ArgumentParser(prog='game.py')
parser.add_argument('move', choices=['rock', 'paper', 'scissors'])
opt = parser.parse_args(['fire'])
print(opt)

out:
usage: game.py [-h] {
    
    rock,paper,scissors}
game.py: error: argument move: invalid choice: 'fire' (choose from 'rock',
'paper', 'scissors')

请注意，在执行任何类型转换后，将检查choices序列中的值，因此choices序列中的对象类型应该与指定的类型匹配。

parser = argparse.ArgumentParser(prog='doors.py')
parser.add_argument('door', type=int, choices=range(1, 4))
opt = parser.parse_args(['3'])
print(opt)

out: Namespace(door=3)

parser = argparse.ArgumentParser(prog='doors.py')
parser.add_argument('door', choices=range(1, 4))
opt = parser.parse_args(['3'])
print(opt)

out:
usage: doors.py [-h] {
    
    1,2,3}
doors.py: error: argument door: invalid choice: '3' (choose from 1, 2, 3)

3.3.7，required

required 参数通常用于指定某个命令行参数是否为必选项，通常使用True和False来设置开关状态。

parser = argparse.ArgumentParser()
parser.add_argument('--foo', required=True)
opt = parser.parse_args(['--foo', 'hello world'])
print(opt)

out: Namespace(foo='hello world')

parser = argparse.ArgumentParser()
parser.add_argument('--foo', required=True)
opt = parser.parse_args()
print(opt)

out:
usage: argparse_exp.py [-h] --foo FOO
argparse_exp.py: error: the following arguments are required: --foo

3.3.8，metavar

metavar 参数通常用于在生成帮助消息时，指定命令行参数的显示名称。
对于可选参数：dest 值将被转为大写形式。
对于位置参数：dest 值将被直接使用。

parser = argparse.ArgumentParser()
parser.add_argument('--foo')
parser.add_argument('bar')
opt = parser.parse_args(['X', '--foo', 'Y'])
print(opt)

Namespace(bar='X', foo='Y')

parser = argparse.ArgumentParser()
parser.add_argument('--foo')
parser.add_argument('bar')
opt = parser.print_help()
print(opt)

out:
usage:  [-h] [--foo FOO] bar

positional arguments:
 bar

options:
 -h, --help  show this help message and exit
 --foo FOO

parser = argparse.ArgumentParser()
parser.add_argument('--foo', metavar='YYY')
parser.add_argument('bar', metavar='XXX')
parser.parse_args(['X', '--foo', 'Y'])
opt = parser.print_help()
print(opt)

out:
Namespace(foo='y', bar='x')
usage: argparse_exp.py [-h] [--foo YYY] XXX

positional arguments:
  XXX

optional arguments:
  -h, --help  show this help message and exit
  --foo YYY

3.3.9，dest

dest 参数通常用于返回某些对象的自定义属性名称。

parser = argparse.ArgumentParser()
parser.add_argument('--foo', dest='bar')
opt = parser.parse_args(['--foo', 'XXX'])
print(opt)

Namespace(bar='XXX')

双短线 “ -- ” 和 单短线 “ - ” 都可以用于命令行可选参数。
1，若命令行参数既有单短线又有双短线，用单短线时输出显示第一个双短线的可选参数；

2，若命令行参数既有单短线又有双短线，用双短线时输出显示第一个双短线的可选参数；

parser = argparse.ArgumentParser()
parser.add_argument('-f', '--foo-bar', '--foo')
parser.add_argument('-x', '-y')
opt = parser.parse_args(['-f', '1', '-x', '2'])
print(opt)

out: Namespace(foo_bar='1', x='2')

parser = argparse.ArgumentParser()
parser.add_argument('-f', '--foo-bar', '--foo')
parser.add_argument('-x', '-y')
opt = parser.parse_args(['--foo', '1', '-y', '2'])
print(opt)

out:Namespace(foo_bar='1', x='2')

**注：若有任何问题，欢迎大家在评论区一起讨论！**