Python 命令行解析工具 Argparse介绍

Python 命令行解析工具 Argparse介绍（一）

最近在研究Python的命令行解析工具，argparse，它是python标准库中推荐使用的编写命令行程序的工具。

以前老是做UI程序，今天试了下命令行程序，感觉相当好，不用再花大把时间去研究界面问题，尤其是vc++中尤其繁琐。

现在用python来实现命令行，核心计算模块可以用c自己写扩展库，效果挺好。

学习了argparse，在官方文档中找到一篇toturial，简单翻译了下。

http://docs.python.org/2/howto/argparse.html#id1

Argparse Tutorial

这篇教程简明地介绍了Python标准库推荐使用的命令行参数解析模块——Argparse的使用。

基本概念

  在这篇教程中我们通过一个常见的ls命令来展示argparse的功能。

[plain]  view plain  copy

1. $ ls  
2. cpython  devguide  prog.py  pypy  rm-unused-function.patch  
3. $ ls pypy  
4. ctypes_configure  demo  dotviewer  include  lib_pypy  lib-python ...  
5. $ ls -l  
6. total 20  
7. drwxr-xr-x 19 wena wena 4096 Feb 18 18:51 cpython  
8. drwxr-xr-x  4 wena wena 4096 Feb  8 12:04 devguide  
9. -rwxr-xr-x  1 wena wena  535 Feb 19 00:05 prog.py  
10. drwxr-xr-x 14 wena wena 4096 Feb  7 00:59 pypy  
11. -rw-r--r--  1 wena wena  741 Feb 18 01:01 rm-unused-function.patch  
12. $ ls --help  
13. Usage: ls [OPTION]... [FILE]...  
14. List information about the FILEs (the current directory by default).  
15. Sort entries alphabetically if none of -cftuvSUX nor --sort is specified.  

从以上的四个命令中，我们能够了解以下几个基本概念：

• ls命令在没有参数的情况下也是可以运行的，默认打印出当前目录下的所有内容。
• 如果我们想让它展示更多内容，那么我们需要给它多一点参数。在这种情况下，我们想显示一个不同的目录，pypy。我们所做的就是明确了常见的定位参数（positional argument），这样命名是因为需要程序根据参数在命令行中的位置而决定做什么。这个概念与命令cp更为接近，它的用法是cp src dest，src表示的是你想要拷贝的文件，dest表示你想要将文件拷贝到哪里。
• 现在，我想要改变程序的行为。在我们的例子中，我想显示文件的向西信息而不仅仅是文件名，参数-l 则是我们所知道的可选参数(optinal argument)
• 最后一句是显示帮助的文档的一个片段，当你遇到你从未使用过的命令时，你可以通过它学习怎么使用。

基本认识

    我们从一个基本的程序开始（它什么也不做）

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.parse_args()  

运行结果：

[plain]  view plain  copy

1. $ python prog.py  
2. $ python prog.py --help  
3. usage: prog.py [-h]  
4.   
5. optional arguments:  
6.   -h, --help  show this help message and exit  
7. $ python prog.py --verbose  
8. usage: prog.py [-h]  
9. prog.py: error: unrecognized arguments: --verbose  
10. $ python prog.py foo  
11. usage: prog.py [-h]  
12. prog.py: error: unrecognized arguments: foo  

结果分析：

• 若不给参数而运行这个程序，将不会得到任何结果。
• 第二条命名显示了使用的argparse的好处，你什么也没做，却得到了一个很好的帮助信息。
• 我们无需人为设置--help参数，就能得到一个良好的帮助信息。但是若给其他参数（比如foo）就会产生一个错误。

位置参数

   首先，给一个例子：

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("echo")  
4. args = parser.parse_args()  
5. print args.echo  

运行结果:

[plain]  view plain  copy

1. $ python prog.py  
2. usage: prog.py [-h] echo  
3. prog.py: error: the following arguments are required: echo  
4. $ python prog.py --help  
5. usage: prog.py [-h] echo  
6.   
7. positional arguments:  
8.   echo  
9.   
10. optional arguments:  
11.   -h, --help  show this help message and exit  
12. $ python prog.py foo  
13. foo  

结果分析：

• 这次，我们增加了一个add_argument()方法，用来设置程序可接受的命令行参数。
• 现在要运行程序，就必须设置一个参数。
• parse_args()方法实际上从我们的命令行参数中返回了一些数据，在上面的例子中是echo
• 这个像“魔法”一样的过程，是argparse自动完成的。

