Python：运行脚本 A 处理脚本 B 中的 argparser

Question

我有一个 script_A，它使用 argparser 处理不同的输入，我用它来执行一个函数。我现在需要脚本 B 来调用并让所有脚本 A 从内部运行（让它处理不同的输入）。我正在使用 Windows。

目标： Script_B 将根据 script_A 的输出做进一步的分析。 Script_A 的行为根据传递的参数选项而改变。 Script_B 的行为始终相同。我宁愿不要把 script_A 和 script_B 组合成一个庞大的脚本。

目标已更新：为了让 script_B 正常工作，我需要运行 script_A，然后传递其中一个字典，即字典 D，它被计算（从 A 输出）传递给B. 直到所有 script_A 运行后才计算字典。

这就是 Script_A 的样子

import sys
import os
from argparse import ArgumentParser

def function 1:
    #it does stuff....

def function 2:
    #it does other stuf...

if __name__ == "__main__":
    parser = ArgumentParser(description = "functionA.py -i [--print]
    parser.add_argument('-i', '--id', help="Please write A or B", required=True)
    parser.add_argument('-r', '--re', help="Please write C or D, required=True)

    sysargs = parser.parse_args()

    #Variable definitions

    if str(sysargs.id) == "A":
        #Uses file A located in directory X to perform analysis
        #calls function A to perform analysis
    elif str(sysargs.id) == "B":
        #Uses file B located in Directory Y to perform analysis
        #calls function B to perform analysis

    if str(sysargs.re) == "C"
        #Provides thorough printout of analysis (more in depth for debugging)
    if str(sysargs.re) == "D"
        #Does Nothing (no debugging option)

脚本 A 运行良好，当我使用它时它就完成了它的工作。我使用命令行参数提交输入，这是必需的，有时是可选的。

这就是脚本B，我试过以下：

1

import sys
import numpy as np
import os
import script_A

os.system("script_A.py", -i "A" -r "C")

#Other stuff that script B does

2

import sys
import os
import script_A

exec(script_A.py[-i "A" -r "C"])

#Other stuff that script B does

3

import os
import sys
from subprocess import call

subprocess.call("script_A.py", -i "A" -r "C")

#Other stuff that script B does

我看过这里：Calling an external command in Python

这里：importing a python script from another script and running it with arguments

但无法从他们所说的内容中弄清楚。任何帮助是极大的赞赏。我还是 Python 的初学者。

我基于 cmets 尝试了以下方法：

1

import subprocess
import script_A

p.subprocess.Popen("script_A.py", "-i", "A", "-r", "none", shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)


(stdoutput, erroutput) = p.communicate()

TypeError: __init_() 为关键字参数“stdout”获取了多个值

我尝试添加 self 参数，但出现以下错误

p.subprocess.Popen("script_A.py", "-i", "A", "-r", "C", shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

TypeError: __init_() 为关键字参数“stderr”获得了多个值

2

import subprocess
import script_A

process= Popen(["script_A", "-i", "A", "-r", "C"], stdout = subprocess.PIPE, stderr=subprocess.STDOUT)

output = process.communicate()

OSError: [ERRno2] 没有这样的文件或目录

在执行子进程中转到 /subprocess.py 的目录出错

引发 child_exception

我不知道这是什么意思。

Answer 1

p = subprocess.Popen("your_a_code_with_args_here",
                     shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

(stdoutput, erroutput) = p.communicate()

那么你的 B 代码就可以根据 A 代码的输出来做事了。

Answer 2

我已将您的A 压缩为：

import argparse

def function_1():
    print('function 1')

def function_2():
    print('function 2')

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument('-i', '--id', choices=['A','B'], default='A')
    parser.add_argument('-r', '--re', choices=['C','D'], default='C')

    args = parser.parse_args()

    #Variable definitions

    if args.id == "A":
        print("A")
        function_1()
    elif args.id == "B":
        print('B')
        function_2()
    if args.re == "C":
        print('C')
    if args.re == "D":
        print('D')

如果B 是

import os
os.system("python3 stack37557027_A.py -i A -r C")

然后A 运行并显示

A
function 1
C

使用main 块，import stack375570237_A 所做的只是从 B 导入两个可以运行的函数

stack375570237_A.function_A()

如果不清楚，请重新阅读有关if __name__ == "__main__": 用途的文档以及运行脚本和导入模块之间的区别。这是重要的基础 Python。

根据@atline 的建议：

import subprocess

p = subprocess.Popen("python3 stack37557027_A.py -i A -r C",
                     shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

(stdoutput, erroutput) = p.communicate()
print(stdoutput)
#print(erroutput)

显示是：

b'A\nfunction 1\nC\n'
#None

同样的东西，但包装成字节串。

请注意，在这两种情况下，我都使用一个字符串调用脚本，其中包括文件名和参数。

p = subprocess.Popen(["python3", "stack37557027_A.py", "-i", "A", "-r", "C"],
                 stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

这也有效。 shell 不再是 True，我使用的是字符串列表。

您可能需要查看subprocess 的文档。 https://pymotw.com/2/subprocess/

======================

您更新后的目标是：

，我需要运行 script_A，然后传递其中一个字典，即字典 D，它被计算（从 A 输出）传递给 B。T

一个问题是目前使用的方法要么只是将一个字符串显示到标准输出，要么将一个字符串返回给调用者（从标准输出）。它们不会像字典那样返回 Python 对象。

这本字典是在您的A 中的哪个位置生成的？它如何依赖于argparse 选项？

让我们改变 A 以便身体中的一个函数产生一个字典

def function_1(id, re):
    print('function 1')
    return {'id':id, 're':re}

并用（在'if name'块中）调用它：

args = parser.parse_args()
print(function_1(args.id, args.re))

结果是这样的

1659:~/mypy$ python3 stack37557027_A.py 
function 1
{'re': 'C', 'id': 'A'}

脚本 B 也可以生成该字典的字符串显示

1659:~/mypy$ python3 stack37557027_B.py
b"function 1\n{'re': 'C', 'id': 'A'}\n"

现在如果在 B 我愿意

import stack37557027_A as A
print(A.function_1('AA','BB'))

我明白了

{'id': 'AA', 're': 'BB'}

因此，如果所有操作都是 A 的主体，并且 if __name__ 块就像 argparse 解析和委托一样，我可以通过导入使用来自 A 的函数，并取回字典（或其他任何内容）对象这些函数产生）。换句话说，我不需要将A 作为子进程或系统进程调用。

如果您确实需要将A 作为一个单独的进程运行，并且仍要返回Python 对象，我认为您可以使用multiprocessing。

https://docs.python.org/2/library/multiprocessing.html#exchanging-objects-between-processes

https://pymotw.com/2/multiprocessing/basics.html

Answer 3

版本 3 几乎是正确的。尽管您的示例中缺少很多 ' 和 "，但我不确定您的代码是否对您有用...

from subprocess import call

# you need pass the name + all the arguments as a vector here 
process = call(["script_A.py", "-i", "A", "-r", "C"])

#Other stuff that script B does

如果要捕获输出，最好使用Popen 而不是call

from subprocess import call, Popen

# you need pass the name + all the arguments as a vector here 
process = Popen(["script_A.py", "-i", "A", "-r", "C"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

output = process.communicate()  # let it run until finished

print output[0]  # stdout
print output[1]  # stderr
#Other stuff that script B does