编程部落

Python中argparse模块命令行参数详细解析

作者：

风君子

在

文章目录
  • argparse 是 Python 标准库中用于解析命令行参数的模块，主要包括： 自动生成帮助和使用信息 支持位置参数和可选参数 多种参数类型和验证与子命令系统支持 自动错误处理 通过合理使用 argparse，可以轻松创建用户友好的命令行工具，提高脚本的可用性和可维护性。
  • Python 的 argparse 模块能够自动生成帮助和使用信息。
  • argparse 模块支持两种主要类型的参数：位置参数(positional arguments)和可选参数(optional arguments),它们在命令行中的使用方式和定义方法有所不同。
  • argparse 提供了多种参数类型和验证机制，确保用户输入符合预期。
  • argparse 模块提供了自动错误处理功能，能够检测和报告用户输入中的各种问题。
    • 目录
    • 一、argparse的主要功能
    • 二、自动生成帮助和使用信息
      • 1. 基本用法
      • 2. 自定义帮助信息
      • 3. 高级格式化
    • 三、位置参数和可选参数
      • 1. 位置参数
      • 2. 可选参数
      • 3. 位置参数与可选参数对比
      • 4. 混合使用示例
    • 四、多种参数类型和验证和子命令系统
      • 1. 基本参数类型
        • 指定参数类型
        • 常用内置类型
      • 2. 参数验证
        • 范围验证
        • 正则表达式验证
      • 3. 高级参数处理
        • 列表参数
        • 布尔参数
        • 计数参数
      • 4. 参数组
        • 互斥参数
        • 参数分组
      • 5. 子命令
        • 6. 默认值和必需参数
          • 7. 自定义参数处理
          • 五、自动错误处理
            • 1. 内置自动错误检测
              • 参数缺失错误
              • 无效参数错误
              • 类型转换错误
              • 参数值验证错误
            • 2. 自定义错误处理
              • 方法1：自定义类型验证函数
              • 方法2：自定义 Action 类
              • 方法3：后解析验证
            • 3. 错误处理配置
              • 自定义错误消息格式
              • 控制退出行为
            • 4. 错误处理技巧
              • 显示更友好的错误消息
              • 收集所有错误而非立即退出
            • 5. 错误处理总结
            • 六、应用与实践
              • 1. 需要用户输入参数的脚本
                • 2. 需要支持可选参数和默认值的脚本
                  • 3. 需要子命令的 CLI 工具（类似git）
                    • 4. 需要自动生成帮助文档（–help）
                      • 5. 需要参数类型检查和错误提示
                        • 6. 替代sys.argv手动解析

                        argparse 是 Python 标准库中用于解析命令行参数的模块，主要包括：

                        1. 自动生成帮助和使用信息
                        2. 支持位置参数和可选参数
                        3. 多种参数类型和验证与子命令系统支持
                        4. 自动错误处理

                        通过合理使用 argparse，可以轻松创建用户友好的命令行工具，提高脚本的可用性和可维护性。

                        Python 的 argparse 模块能够自动生成帮助和使用信息。

                        使用 argparse 创建解析器并添加参数后，它会自动处理 -h 或 –help 参数并显示帮助信息：

                        import argparse
# 创建解析器
parser = argparse.ArgumentParser(description='这是一个示例程序')
# 添加参数
parser.add_argument('filename', help='输入文件名')
parser.add_argument('-v', '--verbose', action='store_true', help='显示详细输出')
parser.add_argument('--output', help='输出文件名')
# 解析参数
args = parser.parse_args()

                        运行这个脚本并加上 -h 或 –help 参数：

                        python script.py -h

                        自动生成的帮助信息：

                        usage: script.py [-h] [-v] [--output OUTPUT] filename
这是一个示例程序
positional arguments:
  filename         输入文件名