尽管自动产生的帮助信息展示地很美观，但是我们仍然无法只根据echo这个参数知道它是做什么的。所以，我们增加了一些东西，使得它变得更有用。

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("echo", help="echo the string you use here")  
4. args = parser.parse_args()  
5. print args.echo  

运行结果：

[plain]  view plain  copy

1. $ python prog.py -h  
2. usage: prog.py [-h] echo  
3.   
4. positional arguments:  
5.   echo        echo the string you use here  
6.   
7. optional arguments:  
8.   -h, --help  show this help message and exit  

在此基础上，我们再多改变一点：（计算输入参数square的平方）

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("square", help="display a square of a given number")  
4. args = parser.parse_args()  
5. print args.square**2  

下面是运行结果：

[plain]  view plain  copy

1. $ python prog.py 4  
2. Traceback (most recent call last):  
3.   File "prog.py", line 5, in <module>  
4.     print args.square**2  
5. TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'  

这个程序并不能正确运行，因为argparse会将输入当作字符串处理，所以我们需要设置它的类型：（type=int）

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("square", help="display a square of a given number",  
4.                     type=int)  
5. args = parser.parse_args()  
6. print args.square**2  

下面是运行结果:

[plain]  view plain  copy

1. $ python prog.py 4  
2. 16  
3. $ python prog.py four  
4. usage: prog.py [-h] square  
5. prog.py: error: argument square: invalid int value: 'four'  

现在，这个程序能够顺利运行，而且能够处理一些错误输入。

这是我看到的一篇Python文档挺好的译文，但是只翻译到了这儿，我将继续向后翻译与argparse有关的内容。

——————————————————————————————————————————————————————————————————

可选参数

到目前为止，我们已经使用了位置参数。让我们来看下如何使用可选参数。

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("--verbosity", help="increase output verbosity")  
4. args = parser.parse_args()  
5. if args.verbosity:  
6.     print "verbosity turned on"  

接下来是输出：

[plain]  view plain  copy

1. $ python prog.py --verbosity 1  
2. verbosity turned on  
3. $ python prog.py  
4. $ python prog.py --help  
5. usage: prog.py [-h] [--verbosity VERBOSITY]  
6.   
7. optional arguments:  
8.   -h, --help            show this help message and exit  
9.   --verbosity VERBOSITY  
10.                         increase output verbosity  
11. $ python prog.py --verbosity  
12. usage: prog.py [-h] [--verbosity VERBOSITY]  
13. prog.py: error: argument --verbosity: expected one argument  

结果分析：

• 当--verbosity被指定时程序会输出回显，当没被指定时没有显示。
  
• 显示的那个参数是可选的，即使没有它程序也会正常运行。注意，在默认情况下如果参数没有被使用，那么相关的变量例如本例中的args.verbosity将被指定一个None值。
  
• 帮助信息有一点不同。
  
• 当使用--verbosity参数的时候它必须被指定一个值，任何一个。

上面的例子 中--verbosity能够接受任意整数的值，但是对于我们简单的程序来说只有两个可用的值，True or Flash。让我们修改相应的代码：

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("--verbose", help="increase output verbosity",  
4.                     action="store_true")  
5. args = parser.parse_args()  
6. if args.verbose:  
7.    print "verbosity turned on"  

结果分析：

• 现在选项并不是需要一个值，我甚至改变了它的名字用来匹配这个说法。注意，我们指定了一个新的关键词action，并且给他赋值为"store_true"。它的意思是，如果选项被指定了则将True赋值给args.verbose，没有指定则赋值Flash。
• 当你指定一个值的时候它才被解释为True值。
• 注意帮助信息的不同。
  

短选项

如果你熟悉命令行用法，你会注意到我还没有触及短选项的主题。这很简单：

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("-v", "--verbose", help="increase output verbosity",  
4.                     action="store_true")  
5. args = parser.parse_args()  
6. if args.verbose:  
7.     print "verbosity turned on"  

接下来是输出 ：

[plain]  view plain  copy

1. $ python prog.py -v  
2. verbosity turned on  
3. $ python prog.py --help  
4. usage: prog.py [-h] [-v]  
5.   
6. optional arguments:  
7.   -h, --help     show this help message and exit  
8.   -v, --verbose  increase output verbosity  

请注意，新的功能也会显示在帮助信息上。

结合位置参数与可选参数

