本文是对下面链接博客的补充与修正，全部代码我已经跑过，都是没有错误的。
——Archerzjc

0_此博客解释很详细

本文绝大多数参考此博客：https://ganler.github.io/2018/07/18/argsparse-python%E5%92%8C%E5%91%BD%E4%BB%A4%E8%A1%8C%E4%B9%8B%E9%97%B4%E7%9A%84%E4%BA%A4%E4%BA%92/

关于dest可以从如下博客找到资料：
http://www.cnblogs.com/zknublx/p/6106343.html
https://blog.csdn.net/guoyajie1990/article/details/76739977

此博主写的也不错，有时间可以看下：
https://blog.csdn.net/u013177568/article/details/62432761/

1. 初始化

# 1引入模块
import argparse  
   
# 2建立解析对象
parser = argparse.ArgumentParser()

# 3增加属性：给xx实例增加一个aa属性 # xx.add_argument("aa")
parser.add_argument("echo")         

# 4属性给与args实例： 把parser中设置的所有"add_argument"给返回到args子类实例当中， 那么parser中增加的属性内容都会在args实例中，使用即可。
args = parser.parse_args()
parser.parse_args()

# 打印定位参数echo
print(args.echo)

运行的话，在 python argp.py 后面加上 abcd (任意)；
其将输出 “abcd”。
因为我们把 abcd 赋给了 args.echo了。

给其设置help：
parser.add_argument("echo", help = "echo is here~")

在命令行中输入：
python argp.py -h
就可以得到相关的帮助信息。

2. type:

假设我们写一个文件，在命令行将其编译时，同时输入一个数字，返回一个平方：
因为 parse.add_argument() 对于接受的值默认其为str，如果要将之视为int类型，额外加一句 “type=int”。

# 1引入模块
import argparse

# 2建立解析对象
parser = argparse.ArgumentParser()

# 3增加属性：在命令行中，该py文件希望用户能给他一个参数，最终将之转化为：args.square
parser.add_argument("square", help = "To sqaure the number given", type = int)

# 4属性给与args实例：add_argument 返回到 args 子类实例
args = parser.parse_arg()
print(args.square**2)

有了type程序也可以自动过滤掉相关的不符合类型的参数输入。

3. 可选参数：

在 add_argument 前，给属性名之前加上“- -”，就能将之变为可选参数。

# 1引入模块
import argparse

# 2建立解析对象
parser = argparse.ArgumentParser()

# 3增加属性：这里的bool是一个可选参数，返回给args的是 args.bool
parser.add_argument("--bool",help = "Whether to pirnt sth.")

# 4属性给与args实例： parser中增加的属性内容都在args实例中
args = parser.parse_args()

# 如果有输入内容，则打印1
if args.bool:
    print('bool = 1')

---输入：
python argp.py --bool 1
---得到：
bool = 1

可选参数"--bool":
既然是可选的，如果不指定（就是不使用它）的话，对应的变量会被设置为None。
对于简单程序，我们可能只需要两种值 True or False：

action = "store_true" 默认操作True :
我们可以在原有的程序的基础上，在 add_argument 中多加一个参数：
action = "store_true"
这个时候，只要在命令行中加个--bool，args.bool就是 True 了，无需再加上之后的赋值内容，加了反而会报错。
---输入：
python argp.py --bool
---得到：
bool = 1

required=True :
但是，如果在 parser.add_argument(..., action = "store_true"，required=True) 的话，那么这个参数就是必须的，因为他是required。
ps: 这里指的参数是 --bool 必须写不然会报错
---输入：
python argp.py --bool
---得到：
bool = 1

4.参数简写:

parser.add_argument("-b","--bool",action="store_true")
这样，在程序内部我们依旧使用 args.bool，但是在命令行当中我们只需要多写一个“-b”就好了。
---输入：
python argp.py -b
---得到：
bool = 1

5.混合定位参数和可选参数：

当我们使用多个 parser.add_argument(...) 的时候，若将之视为可选参数，无则为None。

# 1引入模块
import argparse

# 2建立解析对象
parser = argparse.ArgumentParser()

# 3增加属性
parser.add_argument("-b","--bool",help="to show the ans in a sentencen form",action = "store_true")

parser.add_argument("square", type=int)

# 4属性赋予实例args
args = parser.parse_args() 

ans = args.square**2

# 得到的效果为：一旦输入“-b”然后再输入相关的参数，就可以得到我们需要的结果了，不输入“-b”我们还是可以得到结果，只不过是另外一种方式而已。
if args.bool:
    print("the square of {} = {}".format(args.square,ans))
else:
    print(ans)

---输入：
python test.py -b 2 (或者 python test.py 2)
---得到：
4

关于.format的使用方式请参考我的另一个format详解博客：https://blog.csdn.net/zjc910997316/article/details/86571407

如下内容需进一步了解，进阶：

限制输入的值：

如 parser.add_argument("-b", "--bool", choices = [0,1,2], help="you can only input 0 1or 2."， type = int)
其中，choice 可以限定我们能够输入的数为0,1,2其中一个。
这里的 type = int 必不可少，不然会报错。