optional arguments:
  -h, --help       show this help message and exit
  -v, --verbose    显示详细输出
  --output OUTPUT  输出文件名

                        程序描述：通过 ArgumentParser 的 description 参数

                        parser = argparse.ArgumentParser(description='这是一个详细的程序描述')

                        参数帮助：通过 add_argument 的 help 参数

                        parser.add_argument('--input', help='指定输入文件路径')

                        用法示例：通过 ArgumentParser 的 epilog 参数添加结尾文本

                        parser = argparse.ArgumentParser(
    description='程序描述',
    epilog='示例:n  python script.py input.txt --output result.txt'
)

                        自定义帮助选项：通过 add_help 参数禁用默认帮助或自定义帮助选项

                        parser = argparse.ArgumentParser(add_help=False)  # 禁用默认帮助
parser.add_argument('-?', action='help', help='显示帮助信息')  # 自定义帮助选项

                        argparse 还允许通过 formatter_class 参数自定义帮助信息的格式：

                        # 保留空白字符和换行
parser = argparse.ArgumentParser(
    formatter_class=argparse.RawDescriptionHelpFormatter,
    description='''
        第一行描述
        第二行描述
            缩进的内容'''
)
# 更紧凑的格式
parser = argparse.ArgumentParser(
    formatter_class=argparse.ArgumentDefaultsHelpFormatter
)  # 会显示参数的默认值

                        argparse 模块支持两种主要类型的参数：位置参数(positional arguments)和可选参数(optional arguments),它们在命令行中的使用方式和定义方法有所不同。

                        位置参数是必须提供的参数，它们的顺序很重要，名称不需要在命令行中指定。
                        特点
                        必须提供：调用程序时必须指定
                        顺序敏感：参数值的位置决定其含义
                        无前缀：不需要使用 – 或 – 前缀
                        定义方法

                        parser.add_argument('filename', help='输入文件名')
parser.add_argument('output_dir', help='输出目录')

                        使用示例

                        python script.py input.txt output/

                        input.txt 对应 filename 参数
                        output/ 对应 output_dir 参数
                        高级用法

                        # 接受多个值
parser.add_argument('files', nargs='+', help='一个或多个文件')
# 固定数量参数
parser.add_argument('coordinates', nargs=2, metavar=('X', 'Y'), help='X和Y坐标')

                        可选参数通常以 – 或 – 开头，可以按任意顺序提供。
                        特点
                        可选提供：可以省略（除非设置 required=True）
                        顺序无关：可以任意顺序指定
                        有前缀：使用 -（短参数）或 –（长参数）前缀
                        定义方法

                        parser.add_argument('-v', '--verbose', action='store_true', help='详细输出')
parser.add_argument('-o', '--output', help='输出文件路径')
parser.add_argument('--count', type=int, default=1, help='重复次数')

                        使用示例

                        python script.py --verbose -o result.txt
# 或
python script.py -v --output=result.txt

                        特性 位置参数 可选参数
                        必要性 必须提供 可选(除非设置 required=True)
                        前缀 无 – 或 —
                        顺序 重要 不重要
                        典型用途 主要输入(如文件名) 选项和标志
                        默认值 不常见 常见
                        多值支持 常见(nargs=‘+’) 也支持 

                        import argparse
parser = argparse.ArgumentParser(description='文件处理工具')
# 位置参数
parser.add_argument('source', help='源文件路径')
parser.add_argument('destination', help='目标路径')
# 可选参数
parser.add_argument('-c', '--copy', action='store_true', help='复制模式')
parser.add_argument('-m', '--move', action='store_true', help='移动模式')
parser.add_argument('--size', type=int, choices=[1, 2, 4], help='块大小(1,2或4KB)')
parser.add_argument('-v', '--verbose', action='count', default=0, 
                   help='输出详细程度(-v, -vv, -vvv)')