我们的程序不断增加复杂性：

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("square", type=int,  
4.                     help="display a square of a given number")  
5. parser.add_argument("-v", "--verbose", action="store_true",  
6.                     help="increase output verbosity")  
7. args = parser.parse_args()  
8. answer = args.square**2  
9. if args.verbose:  
10.     print "the square of {} equals {}".format(args.square, answer)  
11. else:  
12.     print answer  

接下来是输出：

[plain]  view plain  copy

1. $ python prog.py  
2. usage: prog.py [-h] [-v] square  
3. prog.py: error: the following arguments are required: square  
4. $ python prog.py 4  
5. 16  
6. $ python prog.py 4 --verbose  
7. the square of 4 equals 16  
8. $ python prog.py --verbose 4  
9. the square of 4 equals 16  

• 我们输入了位置参数，所以程序会有反应
  
• 次序无关紧要

我们如何给程序多个值并去利用他们呢：

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("square", type=int,  
4.                     help="display a square of a given number")  
5. parser.add_argument("-v", "--verbosity", type=int,  
6.                     help="increase output verbosity")  
7. args = parser.parse_args()  
8. answer = args.square**2  
9. if args.verbosity == 2:  
10.     print "the square of {} equals {}".format(args.square, answer)  
11. elif args.verbosity == 1:  
12.     print "{}^2 == {}".format(args.square, answer)  
13. else:  
14.     print answer  

接下来是输出：

[plain]  view plain  copy

1. $ python prog.py 4  
2. 16  
3. $ python prog.py 4 -v  
4. usage: prog.py [-h] [-v VERBOSITY] square  
5. prog.py: error: argument -v/--verbosity: expected one argument  
6. $ python prog.py 4 -v 1  
7. 4^2 == 16  
8. $ python prog.py 4 -v 2  
9. the square of 4 equals 16  
10. $ python prog.py 4 -v 3  
11. 16  

除了最后一行，上面的测试都非常完美，它暴露了我们程序的一个小bug。现在我们通过限定--verbosity的值来修改它：

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("square", type=int,  
4.                     help="display a square of a given number")  
5. parser.add_argument("-v", "--verbosity", type=int, choices=[0, 1, 2],  
6.                     help="increase output verbosity")  
7. args = parser.parse_args()  
8. answer = args.square**2  
9. if args.verbosity == 2:  
10.     print "the square of {} equals {}".format(args.square, answer)  
11. elif args.verbosity == 1:  
12.     print "{}^2 == {}".format(args.square, answer)  
13. else:  
14.     print answer  

接下来是输出：

[python]  view plain  copy

1. $ python prog.py 4 -v 3  
2. usage: prog.py [-h] [-v {0,1,2}] square  
3. prog.py: error: argument -v/--verbosity: invalid choice: 3 (choose from 0, 1, 2)  
4. $ python prog.py 4 -h  
5. usage: prog.py [-h] [-v {0,1,2}] square  
6.   
7. positional arguments:  
8.   square                display a square of a given number  
9.   
10. optional arguments:  
11.   -h, --help            show this help message and exit  
12.   -v {0,1,2}, --verbosity {0,1,2}  
13.                         increase output verbosity  

注意，这些变化也体现在错误信息和帮助信息上。

让我们来使用一种不同的方法来处理verbosity参数，这是很常见的方法。这也是CPython 用来处理自己冗长的的参数的办法（查看输出python --help）：

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("square", type=int,  
4.                     help="display the square of a given number")  
5. parser.add_argument("-v", "--verbosity", action="count",  
6.                     help="increase output verbosity")  
7. args = parser.parse_args()  
8. answer = args.square**2  
9. if args.verbosity == 2:  
10.     print "the square of {} equals {}".format(args.square, answer)  
11. elif args.verbosity == 1:  
12.     print "{}^2 == {}".format(args.square, answer)  
13. else:  
14.     print answer  

我们来介绍另一个action的参数，”count“，它用来计算一个特定的可选参数出现的次数：

[plain]  view plain  copy

1. $ python prog.py 4  
2. 16  
3. $ python prog.py 4 -v  
4. 4^2 == 16  
5. $ python prog.py 4 -vv  
6. the square of 4 equals 16  
7. $ python prog.py 4 --verbosity --verbosity  
8. the square of 4 equals 16  
9. $ python prog.py 4 -v 1  
10. usage: prog.py [-h] [-v] square  
11. prog.py: error: unrecognized arguments: 1  
12. $ python prog.py 4 -h  
13. usage: prog.py [-h] [-v] square  
14.   
15. positional arguments:  
16.   square           display a square of a given number  
17.   
18. optional arguments:  
19.   -h, --help       show this help message and exit  
20.   -v, --verbosity  increase output verbosity  
21. $ python prog.py 4 -vvv  
22. 16  

