0

我写了两个 python 脚本 script1.py 和 script2.py。我想从 script2.py 运行 script1.py 并获取 script1 执行期间创建的 script1 变量的内容。Script1 有几个函数在其中创建变量，包括在主函数中。

感谢您的所有回答。我已经检查了您的答案，但它似乎不起作用。这是我正在谈论的有罪脚本：

脚本1.py

def main(argv):
    """Main of script 1
    Due to the  internal structure of the script this 
    main function must always be called with the flag -d
    and a corresponding argument.
    """
    global now
    now = datetime.datetime.now()

    global vroot_directory
    vroot_directory = commands.getoutput("pwd")

    global testcase_list_file
    testcase_list_file = 'no_argument'

    try:
        opts, args = getopt.getopt(argv, "d:t:", 
            ["directory_path=", "testcase_list="])
    except getopt.GetoptError, err:
        print command_syntax
        sys.exit()
    for opt, arg in opts:
        if opt in ("-d", "--directory"):
            vroot_directory = arg
        if opt in ("-t", "--testcase"):
             testcase_list_file = arg

    def function1():
        pass  

    def function2():
        if testcase_list_file == 'no_argument':
            function1()
        else:
            function2()

if __name__ == "__main__":
    main(sys.argv[1:])

脚本2.py

from Tkinter import *

class Application:
    def __init__(self):
        """ main window constructor """
        self.root = Tk()
        # I'd like to import here the variables of script1.py
        self.root.title(script1.vroot_directory)   ?
        self.root.mainloop()

# Main program
f = Application()

对我的错误感到抱歉，并感谢您的中肯评论。我收到以下错误消息：

“ AttributeError：‘模块’对象没有属性‘vroot_directory’”

更具体地说，我想要类似于以下内容：

from Tkinter import *
import script1

class Application:
    def __init__(self):
        """ main window constructor """
        self.root = Tk()
        script1.main(-d directory -t testcase_list_file) # to launch script1
        self.root.title(script1.vroot_directory)   # and after use its variables and functions
        self.root.mainloop()

# Main program
f = Application()
4

5 回答 5

4

从script2做

import script1

这将运行里面的任何代码script1；任何全局变量都可以作为例如script1.result_of_calculation. 您可以如下设置全局变量。

脚本1：

from time import sleep
def main( ):
    global result
    sleep( 1 ) # Big calculation here
    result = 3

脚本2：

import script1
script1.main( ) # ...
script1.result # 3

请注意，在 script1 return中制作会更好，这样您就可以做到main()result

import script1
result = script1.main( )

这更好地封装了数据流，并且通常更 Pythonic。它还避免了全局变量，这通常是一件坏事。

于 2010-08-17T09:19:25.200 回答
0

有两种可能性：首先，将它们合并到一个脚本中。这可能看起来像（在 script2.py 中）

import script1

...
script1.dostuff()
importantvar = script1.importantvar
doScript2Stuff(importantvar)

但是，在不知道您的应用程序的情况下，我建议将 script1 所做的任何事情封装到一个函数中，这样您就可以简单地调用

(var1, var2, var3) = script1.dostuffAndReturnVariables()

因为避免全局变量总是好的。此外，如果 script1 中的内容在您导入它的那一刻没有执行（因为如果您直接在主级别上编写所有命令，则它可能会在稍后变得方便），但是当您需要它时，通过调用一个函数。否则，一旦您获得更多模块，事情可能会变得混乱，并且您可能会发现自己重新排列导入命令，因为它们做了很多事情。

第二种可能性，如果由于某种原因需要单独运行它们，那就是使用 pickle。

写

output = open(picklefile, "w")
pickle.dump(vars, output)    
output.close()

在 script1.py 中

进而

inputfile = open(picklefile, "r")
vars = pickle.load(inputfile)
input.close()

在 script2.py 中。这样，您可以将 var 的内容保存在一个文件中，并在需要时从那里恢复它们。

但是，我更喜欢第一种方法，除非有充分的理由不将两者一起运行，因为它可以改进代码的结构。

于 2010-08-17T09:22:26.217 回答
0

Python 是一种解释型语言，因此当您在另一个脚本中简单地导入一个脚本（例如通过import script1在 script2 中编写）时，解释器将加载第二个脚本并逐步执行它。每个函数定义都会产生一个可调用的函数对象等等，每个表达式都会被简单地执行。

之后，您可以访问模块中的所有内容script1.globalvar1，依此类推。

于 2010-08-17T09:22:35.560 回答
0

我认为您正在寻找的是某种形式的对象持久性。我个人为此使用搁置模块：

脚本 1：

import shelve

def main(argv):
    """Main of script 1
    Due to the  internal structure of the script this 
    main function must always be called with the flag -d
    and a corresponding argument.
    """

    settings = shelve.open('mySettings')

    global now
    now = datetime.datetime.now()

    settings['vroot_directory'] = commands.getoutput("pwd")

    settings['testcase_list_file'] = 'no_argument'

    try:
        opts, args = getopt.getopt(argv, "d:t:", 
            ["directory_path=", "testcase_list="])
    except getopt.GetoptError, err:
        print command_syntax
        sys.exit()
    for opt, arg in opts:
        if opt in ("-d", "--directory"):
            settings['vroot_directory'] = arg
        if opt in ("-t", "--testcase"):
            settings['testcase_list_file'] = arg

    def function1():
        pass  

    def function2():
        if testcase_list_file == 'no_argument':
            function1()
        else:
            function2()

if __name__ == "__main__":
    main(sys.argv[1:])

脚本 2：

from Tkinter import *
import shelve

class Application:
    def __init__(self):
        settings = shelve.open('mySettings')

        """ main window constructor """
        self.root = Tk()
        # I'd like to import here the variables of script1.py
        self.root.title(settings['vroot_directory'])   ?
        self.root.mainloop()

# Main program
f = Application()

shelve 模块在其实现中使用了 pickle 模块，因此您还可以查看 pickle 模块的另一种方法。

于 2010-08-17T15:18:11.047 回答
-2

根据您要传递给 script2.py 的变量数量，您可以通过参数传递它们并将它们作为 argv 数组拾取。您可以运行 script1.py，然后从该脚本运行 os.system('script2.py arg0 arg1 arg2 arg3') 来调用 script2.py。

然后，您可以通过执行以下操作在 script2.py 中获取变量：

import sys

arg0 = sys.argv[0]
arg1 = sys.argv[1]
...
于 2010-08-17T09:18:56.117 回答