args = parser.parse_args()
print(f"源: {args.source}")
print(f"目标: {args.destination}")
print(f"模式: {'移动' if args.move else '复制'}")
print(f"详细级别: {args.verbose}")

                        argparse 提供了多种参数类型和验证机制，确保用户输入符合预期。

                        使用 type 参数可以指定输入值的类型：

                        parser.add_argument('--num', type=int, help='整数参数')
parser.add_argument('--size', type=float, help='浮点数参数')
parser.add_argument('--file', type=argparse.FileType('r'), help='输入文件')

                        int: 整数
                        float: 浮点数
                        str: 字符串(默认)
                        argparse.FileType(‘r’/‘w’): 文件对象(自动打开)

                        通过自定义函数或结合 choices 实现：

                        # 使用 choices 限制可选值
parser.add_argument('--color', choices=['red', 'green', 'blue'], help='颜色选择')
# 自定义验证函数
def check_positive(value):
    ivalue = int(value)
    if ivalue <= 0:
        raise argparse.ArgumentTypeError(f"{value} 必须是正数")
    return ivalue
parser.add_argument('--positive', type=check_positive)

                        import re
def validate_email(email):
    if not re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}$', email):
        raise argparse.ArgumentTypeError(f"'{email}' 不是有效的邮箱地址")
    return email
parser.add_argument('--email', type=validate_email)

                        # 接收多个值
parser.add_argument('--nums', nargs='+', type=int, help='多个整数')
# 固定数量参数
parser.add_argument('--coords', nargs=2, metavar=('X', 'Y'), help='X Y 坐标')

                        # 开关型参数
parser.add_argument('--enable', action='store_true', help='启用功能')
parser.add_argument('--disable', action='store_false', dest='enable', help='禁用功能')
# 另一种方式
parser.add_argument('--flag', action=argparse.BooleanOptionalAction, help='布尔标志')

                        parser.add_argument('-v', '--verbose', action='count', default=0, 
                   help='增加输出详细程度(如 -vvv)')


                        group = parser.add_mutually_exclusive_group(required=True)
group.add_argument('--create', action='store_true', help='创建模式')
group.add_argument('--delete', action='store_true', help='删除模式')


                        parser = argparse.ArgumentParser()
input_group = parser.add_argument_group('输入选项')
input_group.add_argument('--input-file', help='输入文件')
input_group.add_argument('--input-dir', help='输入目录')
output_group = parser.add_argument_group('输出选项')
output_group.add_argument('--output-file', help='输出文件')

                        parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest='command', required=True)
# 创建子命令
parser_create = subparsers.add_parser('create', help='创建资源')
parser_create.add_argument('name', help='资源名称')
# 删除子命令
parser_delete = subparsers.add_parser('delete', help='删除资源')
parser_delete.add_argument('id', type=int, help='资源ID')

                        parser.add_argument('--port', type=int, default=8080, help='端口号(默认: 8080)')
