argparse用法介绍 argparse入门用法

argparse 是 Python 的一个库，用于为程序提供命令行接口（Command Line Interface）。当然也可以将其用于管理程序的参数配置。

默认可选参数

  1. # test.py
  2. import argparse
  3. parser = argparse.ArgumentParser()
  4. parser.parse_args()

在命令行，输入test.py -h，那么将会有如下输出：

  1. usage: test.py [-h]
  3. optional arguments:
  4.   -h, --help  show this help message and exit

位置参数介绍

函数调用中的args和*kwargs

  1. def test(*args, **kwargs):
  2.     print(args)
  3.     print(kwargs)
  4.     print('-----------------')
  5. test(1,2,3,4)
  6. test(a=1,b=2,c=3,d=4)
  7. test(1,2,a=1,b=2,c=3)
  8. test(a=1,1,b=2,2,c=3,3)

上述代码输出：

  1.   File "test.py", line 8
  2.     test(a=1,1,b=2,2,c=3,3)
  3.             ^
  4. SyntaxError: positional argument follows keyword argument

如果删去第八行则输出如下：

  1. (1, 2, 3, 4)
  2. {}
  3. -----------------
  4. ()
  5. {'a': 1, 'b': 2, 'c': 3, 'd': 4}
  6. -----------------
  7. (1, 2)
  8. {'a': 1, 'b': 2, 'c': 3}
  9. -----------------

总结如下：

  • *args和**kwargs都可以获取可变数量的参数；
  • *args获取的是位置参数（位置参数要位于关键字参数之前，任何函数都是如此，否则会报错）；

  • **kwargs获取的是关键字参数，其实质是产生了字典；

    增加位置参数

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

  • 我们增加了 add_argument() 方法，该方法用于指定程序能够接受哪些命令行选项。在这个例子中，我将选项命名为 echo，与其功能一致。

  • add_argument()通常会传入四个参数：第一个参数名、第二个type、第三default以及第四个help。
  • 现在调用我们的程序必须要指定一个选项（与echo对应，否则会报错：与调用函数没有传递参数一样）。
  • The parse_args() method actually returns some data from the options specified, in this case, echo.
  • 这一变量是 argparse 免费施放的某种 “魔法”（即是说，不需要指定哪个变量是存储哪个值的）。你也可以注意到，这一名称与传递给方法的字符串参数一致，都是 echo。
  • 参数传递过程中都默认为字符串。

  • 位置函数和函数调用的位置参数对应，都是在调用时必须传入的（函数的位置没有默认值，但是此处的位置参数可以设定默认值，但是事实上没有任何效果）。

    可选参数

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

  • 添加可选参数与位置参数非常类似，只需要在前面加双横即可：--；

  • 可选参数与函数调用过程中的关键字参数对应，由于关键字参数已经包括默认值，可以在函数调用时不传入该参数；同理此处可选参数也是如此，但是可选参数并没有要求必须设定默认值，没有设定是将为None；

    标志可选参数

    1. import argparse
    2. parser = argparse.ArgumentParser()
    3. parser.add_argument("--flag", help="a flag variable", action='store_true', default=True)
    4. args = parser.parse_args()
    5. if args.flag:
    6.   print('OK!')
    7. else:
    8.   print('NO!')

  • action='store_true'表示意义：这意味着，当这一选项存在时，为 args.flag赋值为 True。没有指定时则隐含地赋值为 False。

    • 也就是说，此类参数，在命令行被指定时则赋值为True，否则为False；
    • 不能为其指定值，调用时直接：python test.py --flag即可（指定值时，会报错）；

  • 也可以用：parser.set_defaults(name=value)的形式赋默认值。

    短选项

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

  • 事实上，短选项就是可选参数的一个缩写形式，非常常见；

  • 原来需要：python test.py --echo 100的现在可以用：python test.py -E 100代替；

    位置参数和可选参数结合

    1. import argparse
    2. parser = argparse.ArgumentParser()
    3. parser.add_argument("-E", "--echo", help="echo the string you use here", type=str, default="hello")
    4. parser.add_argument("square", help="a number to caculate", type=int)
    5. args = parser.parse_args()
    6. print(args.echo)
    7. print(args.square)

  • 现在命令行输入：python test.py -E hello 4或者python test.py 4 -E hello，输出将是：

    1. hello
    2. 4

  • 也就是说顺序不影响，它会自动匹配位置参数和可选参数。

    引入其它参数

    限定参数可选值

    1. import argparse
    2. parser = argparse.ArgumentParser()
    3. parser.add_argument("--square", help="a number to caculate", type=int, choices=[100,200,300])
    4. args = parser.parse_args()
    5. print(args.square)

  • choices参数限定参数的可选值，如果输入的参数不在其中，那么将会报错；

    action的count实现计数

    1. import argparse
    2. parser = argparse.ArgumentParser()
    3. parser.add_argument("-c", "--counter", action="count", help="a counter", default=0)
    4. args = parser.parse_args()
    5. print(args.counter)

  • action="count"实现对参数计数；

    1. >>>python test.py -c
    2. 1
    3. >>>python test.py -ccc
    4. 3
    5. >>>python test.py -counter -ccc
    6. 4

    矛盾选项

    ```python import argparse

parser = argparse.ArgumentParser() group = parser.add_mutually_exclusive_group() group.add_argument(“-v”, “—verbose”, action=”store_true”) group.add_argument(“-q”, “—quiet”, action=”store_true”) parser.add_argument(“x”, type=int, help=”the base”) parser.add_argument(“y”, type=int, help=”the exponent”) args = parser.parse_args() answer = args.x**args.y

if args.quiet: print(answer) elif args.verbose: print(“{} to the power {} equals {}”.format(args.x, args.y, answer)) else: print(“{}^{} == {}”.format(args.x, args.y, answer)) ```

  • group = parser.add_mutually_exclusive_group()进行矛盾项初始化；
  • 通过group.add_argument()进行矛盾项参数的添加；