Python：除了从外部函数读取命令行参数外，还使用argparse读取命令行参数

我在同一个包中有两个模块，

module1.py

和

module2.py

在

module1.py

中，我使用

argparse

读取命令行args的函数：

import argparse

def parse_arguments_module1():
    parser = argparse.ArgumentParser()
    optional = parser._action_groups.pop()
    required = parser.add_argument_group('required arguments')
    required.add_argument('--argA', help='argA', required=True)
    required.add_argument('--argB', help='argB', required=True)
    optional.add_argument('--argC', help='argC')
    optional.add_argument('--argD', help='argD')
    parser._action_groups.append(optional)
    args = parser.parse_args()
    return args

现在假设在

module2.py

中，我从

module1.py

导入

parse_arguments\u module1（）

，并使用它（这很有效）：

使用：

输出：

命名空间（argA='A'，argB='B'，argC='C'，argD=None）

问题是：如何读取

module2.py

（

required

和/或

optional

）中除

module1.py

之外的参数？（即，让

main

中的

args

包含更多参数，仅用于

module2.py

）

您需要使用来实现所需，和/或显式地将参数作为列表传递

通常，如果没有参数，parser.parse_args（）会将sys.argv[1://code>中的所有值（因此除了第一个元素之外的所有值）作为解析的输入。如果该列表中有无法解析的元素，则会打印错误消息并调用

sys.exit（1）

；您的脚本将退出

因此，如果希望

sys.argv

上的一些参数转到一个解析器，其余参数转到另一个解析器，则需要使用

parser.parse_known_args（）

并将其余参数传递给另一个解析器

我从解析中分离出创建和配置

ArgumentParser（）

实例；因此在

模块1中

执行以下操作：

def module1_argument_parser():
    parser = argparse.ArgumentParser()
    optional = parser._action_groups.pop()
    required = parser.add_argument_group('required arguments')
    required.add_argument('--argA', help='argA', required=True)
    required.add_argument('--argB', help='argB', required=True)
    optional.add_argument('--argC', help='argC')
    optional.add_argument('--argD', help='argD')
    parser._action_groups.append(optional)
    return parser

def parse_arguments_module1(args=None):
    parser = module1_argument_parser()
    return parser.parse_args(args)

if __name__ == '__main__':
    args = parse_arguments_module1()
    print(args)

在

module2

中，使用相同的结构，但重复使用

module1

中的解析器：

from module1 import module1_argument_parser

def module2_argument_parser():
    parser = argparse.ArgumentParser()
    # create argument switches, etc.
    return parser

def parse_arguments_module2(args=None):
    parser = module2_argument_parser()
    return parser.parse_args(args)

if __name__ == '__main__':
    module1_parser = module1_argument_parser()
    module1_args, remainder = module1_parser.parse_known_args()
    module2_args = parse_arguments_module2(remainder)
    print(module1_args)
    print(module2_args)

def module1_argument_parser():
    parser = argparse.ArgumentParser()
    optional = parser._action_groups.pop()
    required = parser.add_argument_group('required arguments')
    required.add_argument('--argA', help='argA', required=True)
    required.add_argument('--argB', help='argB', required=True)
    optional.add_argument('--argC', help='argC')
    optional.add_argument('--argD', help='argD')
    parser._action_groups.append(optional)
    return parser

def parse_arguments_module1(args=None):
    parser = module1_argument_parser()
    return parser.parse_args(args)

if __name__ == '__main__':
    args = parse_arguments_module1()
    print(args)

from module1 import module1_argument_parser

def module2_argument_parser():
    parser = argparse.ArgumentParser()
    # create argument switches, etc.
    return parser

def parse_arguments_module2(args=None):
    parser = module2_argument_parser()
    return parser.parse_args(args)

if __name__ == '__main__':
    module1_parser = module1_argument_parser()
    module1_args, remainder = module1_parser.parse_known_args()
    module2_args = parse_arguments_module2(remainder)
    print(module1_args)
    print(module2_args)