Question

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

感谢您的所有答案。我检查了你的答案，似乎没有用。以下是我正在讨论的有罪脚本：

script1.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:])

script2.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：'module'对象没有属性'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()

Answer 1

来自script2做

import script1

这将运行script1内的任何代码;任何全局变量都可用作例如script1.result_of_calculation。您可以将全局变量设置如下。

SCRIPT1：

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

SCRIPT2：

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

请注意，在script1中使main()返回result将更好，以便您可以

import script1
result = script1.main( )

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

Answer 2

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

import script1

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

然而，在不知道您的应用程序的情况下，我建议将script1所做的任何内容封装到一个函数中，以便您可以简单地调用

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

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

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

写

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的内容保存在文件中，并在需要时从那里恢复它们。

但是，我更喜欢第一种方法，除非有两个不能一起运行的正当理由，因为它改善了代码的结构。

Answer 3

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

之后，您可以使用script1.globalvar1等模块访问模块中的所有内容。

Answer 4

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

脚本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模块以获得另一种方法。

Answer 5

根据要传递给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]
...

在程序执行后导入程序的python变量

5 个答案: