0

我想使用六个子命令（使用 argparse 库中的子解析器）将我的大程序分成更小的独立程序，并能够单独运行它们。换句话说，我设想一个接一个地从命令行运行六个命令，其中每个命令的结果作为下一个命令的参数输入。（或者如果使用 argparse 无法做到这一点，那么至少可以通过某种方式独立运行这六个部分中的每一个）。

我对一个解析器没有任何问题，但是当我试图了解如何使用子解析器来完成这项任务时，我发现文档太混乱了。

目前我的代码类似于

import argparse
from my_functions import (func_a, func_b, func_c, func_d, func_e, func_f)

parser = argparse.ArgumentParser()  # Top level parser
subparsers = parser.add_subparsers()

parser_a = subparsers.add_parser('parser_a', help='parser_a_help')
parser_a.set_defaults(func=func_a)
parser_a.add_argument('a_arg', type=int)

parser_b = subparsers.add_parser('parser_b', help='parser_b_help')
           parser_b.set_defaults(func=func_b)
           parser_b.add_argument('b_arg', type=int)

parser_c = subparsers.add_parser('parser_c', help='parser_c_help')
           parser_c.set_defaults(func=func_c)
           parser_c.add_argument('c_arg', type=int)

parser_d = subparsers.add_parser('parser_d', help='parser_d_help')
           parser_d.set_defaults(func=func_d)
           parser_d.add_argument('d_arg', type=int)

parser_e = subparsers.add_parser('parser_e', help='parser_e_help')
           parser_e.set_defaults(func=func_e)
           parser_e.add_argument('e_arg', type=int)

parser_f = subparsers.add_parser('parser_f', help='parser_f_help')
           parser_f.set_defaults(func=func_f)
           parser_f.add_argument('f_arg', type=int)

# Parse arguments

args = parser.parse_args()
args.func(args)

def main(a_arg, b_arg, c_arg, d_arg, e_arg, f_arg):
    #Do stuff with these args

if __name__ == "__main__":
   main(args.a_arg, args.b_arg, args.c_arg, args.d_arg, args.e_arg, args.f_arg)

所以我想要的行为是在命令行上我可以输入

$ python my_function.py parser_a 3

$ python my_function.py parser_b 5

$ python my_function.py parser_c 8

$ python my_function.py parser_d 150

$ python my_function.py parser_e 42

$ python my_function.py parser_f 2

因此，如果一个子命令出现问题，我可以独立运行该子命令进行调试。

任何帮助理解我应该做什么的逻辑将不胜感激。我什至不确定我想要的行为是否是我应该想要的行为。

4

0 回答 0