Importing python variables of a program after its execution.

Question

Hello,

I've written two python scripts script1.py and script2.py. I want to run script1.py from script2.py and get the content of the variables of script1 created during the execution of script1. Script1 has several functions in which the variables are created including in the main.

rgds,

Bruno

Thank you for all your answers. I've examined your answers and it doesn't seem to work. Here are the guilty scripts I'm talking about :

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()

Sorry for my mistakes and thank you for your pertinent remarks. I've got the following error message :

" AttributeError: 'module' object has no attribute 'vroot_directory' "

To be more specific I'd like to have something similar to the following :

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()

rgds,

Answer 1

Depending on how many variables you want to pass to script2.py you could pass them via arguments and pick them up as an argv array. You could run script1.py then from this script run os.system('script2.py arg0 arg1 arg2 arg3') to call script2.py.

Then you can pick up your variables in you script2.py by doing this:

import sys

arg0 = sys.argv[0]
arg1 = sys.argv[1]
...

Answer 2

From script2 do

import script1

This will run any code inside script1; any global variables will be available as e.g. script1.result_of_calculation. You can set global variables as below.

---

script1:

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

script2:

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

---

Note that it would be nicer to make main() in script1 return result, so that you could do

import script1
result = script1.main( )

This better encapsulates the flow of data, and is generally more Pythonic. It also avoids global variables, which are generally a Bad Thing.

Answer 3

There are two possibilities: First, merge them into a single script. This could look something like (in script2.py)

import script1

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

Without knowing your application, however, I'd advise encapsulating whatever script1 does into a function such that you can simply call

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

since it's always good to avoid global variables. Also, it may turn out handy later on if the stuff in script1 isn't executed in the moment you import it (as it is done if you write all the commands directly on the main level), but when you want it, by calling a function. Otherwise things may get messy once you get more modules and you may find yourself rearranging import commands because they do so much stuff.

Second possibility, if, for some reason, they need to be run separately, would be to use pickle.

Write

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

in script1.py

and then

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

in script2.py. This way, you save the contents of your var in a file and can revive them from there when needed.

However, I'd prefer the first approach unless there's a really good reason for the two not to be run together, as it improves the structure of your code.

Answer 4

Python is an interpreted language, so when you simply import a script within another script (e.g. by writing import script1 inside script2) then the interpreter will load the second script and execute it step by step. Each function definition will result in a callable function object and so on, and each expression will be simply executed.

After that, you can access everything from the module with script1.globalvar1 and so on.

Answer 5

I think what you are looking for is some form of object persistence. I personally use the shelve module for this:

Script 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:]) 

Script 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()

The shelve module uses the pickle module in its implementation, so you could also look at pickle module for another approach.