import argparse

parser = argparse.ArgumentParser()

parser.add_argument("-b", "--bool", choices = [0,1,2], type = int )

args = parser.parse_args() 

ans = args.bool**2

print(ans)

---输入：
python test.py -b 2
---得到：
4

参数值和顺序：

一般我们要把可选参数最后add，不可选参数放前面add。
而在命令行里面输入代码时，程序会先赋值“先add的参数选项”。

比如我先 parser.add_argument(“a”,…) 再b;
输入命令行的时候： python xx.py x y，这个时候， args.a=x ; args.b=y。

count操作计数赋值：

import argparse

parser = argparse.ArgumentParser()

parser.add_argument("-a", "--bool", action = "count")

args = parser.parse_args() 

ans = args.bool**2

print(ans)

---输入：
python test.py -aaa
---得到：
9

parser.add_argument("-b", "--bool", action="count"，type=int) PS:这里千万不要加 type=int 不然会报错
这个时候，在命令后加上 -b ——> bool=1 ; -bb ——> bool=2 ; -bbb ——> bool=3 以此类推。

但是这样的话，如果在程序里拿bool作为比较对象的时候，比如 if bool > 0: ,

import argparse

parser = argparse.ArgumentParser()

parser.add_argument("-a", "--bool", action = "count")

args = parser.parse_args() 

ans = args.bool**2
if bool:
    print(ans)

---输入： python test.py
不写“-b”的时候会报错，原因是此时的bool是 None ,无法比较，

import argparse

parser = argparse.ArgumentParser()

parser.add_argument("-a", "--bool", action = "count"， default=0)

args = parser.parse_args() 

ans = args.bool**2
if bool:
    print(ans)

要解决这个问题我们只需要加上一个 default 选项：
parser.add_argument("-b", "--bool", action="count", type=int, default=0) 就好了。
---输入： python test.py
---输出：0

6.高级用法：

光上面那点知识，怕是根本算不上炫酷。我们肯定需要更牛逼的办法。

一个py文件的文件名字为"__file__"
参数冲突：

我们可以通过 group 方法，来让 group 组的参数不可以被同时指定：

# 1导入模块
import argparse

# 2建立解析对象
parser = argparse.ArgumentParser()

# 3添加属性
group = parser.add_mutually_exclusive_group()
group.add_argument("-f", "--form", action="store_true")
group.add_argument("-F", "--Form", action="store_true")
parser.add_argument("x", type = float)  // python __file__.py -x 10 , 这个前面“x”不需要写成"-x"??
parser.add_argument("y", type = float)

# 4属性赋予实例args
args = parser.parse_args()
ans = args.x**args.y

if args.form:
    print("{} to the power {} equals {}".format(args.x, args.y, ans))
elif args.Form:
    print("{}^{} = {}".format(args.x,args.y,ans))
else:
    print(ans)

帮助信息中若有“ [a | b] ”就意味着，ab不可以同时使用。

注意点：

在参数简写的时候不要定义“-h”，这个是给help用的。
如果你设置了几个同类型（比如int）的可选参数，并且给他们简写参数了，比如：

x -> -x ; y -> -y …
那么在命令行赋值的时候就应该写：
python __file__ -x 10 -y 100
x = 10 ; y = 100 ;

常用的参数：

dest：如果提供dest，例如dest="a"，那么可以通过args.a访问该参数

default：设置参数的默认值

action：参数出发的动作

store：保存参数，默认

store_const：保存一个被定义为参数规格一部分的值（常量），而不是一个来自参数解析而来的值。

store_ture/store_false：保存相应的布尔值

append：将值保存在一个列表中。

append_const：将一个定义在参数规格中的值（常量）保存在一个列表中。

count：参数出现的次数

parser.add_argument("-v", "--verbosity", action="count", default=0, help="increase output verbosity")

version：打印程序版本信息

type：把从命令行输入的结果转成设置的类型

choice：允许的参数值

parser.add_argument("-v", "--verbosity", type=int, choices=[0, 1, 2], help="increase output verbosity")

help：参数命令的介绍

7.dest：

http://www.cnblogs.com/zknublx/p/6106343.html

dest：如果提供dest，例如dest="a"，那么可以通过args.a访问该参数
dest 允许自定义ArgumentParser的参数属性名称

如下例子，Example 0

# 改进sort：
# 用于被我验证这部分的使用方法

# 1导入模块
import argparse
# 2建立解析对象
parser = argparse.ArgumentParser(description='SORT demo')
# 3添加属性
parser.add_argument('--display', dest='display', help='Display online tracker output (slow) [False]',action='store_true')
# 4属性赋予实例args
args = parser.parse_args()
print("{}".format(args.display))

在文件位置打开终端输入 python test.py --display

‘--display’是可选选项，也可以不输入,直接 python test.py

PS：后面三个例子暂时没看懂

Example 1

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('bar')
>>> parser.parse_args('XXX'.split())
Namespace(bar='XXX')

