Python argparse 如何使用

1. 概述

argparse 是 Python 标准库中的一个模块，用于处理命令行参数。它提供了一个简单而强大的接口，用于解析命令行参数并生成帮助信息。argparse 模块使得编写命令行工具变得更加容易，尤其是在需要处理复杂参数时。

本文将详细介绍如何使用 argparse 模块，包括如何定义参数、解析参数、生成帮助信息以及处理不同类型的参数。

2. 基本用法

2.1 创建一个简单的命令行工具

首先，我们来看一个最简单的例子。假设我们要编写一个命令行工具，它接受一个名字作为参数，并打印出 “Hello, [name]!“。

import argparse

# 创建 ArgumentParser 对象
parser = argparse.ArgumentParser(description="A simple greeting tool")

# 添加一个位置参数
parser.add_argument("name", help="The name to greet")

# 解析命令行参数
args = parser.parse_args()

# 使用解析后的参数
print(f"Hello, {args.name}!")

在这个例子中，我们首先导入了 argparse 模块，然后创建了一个 ArgumentParser 对象。ArgumentParser 对象用于定义命令行参数和生成帮助信息。

接下来，我们使用 add_argument 方法添加了一个位置参数 name。位置参数是指在命令行中必须提供的参数，它们的顺序决定了它们在 args 对象中的属性名。

最后，我们调用 parse_args 方法来解析命令行参数，并将结果存储在 args 对象中。我们可以通过 args.name 来访问解析后的参数值。

2.2 运行命令行工具

假设我们将上述代码保存为 greet.py，我们可以在命令行中运行它：

$ python greet.py Alice
Hello, Alice!

如果我们不提供任何参数，argparse 会自动生成帮助信息并退出：

$ python greet.py
usage: greet.py [-h] name
greet.py: error: the following arguments are required: name

2.3 生成帮助信息

argparse 会自动生成帮助信息。我们可以通过 -h 或 --help 选项来查看帮助信息：

$ python greet.py -h
usage: greet.py [-h] name

A simple greeting tool

positional arguments:
  name        The name to greet

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

3. 添加可选参数

除了位置参数，我们还可以添加可选参数。可选参数通常以 - 或 -- 开头。

3.1 添加一个简单的可选参数

假设我们想要为我们的命令行工具添加一个可选参数 --uppercase，用于将名字转换为大写。

import argparse

parser = argparse.ArgumentParser(description="A simple greeting tool")

parser.add_argument("name", help="The name to greet")
parser.add_argument("--uppercase", action="store_true", help="Convert the name to uppercase")

args = parser.parse_args()

greeting = f"Hello, {args.name}!"
if args.uppercase:
    greeting = greeting.upper()

print(greeting)

在这个例子中，我们添加了一个可选参数 --uppercase，并指定了 action="store_true"。这意味着如果用户在命令行中提供了 --uppercase 选项，args.uppercase 将被设置为 True，否则为 False。

3.2 运行带有可选参数的命令行工具

我们可以这样运行这个命令行工具：

$ python greet.py Alice --uppercase
HELLO, ALICE!

如果我们不提供 --uppercase 选项，名字将不会被转换为大写：

$ python greet.py Alice
Hello, Alice!

4. 处理不同类型的参数

argparse 支持多种类型的参数，包括字符串、整数、浮点数、布尔值等。我们可以通过 type 参数来指定参数的类型。

4.1 处理整数参数

假设我们想要编写一个命令行工具，它接受两个整数作为参数，并计算它们的和。

import argparse

parser = argparse.ArgumentParser(description="A simple addition tool")

parser.add_argument("x", type=int, help="The first number")
parser.add_argument("y", type=int, help="The second number")

args = parser.parse_args()

result = args.x + args.y
print(f"The sum of {args.x} and {args.y} is {result}")

在这个例子中，我们使用 type=int 来指定参数 x 和 y 的类型为整数。

4.2 运行带有整数参数的命令行工具

我们可以这样运行这个命令行工具：

$ python add.py 3 5
The sum of 3 and 5 is 8

如果我们提供的参数不是整数，argparse 会报错：

$ python add.py 3 foo
usage: add.py [-h] x y
add.py: error: argument y: invalid int value: 'foo'

4.3 处理浮点数参数

类似地，我们可以处理浮点数参数。假设我们想要编写一个命令行工具，它接受两个浮点数作为参数，并计算它们的乘积。

import argparse

parser = argparse.ArgumentParser(description="A simple multiplication tool")

parser.add_argument("x", type=float, help="The first number")
parser.add_argument("y", type=float, help="The second number")

args = parser.parse_args()

result = args.x * args.y
print(f"The product of {args.x} and {args.y} is {result}")

4.4 运行带有浮点数参数的命令行工具

我们可以这样运行这个命令行工具：

$ python multiply.py 3.5 2.0
The product of 3.5 and 2.0 is 7.0

5. 处理多个值

有时我们需要处理多个值的参数。argparse 提供了 nargs 参数来处理这种情况。

5.1 处理多个值的参数

假设我们想要编写一个命令行工具，它接受多个整数作为参数，并计算它们的和。

import argparse

parser = argparse.ArgumentParser(description="A simple sum tool")

parser.add_argument("numbers", type=int, nargs="+", help="The numbers to sum")

args = parser.parse_args()

result = sum(args.numbers)
print(f"The sum of {args.numbers} is {result}")

在这个例子中，我们使用 nargs="+" 来指定参数 numbers 可以接受一个或多个整数值。

5.2 运行带有多个值参数的命令行工具

我们可以这样运行这个命令行工具：

$ python sum.py 1 2 3 4 5
The sum of [1, 2, 3, 4, 5] is 15

如果我们不提供任何参数，argparse 会报错：

$ python sum.py
usage: sum.py [-h] numbers [numbers ...]
sum.py: error: the following arguments are required: numbers

6. 处理默认值

我们可以为参数指定默认值。如果用户没有提供该参数，argparse 将使用默认值。

6.1 为参数指定默认值

假设我们想要编写一个命令行工具，它接受一个可选参数 --count，用于指定打印 “Hello, World!” 的次数。如果没有提供 --count 参数，默认打印一次。

import argparse

parser = argparse.ArgumentParser(description="A simple greeting tool")

parser.add_argument("--count", type=int, default=1, help="Number of times to print the greeting")

args = parser.parse_args()

for _ in range(args.count):
    print("Hello, World!")

在这个例子中，我们使用 default=1 来指定 --count 参数的默认值为 1。

6.2 运行带有默认值的命令行工具

我们可以这样运行这个命令行工具：

$ python greet.py --count 3
Hello, World!
Hello, World!
Hello, World!

如果我们不提供 --count 参数，argparse 将使用默认值：

$ python greet.py
Hello, World!

7. 处理互斥参数

有时我们需要处理互斥参数，即用户只能提供其中一个参数。argparse 提供了 add_mutually_exclusive_group 方法来处理这种情况。

7.1 处理互斥参数

假设我们想要编写一个命令行工具，它接受两个互斥参数 --add 和 --subtract，分别用于计算两个数的和或差。

import argparse

parser = argparse.ArgumentParser(description="A simple calculator tool")

group = parser.add_mutually_exclusive_group()
group.add_argument("--add", action="store_true", help="Add the numbers")
group.add_argument("--subtract", action="store_true", help="Subtract the numbers")

parser.add_argument("x", type=int, help="The first number")
parser.add_argument("y", type=int, help="The second number")

args = parser.parse_args()

if args.add:
    result = args.x + args.y
    print(f"The sum of {args.x} and {args.y} is {result}")
elif args.subtract:
    result = args.x - args.y
    print(f"The difference of {args.x} and {args.y} is {result}")
else:
    print("Please specify either --add or --subtract")

在这个例子中，我们使用 add_mutually_exclusive_group 方法来创建一个互斥参数组，并在组中添加了 --add 和 --subtract 两个参数。

7.2 运行带有互斥参数的命令行工具

我们可以这样运行这个命令行工具：

$ python calculator.py --add 3 5
The sum of 3 and 5 is 8

$ python calculator.py --subtract 5 3
The difference of 5 and 3 is 2

如果我们不提供任何互斥参数，argparse 会提示我们指定一个：

$ python calculator.py 3 5
Please specify either --add or --subtract

8. 处理子命令

有时我们需要处理子命令，即一个命令行工具可以执行多个不同的操作。argparse 提供了 add_subparsers 方法来处理这种情况。

8.1 处理子命令

假设我们想要编写一个命令行工具，它有两个子命令 add 和 subtract，分别用于计算两个数的和或差。

import argparse

parser = argparse.ArgumentParser(description="A simple calculator tool")

subparsers = parser.add_subparsers(dest="command", help="Sub-command help")

# 添加 add 子命令
add_parser = subparsers.add_parser("add", help="Add two numbers")
add_parser.add_argument("x", type=int, help="The first number")
add_parser.add_argument("y", type=int, help="The second number")

# 添加 subtract 子命令
subtract_parser = subparsers.add_parser("subtract", help="Subtract two numbers")
subtract_parser.add_argument("x", type=int, help="The first number")
subtract_parser.add_argument("y", type=int, help="The second number")

args = parser.parse_args()

if args.command == "add":
    result = args.x + args.y
    print(f"The sum of {args.x} and {args.y} is {result}")
elif args.command == "subtract":
    result = args.x - args.y
    print(f"The difference of {args.x} and {args.y} is {result}")
else:
    print("Please specify a sub-command")

在这个例子中，我们使用 add_subparsers 方法来创建子命令，并为每个子命令添加了相应的参数。

8.2 运行带有子命令的命令行工具

我们可以这样运行这个命令行工具：

$ python calculator.py add 3 5
The sum of 3 and 5 is 8

$ python calculator.py subtract 5 3
The difference of 5 and 3 is 2

如果我们不提供任何子命令，argparse 会提示我们指定一个：

$ python calculator.py
Please specify a sub-command

9. 总结

argparse 是 Python 标准库中一个非常强大的模块，用于处理命令行参数。通过 argparse，我们可以轻松地定义和解析命令行参数，生成帮助信息，并处理不同类型的参数。本文介绍了 argparse 的基本用法，包括如何定义位置参数、可选参数、处理不同类型的参数、处理多个值、指定默认值、处理互斥参数以及处理子命令。

希望本文能帮助你更好地理解和使用 argparse 模块，编写出功能强大且易于使用的命令行工具。