parser.add_argument('--username', required=True, help='必须指定用户名')


                        class PercentageAction(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        if not 0 <= values <= 100:
            raise argparse.ArgumentError(self, "必须在0-100之间")
        setattr(namespace, self.dest, values)
parser.add_argument('--percent', type=int, action=PercentageAction, help='百分比(0-100)')

                        argparse 模块提供了自动错误处理功能，能够检测和报告用户输入中的各种问题。

                        argparse 会自动处理以下常见错误情况。

                        # 当必需参数未提供时
parser.add_argument('required_arg', help='必需参数')
# 用户未提供时会自动报错


                        # 当用户提供了未定义的参数时
# 例如用户输入 --unknown 但未定义此参数


                        parser.add_argument('--num', type=int)
# 用户输入非数字时会自动报错：error: argument --num: invalid int value: 'abc'


                        parser.add_argument('--size', choices=['S', 'M', 'L'])
# 用户输入无效选项时会报错


                        def positive_int(value):
    try:
        ivalue = int(value)
        if ivalue <= 0:
            raise argparse.ArgumentTypeError(f"{value} 必须是正整数")
        return ivalue
    except ValueError:
        raise argparse.ArgumentTypeError(f"'{value}' 不是有效整数")
parser.add_argument('--count', type=positive_int)

                        class RangeAction(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        if not 0 <= values <= 100:
            parser.error(f"{option_string} 必须在0到100之间")
        setattr(namespace, self.dest, values)
parser.add_argument('--percent', type=int, action=RangeAction)

                        def validate_args(args):
    if args.start > args.end:
        raise ValueError("开始值不能大于结束值")
parser.add_argument('--start', type=int)
parser.add_argument('--end', type=int)
args = parser.parse_args()
try:
    validate_args(args)
except ValueError as e:
    parser.error(str(e))

                        parser = argparse.ArgumentParser(
    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
    epilog="遇到错误时请联系支持团队"
)


                        try:
    args = parser.parse_args()
except argparse.ArgumentError as e:
    print(f"参数错误: {e}")
    parser.print_help()
    sys.exit(2)  # Unix惯例: 2表示命令行用法错误


                        try:
    args = parser.parse_args()
except argparse.ArgumentTypeError as e:
    print(f"错误: {e}")
    print("请输入 --help 查看用法")
    sys.exit(1)


                        parser = argparse.ArgumentParser(exit_on_error=False)
try:
    args = parser.parse_args()
except argparse.ArgumentError as e:
    errors.append(str(e))

                        1. 提供清晰的错误消息：确保错误信息能指导用户正确使用
                        2. 一致性：保持错误格式一致，便于用户理解
                        3. 防御性编程：对关键参数进行额外验证
                        4. 适当退出代码：使用标准退出代码(如2表示用法错误)
                        5. 记录错误：对于复杂应用，考虑记录错误日志

                        当 Python 脚本需要接收外部输入（如文件路径、配置选项、运行模式等）时，argparse 可以方便地解析命令行参数，而不是硬编码在代码中。

                        示例场景

                        • 数据处理脚本需要输入文件路径
                        • 机器学习训练脚本需要调整超参数（如学习率、批次大小）
                        • 日志分析工具需要指定时间范围或过滤条件

                        示例代码

                        import argparse
parser = argparse.ArgumentParser(description="处理CSV文件")
parser.add_argument("input_file", help="输入CSV文件路径")
parser.add_argument("--output", "-o", help="输出文件路径（可选）")
parser.add_argument("--delimiter", default=",", help="分隔符（默认：逗号）")
args = parser.parse_args()
print(f"处理文件: {args.input_file}")
if args.output:
    print(f"输出到: {args.output}")
print(f"分隔符: {args.delimiter}")

                        如果你的脚本有些参数是可选的，并且需要默认值，argparse 可以轻松管理这些参数。

                        示例场景

                        • 爬虫脚本可以设置 --delay（默认 1 秒）控制请求间隔
                        • 图像处理脚本可以设置 --quality（默认 90）控制输出质量
                        • 数据库备份脚本可以设置 --compress（默认 True）控制是否压缩

                        示例代码

                        import argparse
parser = argparse.ArgumentParser(description="爬虫脚本")
parser.add_argument("--delay", type=float, default=1.0, help="请求间隔（秒）")
parser.add_argument("--max-pages", type=int, default=10, help="最大爬取页数")
parser.add_argument("--headless", action="store_true", help="是否使用无头模式")
args = parser.parse_args()
print(f"请求间隔: {args.delay} 秒")
print(f"最大爬取页数: {args.max_pages}")
if args.headless:
    print("使用无头模式")

                        如果你的工具支持多个子命令（如 git commit、git push），argparse 的 subparsers 功能可以很好地组织代码。

                        示例场景

                        • 版本控制工具（类似 git）
                        • 数据库管理工具（db backup、db restore）
                        • 系统管理工具（system start、system stop）

                        示例代码

                        import argparse
parser = argparse.ArgumentParser(description="数据库管理工具")
subparsers = parser.add_subparsers(dest="command", required=True)
# 子命令：backup
backup_parser = subparsers.add_parser("backup", help="备份数据库")
backup_parser.add_argument("--output", required=True, help="备份文件路径")
backup_parser.add_argument("--compress", action="store_true", help="是否压缩")
# 子命令：restore
restore_parser = subparsers.add_parser("restore", help="恢复数据库")
restore_parser.add_argument("input", help="备份文件路径")
args = parser.parse_args()
if args.command == "backup":
    print(f"备份数据库到: {args.output}")
    if args.compress:
        print("启用压缩")
elif args.command == "restore":
    print(f"从 {args.input} 恢复数据库")

                        argparse 自动生成 --help 信息，用户无需手动编写帮助文本。

                        示例代码：

                        import argparse
parser = argparse.ArgumentParser(description="一个示例程序")
parser.add_argument("input", help="输入文件")
parser.add_argument("--output", "-o", help="输出文件")
parser.add_argument("--verbose", "-v", action="store_true", help="显示详细日志")
args = parser.parse_args()

                        运行 python script.py --help 会输出：

                        usage: script.py [-h] [--output OUTPUT] [--verbose] input
一个示例程序
positional arguments:
  input                 输入文件
optional arguments:
  -h, --help            show this help message and exit
  --output OUTPUT, -o OUTPUT
                        输出文件
  --verbose, -v        显示详细日志

                        argparse 可以自动检查参数类型（如 int、float），并提示错误。

                        示例场景：

                        • 如果用户输入 --count abc（期望是整数），argparse 会报错
                        • 如果用户输入 --mode fast，但 choices=["slow", "medium"]，会提示无效选项

                        示例代码

                        import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--count", type=int, help="必须输入整数")
parser.add_argument("--mode", choices=["slow", "medium", "fast"], default="medium")
args = parser.parse_args()
print(f"Count: {args.count}")
print(f"Mode: {args.mode}")

                        如果用户输入 --count abc，会报错：

                        error: argument --count: invalid int value: 'abc'

                        如果你之前用 sys.argv 手动解析参数，argparse 可以更优雅地处理复杂参数。

                        sys.argv 手动解析（不推荐）

                        import sys
if len(sys.argv) < 2:
    print("Usage: script.py <input> [--output OUTPUT]")
    sys.exit(1)
input_file = sys.argv[1]
output_file = None
if "--output" in sys.argv:
    output_index = sys.argv.index("--output") + 1
    if output_index < len(sys.argv):
        output_file = sys.argv[output_index]
print(f"Input: {input_file}")
if output_file:
    print(f"Output: {output_file}")

                        argparse 解析（推荐）

                        import argparse
parser = argparse.ArgumentParser()
parser.add_argument("input", help="输入文件")
parser.add_argument("--output", "-o", help="输出文件")
args = parser.parse_args()
print(f"Input: {args.input}")
if args.output:
    print(f"Output: {args.output}")

                        到此这篇关于Python中argparse模块命令行参数解析介绍的文章就介绍到这了,更多相关Python argparse命令行参数内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！

                        您可能感兴趣的文章:

                        • python程序运行添加命令行参数argparse模块具体用法详解
                        • 使用Python中的Argparse实现将列表作为命令行参数传递
                        • Python命令行参数解析之argparse模块详解
                        • python命令行参数argparse模块基本用法详解
                        • Python命令行参数解析包argparse的使用详解
                        • Python命令行解析器argparse详解
                        • python 如何利用argparse解析命令行参数
                        • Python解析命令行读取参数–argparse模块使用方法

                        更多文章

                        站内搜索

                        标签云

                        iphone 三星 信用卡 信贷 华为 小米 微软 快科技 手机 投资理财 支付宝 特斯拉 理财知识 电脑 科技 程序 股票 芯片 苹果 贷款 路由器 银行 银行卡 额度

                        热门文章

                        友情链接