• 是的，在我们前面的脚本中出了一个标志参数（就像action="store_true"），并且给出了相应的解释。
• 他们的行为都和action="store_true"相似。
• 刚刚我们演示了一下”计数“功能，在这之前你可能看到过这种做法。
• 并且，就像action="store_true"功能一样，如果你没有指定”-v“一个参数值，那它被视为一个None值。
• 可以预料，如果指定长形式的参数，我们可以得到同样的输出。
• 遗憾的是，我们的帮助信息并不能识别脚本新的功能，但是我们可以进一步优化我们的脚本（例如：修改帮助参数的关键字）。
• 最后一行输出暴露了我们程序的一个bug。

现在修复它：

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("square", type=int,  
4.                     help="display a square of a given number")  
5. parser.add_argument("-v", "--verbosity", action="count",  
6.                     help="increase output verbosity")  
7. args = parser.parse_args()  
8. answer = args.square**2  
9.   
10. # bugfix: replace == with >=  
11. if args.verbosity >= 2:  
12.     print "the square of {} equals {}".format(args.square, answer)  
13. elif args.verbosity >= 1:  
14.     print "{}^2 == {}".format(args.square, answer)  
15. else:  
16.     print answer  

接下来是输出：

[plain]  view plain  copy

1. $ python prog.py 4 -vvv  
2. the square of 4 equals 16  
3. $ python prog.py 4 -vvvv  
4. the square of 4 equals 16  
5. $ python prog.py 4  
6. Traceback (most recent call last):  
7.   File "prog.py", line 11, in <module>  
8.     if args.verbosity >= 2:  
9. TypeError: unorderable types: NoneType() >= int()  

#译者注：在Python2.X中并不会出现这个错误，但在Python3.X下会报错，Python3相对于Python2修改了很多地方。

• 第一行的输出还是很好的，修复了之前的bug，使我们可以输入任意>=2的数。
  
• 第三行输出出了问题。

让我们修复bug：

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("square", type=int,  
4.                     help="display a square of a given number")  
5. parser.add_argument("-v", "--verbosity", action="count", default=0,  
6.                     help="increase output verbosity")  
7. args = parser.parse_args()  
8. answer = args.square**2  
9. if args.verbosity >= 2:  
10.     print "the square of {} equals {}".format(args.square, answer)  
11. elif args.verbosity >= 1:  
12.     print "{}^2 == {}".format(args.square, answer)  
13. else:  
14.     print answer  

我们刚刚介绍了另一个关键字，default。我们将它设置为0使它可以与任何int类型的值比较。记住，如果一个可选参数没有被指定，那它将是默认值None，这样他就不能与int类型值比较。（因此上文才会出现 TypeError）

接下来的输出：

[plain]  view plain  copy

1. $ python prog.py 4  
2. 16  

到目前为止，虽然我们涉及的东西还很浅，但根据我们所学的知识你可以做很多你想做的东西了。

更高级的用法

我们可以强化我们的程序不止用来计算平方：

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("x", type=int, help="the base")  
4. parser.add_argument("y", type=int, help="the exponent")  
5. parser.add_argument("-v", "--verbosity", action="count", default=0)  
6. args = parser.parse_args()  
7. answer = args.x**args.y  
8. if args.verbosity >= 2:  
9.     print "{} to the power {} equals {}".format(args.x, args.y, answer)  
10. elif args.verbosity >= 1:  
11.     print "{}^{} == {}".format(args.x, args.y, answer)  
12. else:  
13.     print answer  

接下来是输出：

[python]  view plain  copy

1. $ python prog.py  
2. usage: prog.py [-h] [-v] x y  
3. prog.py: error: the following arguments are required: x, y  
4. $ python prog.py -h  
5. usage: prog.py [-h] [-v] x y  
6.   
7. positional arguments:  
8.   x                the base  
9.   y                the exponent  
10.   
11. optional arguments:  
12.   -h, --help       show this help message and exit  
13.   -v, --verbosity  
14. $ python prog.py 4 2 -v  
15. 4^2 == 16  

可以看出到目前为止，我们使用--verbosity来控制文本输出，接下来的例子我们将使用它显示更多的文本：

[python]  view plain  copy

