# python – What is the best way to call a script from another script?

## The Question :

351 people think this question is useful

I have a script named test1.py which is not in a module. It just has code that should execute when the script itself is run. There are no functions, classes, methods, etc. I have another script which runs as a service. I want to call test1.py from the script running as a service.

For example:

### File test1.py

print "I am a test"
print "see! I do nothing productive."



### File service.py

# Lots of stuff here
test1.py # do whatever is in test1.py



I’m aware of one method which is opening the file, reading the contents, and basically eval’ing it. I’m assuming there’s a better way of doing this. Or at least I hope so.

310 people think this answer is useful

The usual way to do this is something like the following.

test1.py

def some_func():
print 'in test 1, unproductive'

if __name__ == '__main__':
# test1.py executed as script
# do something
some_func()



service.py

import test1

def service_func():
print 'service func'

if __name__ == '__main__':
# service.py executed as script
# do something
service_func()
test1.some_func()



169 people think this answer is useful

This is possible in Python 2 using

execfile("test2.py")



See the documentation for the handling of namespaces, if important in your case.

In Python 3, this is possible using (thanks to @fantastory)

exec(open("test2.py").read())



However, you should consider using a different approach; your idea (from what I can see) doesn’t look very clean.

82 people think this answer is useful

Another way:

### File test1.py:

print "test1.py"



### File service.py:

import subprocess

subprocess.call("test1.py", shell=True)



The advantage to this method is that you don’t have to edit an existing Python script to put all its code into a subroutine.

Documentation: Python 2, Python 3

24 people think this answer is useful

If you want test1.py to remain executable with the same functionality as when it’s called inside service.py, then do something like:

test1.py

def main():
print "I am a test"
print "see! I do nothing productive."

if __name__ == "__main__":
main()



service.py

import test1
# lots of stuff here
test1.main() # do whatever is in test1.py



20 people think this answer is useful
import os

os.system("python myOtherScript.py arg1 arg2 arg3")



Using os you can make calls directly to your terminal. If you want to be even more specific you can concatenate your input string with local variables, ie.

command = 'python myOtherScript.py ' + sys.argv[1] + ' ' + sys.argv[2]
os.system(command)



13 people think this answer is useful

You should not be doing this. Instead, do:

test1.py:

 def print_test():
print "I am a test"
print "see! I do nothing productive."



service.py

#near the top
from test1 import print_test
#lots of stuff here
print_test()



10 people think this answer is useful

Use import test1 for the 1st use – it will execute the script. For later invocations, treat the script as an imported module, and call the reload(test1) method.

When reload(module) is executed:

• Python modules’ code is recompiled and the module-level code reexecuted, defining a new set of objects which are bound to names in the module’s dictionary. The init function of extension modules is not called

A simple check of sys.modules can be used to invoke the appropriate action. To keep referring to the script name as a string ('test1'), use the import()’ builtin.

import sys
if sys.modules.has_key['test1']:
else:
__import__('test1')



8 people think this answer is useful

I prefer runpy:

#!/usr/bin/env python
# coding: utf-8

import runpy

runpy.run_path(path_name='script-01.py')
runpy.run_path(path_name='script-02.py')
runpy.run_path(path_name='script-03.py')



4 people think this answer is useful

As it’s already mentioned, runpy is a nice way to run other scripts or modules from current script.

By the way, it’s quite common for a tracer or debugger to do this, and under such circumstances methods like importing the file directly or running the file in a subprocess usually do not work.

It also needs attention to use exec to run the code. You have to provide proper run_globals to avoid import error or some other issues. Refer to runpy._run_code for details.

3 people think this answer is useful

Why not just import test1? Every python script is a module. A better way would be to have a function e.g. main/run in test1.py, import test1 and run test1.main(). Or you can execute test1.py as a subprocess.

2 people think this answer is useful

This process is somewhat un-orthodox, but would work across all python versions,

Suppose you want to execute a script named ‘recommend.py’ inside an ‘if’ condition, then use,

if condition:
import recommend



The technique is different, but works!

0 people think this answer is useful

This is an example with subprocess library:

import subprocess

python_version = '3'
path_to_run = './'
py_name = '__main__.py'

# args = [f"python{python_version}", f"{path_to_run}{py_name}"]  # Avaible in python3
args = ["python{}".format(python_version), "{}{}".format(path_to_run, py_name)]

res = subprocess.Popen(args, stdout=subprocess.PIPE)
output, error_ = res.communicate()

if not error_:
print(output)
else:
print(error_)



import os