Python："importing"输入参数

Question

我有两个python脚本A和B，都有一个主要的和不同的输入参数(我使用argparse)。我通常使用:

启动它们

$ python A.py --paramA1 valA1 --paramA2 valA2
$ python B.py --paramB1 valB1 --paramB2 valB2

我希望能够从A中调用B，并在启动A时指定B的参数。简而言之，我想用A的参数和B的参数来调用A。从外部看，它应该是这样的:

$ python A.py --paramA1 valA1 --paramA2 valA2 --paramB1 valB1 --paramB2 valB2

是否有一个更优雅的方式来做到这一点，而不是复制和粘贴B的argparse代码到A，然后调用B上?

EDIT:为了简化，这里有一些示例代码:

A.py:

import argparse
def main():
    parser = argparse.ArgumentParser(description="Args for A.py")
    parser.add_argument("--param1A", type=int)
    parser.add_argument("--param2A", type=int)
    args = parser.parse_args()
    valA1 = args.param1A
    valA2 = args.param2A
    ...
    return 0

B.py:

import argparse
def main():
    parser = argparse.ArgumentParser(description="Args for B.py")
    parser.add_argument("--param1B", type=int)
    parser.add_argument("--param2B", type=int)
    args = parser.parse_args()
    valA1 = args.param1B
    valA2 = args.param2B
    ...
    return 0

建议的C.py，包括A.py和B.py的参数到底是什么样子?那么A.py和B.py会是什么样子呢?

EDIT 2:我忘了提到B.py的一个参数必须在A.py中创建，因此执行顺序是A然后是B, A必须能够将参数传递给B。

Answer 1

您可以创建一个模块C.py，它包含常见的argparse逻辑，并由a和b导入。

当从A调用B时，您也可以将已经解析过的参数传递给B。我的意思是，A和B都应该有类似main函数的东西，它接受已经解析过的参数，因此不必进行两次解析。

C.py

import argparse
def create_parser():
    parser = argparse.ArgumentParser(description="Args for B.py")
    parser.add_argument("--param1B", type=int)
    parser.add_argument("--param2B", type=int)
    return parser

B.py

import argparse
import sys
import C
def main(args):
    valB1 = args.param1B
    valB2 = args.param2B
    # do stuff
    return 0
if __name__ == '__main__':
    parser = C.create_parser()
    args = parser.parse_args()
    sys.exit(main(args))

A.py

import argparse
import sys
import C
import B
def main(args):
    valA1 = args.param1A
    valA2 = args.param2A
    # do stuff
    return 0

if __name__ == '__main__':
    parser = C.create_parser()
    parser.add_argument("--param1A", type=int)
    parser.add_argument("--param2A", type=int)
    args = parser.parse_args()
    B.main(args)
    sys.exit(main(args))

Answer 2

我认为@Ioan Alexandru Cucu的描述是这样的:

import argparse
class A():
    __init__(self, param1A, param2A, param1B=None, param2B=None):
        if(param1B and param2B):
            myB = B(param1B, param2B)
        #Do processing here ...
        return 0

class B():
    __init__(self, param1B, param2B):
        #Do processing here ...
        return 0
if(__name__ == '__main__'):
    parser = argparse.ArgumentParser(description="Args for A and/or B")
    parser.add_argument("--param1A", type=int)
    parser.add_argument("--param2A", type=int)
    parser.add_argument("--param1B", type=int)
    parser.add_argument("--param2B", type=int)
    args = parser.parse_args()
    if(args.param1A and args.param2A and args.param1B and args.param2B):
        A(args.param1A, args.param2A, args.param1B, args.param2B)
    if(args.param1A and args.param2A):
        A(args.param1A, args.param2A)
    elif(args.param1B and args.param2B):
        B(args.param1B, args.param2B)

与其在一个模块中包含多个类，不如在多个模块中包含不同的类。