1. import argparse  
2. parser = argparse.ArgumentParser()  
3. parser.add_argument("x", type=int, help="the base")  
4. parser.add_argument("y", type=int, help="the exponent")  
5. parser.add_argument("-v", "--verbosity", action="count", default=0)  
6. args = parser.parse_args()  
7. answer = args.x**args.y  
8. if args.verbosity >= 2:  
9.     print "Running '{}'".format(__file__)  
10. if args.verbosity >= 1:  
11.     print "{}^{} ==".format(args.x, args.y),  
12. print answer  

接下来是输出：

[plain]  view plain  copy

1. $ python prog.py 4 2  
2. 16  
3. $ python prog.py 4 2 -v  
4. 4^2 == 16  
5. $ python prog.py 4 2 -vv  
6. Running 'prog.py'  
7. 4^2 == 16  

冲突选项

到目前为止我们已经了解了argparse.ArgumentParser的两种实例方法，现在我们来介绍第三种，argparse.ArgumentParser()。它允许我们定义冲突的选项。现在我们修改一下程序，使它的功能更具有实用性：我们将介绍--quite选项，它与--verbosity相反：

[python]  view plain  copy

1. import argparse  
2.   
3. parser = argparse.ArgumentParser()  
4. group = parser.add_mutually_exclusive_group()  
5. group.add_argument("-v", "--verbose", action="store_true")  
6. group.add_argument("-q", "--quiet", action="store_true")  
7. parser.add_argument("x", type=int, help="the base")  
8. parser.add_argument("y", type=int, help="the exponent")  
9. args = parser.parse_args()  
10. answer = args.x**args.y  
11.   
12. if args.quiet:  
13.     print answer  
14. elif args.verbose:  
15.     print "{} to the power {} equals {}".format(args.x, args.y, answer)  
16. else:  
17.     print "{}^{} == {}".format(args.x, args.y, answer)  

现在我们的程序很简单，因为我们去掉一些演示的功能，它的输出如下：

[sql]  view plain  copy

1. $ python prog.py 4 2  
2. 4^2 == 16  
3. $ python prog.py 4 2 -q  
4. 16  
5. $ python prog.py 4 2 -v  
6. 4 to the power 2 equals 16  
7. $ python prog.py 4 2 -vq  
8. usage: prog.py [-h] [-v | -q] x y  
9. prog.py: error: argument -q/--quiet: not allowed with argument -v/--verbose  
10. $ python prog.py 4 2 -v --quiet  
11. usage: prog.py [-h] [-v | -q] x y  
12. prog.py: error: argument -q/--quiet: not allowed with argument -v/--verbose  

这很容易理解，我所增加的最后一个输出向你展示了这种操作的灵活性--------长短参数掺杂使用。

在我们结束之前，你可能想让你的用户知道程序主要的作用，万一他们不知道：

[python]  view plain  copy

1. import argparse  
2.   
3. parser = argparse.ArgumentParser(description="calculate X to the power of Y")  
4. group = parser.add_mutually_exclusive_group()  
5. group.add_argument("-v", "--verbose", action="store_true")  
6. group.add_argument("-q", "--quiet", action="store_true")  
7. parser.add_argument("x", type=int, help="the base")  
8. parser.add_argument("y", type=int, help="the exponent")  
9. args = parser.parse_args()  
10. answer = args.x**args.y  
11.   
12. if args.quiet:  
13.     print answer  
14. elif args.verbose:  
15.     print "{} to the power {} equals {}".format(args.x, args.y, answer)  
16. else:  
17.     print "{}^{} == {}".format(args.x, args.y, answer)  

dest：如果提供dest，例如dest="a"，那么可以通过args.a访问该参数
注意usage信息的不同，以及[-v | -q]，我们只能使用-v或者-q，但不能同时使用：

[plain]  view plain  copy

1. $ python prog.py --help  
2. usage: prog.py [-h] [-v | -q] x y  
3.   
4. calculate X to the power of Y  
5.   
6. positional arguments:  
7.   x              the base  
8.   y              the exponent  
9.   
10. optional arguments:  
11.   -h, --help     show this help message and exit  
12.   -v, --verbose  
13.   -q, --quiet  

结论

比起我们展示的内容，argparse模块提供了更多的信息。它的文档非常详细和深入，并且包含很多例子。学习了本教程你应该很容易消化这些知识，而不至于感到不知所措。

译者注：水平有限，如有不当，还请指正。

文章转自：http://blog.csdn.net/guojuxia/article/details/44462807