Example 2

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('-f', '--foo-bar', '--foo')
>>> parser.add_argument('-x', '-y')
>>> parser.parse_args('-f 1 -x 2'.split())
Namespace(foo_bar='1', x='2')
>>> parser.parse_args('--foo 1 -y 2'.split())
Namespace(foo_bar='1', x='2')

Example 3

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

原博客地址：https://ganler.github.io/2018/07/18/argsparse-python%E5%92%8C%E5%91%BD%E4%BB%A4%E8%A1%8C%E4%B9%8B%E9%97%B4%E7%9A%84%E4%BA%A4%E4%BA%92/

1_操作说明：
背景：我安装了Anaconda, 在win7下，把.py文件放置在桌面，用pyhton运行它

一：
win+R打开运行，输入cmd打开终端
备注：win7可以在指定文件夹内 shift+右键 ->选择在“此处打开命令窗口”，即可在指定位置打开终端。

运行.py文件，以下述代码为例：

此文件在桌面，内容如下：

# 1引入模块
import argparse  
   
# 2建立解析对象
parser = argparse.ArgumentParser()

# 3增加属性：给xx实例增加一个aa属性 # xx.add_argument("aa")
parser.add_argument("echo")         

# 4属性给与args实例： 把parser中设置的所有"add_argument"给返回到args子类实例当中， 那么parser中增加的属性内容都会在args实例中，使用即可。
args = parser.parse_args()
parser.parse_args()

# 打印定位参数echo
print(arg.echo)

二：

此文件如何得到记录过程：
win+R -> cmd -> 输入 jupyter notebook 打开了jupyter ->如下操作

双击此处，改名如下

输入代码如下：

保存为test.py:

选择地址保存即可。

三：运行此 test.py 文件

方法1：开始->搜索“python.exe”->拖拽过去-> 输入空格

->再拖拽.py文件

->输入空格->输入要打印内容比如 qwe

因为此文件运行方法如此,注意：红色地方敲空格，蓝线上面是要打印内容

方法2：
打开终端->输入python->空格->拖入test.py文件
因为添加了环境变量，所以直接输入python 就可以，系统可以找到它。

方法3：
CD到 test.py 文件目录下 -> python test.py qwe (python ./test.py qwe 也是可以的)
即可执行文件输出 qwe

备注：关于如何敲代码cd到指定位置?

1.切换盘符：
D:

2.进入D盘内的文件：
cd 文件名

3.撤回上一级目录:

cd..

4.查看当前目录下文件：

dir

2_后面是另外的一些相关博客，没有前面的详细，但有帮助理解
parse_args()

https://blog.csdn.net/daydayjump/article/details/80493024

我对与文档的理解是，parse_args()是将之前add_argument()定义的参数进行赋值，并返回相关的namespace。

Convert argument strings to objects and assign them as attributes of the namespace.

Return the populated namespace.

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x')
>>> parser.add_argument('--foo')
>>> parser.parse_args(['-x', 'X'])
Namespace(foo=None, x='X')
>>> parser.parse_args(['--foo', 'FOO'])
Namespace(foo='FOO', x=None)

3_补充：在python中，命令行解析的很好用

1 导入命令行解析模块

import argparse
import sys

2 然后创建对象

parse = argparse.ArgumentParser()

3 然后增加命令行

parse.add_argument ("--learning_rate", type=float, default=0.01, help="initial learining rate")
parse.add_argument ("--max_steps", type=int, default=2000, help="max")
parse.add_argument ("--hidden1", type=int, default=100, help="hidden1")

# 对于函数 add_argument() 第一个是选项，第二个是数据类型，第三个默认值，第四个是help命令时的说明

然后用 arg=parse.parse_args( sys.argv[1:] )

其中参数 sys.argv[1:] 是命令行语句中从第一个到最后。
如在ubuntu下输入命令行python gg.py --learning_rate 20 --max_steps 10

则 sys.argv[1:0] = --learning_rate 20 --max_steps 10

输出的arg为namespace空间，结果是 Namespace (hidden1=100, learning_rate=20.0, max_steps=10)
但是parse_known_args（）函数输出结果为

te 20 --max_steps 10
20.0
10
100

程序：

import argparse
import sys

parse=argparse.ArgumentParser()
parse.add_argument("--learning_rate",type=float,default=0.01,help="initial learining rate")
parse.add_argument("--max_steps",type=int,default=2000,help="max")
parse.add_argument("--hidden1",type=int,default=100,help="hidden1")
flags,unparsed=parse.parse_known_args(sys.argv[1:])
print flags.learning_rate
print flags.max_steps
print flags.hidden1
print unparsed

输出结果：

20.0
10
100
[]

程序：

20.0
10
100
这两个函数的功能差不多

Python 讲堂　parse_args()详解

1. 初始化

2. type:

3. 可选参数：

4.参数简写:

5.混合定位参数和可选参数：

6.高级用法：

注意点：

常用的参数：

7.dest：

猜你喜欢

Python 讲堂 parse_args()详解

1. 初始化

2. type:

3. 可选参数：

4.参数简写:

5.混合定位参数和可选参数：

6.高级用法：

注意点：

常用的参数：

7.dest：

猜你喜欢

Python 讲堂　parse_args()详解