Tell me more ×
Stack Overflow is a question and answer site for professional and enthusiast programmers. It's 100% free, no registration required.
up vote 22 down vote favorite
5

I want to run a python script from another python script. I want to pass variables like I would using the command line.

For example, I would run my first script that would iterate through a list of values (0,1,2,3) and pass those to the 2nd script "script2.py 0" then "script2.py 1", etc.

I found SO 1186789 which is a similar question but ars's answer calls a function, where as I want to run the whole script not just a function, and balpha's answer calls the script but with no args. I altered this to something like the below as a test: 

execfile("script2.py 1")

But is is not accept vars properly. When I print out the 'sys.argv' ins script2.py it is the original command call to first script "['C:\script1.py'].

I don't really want to change the original script (i.e. script2.py in my example) since I don't own it.

I figure there must be a way to do this, I am just confused how you do it.

Thanks!

share|improve this question

5 Answers

up vote 29 down vote accepted

Try using os.system:

os.system("script2.py 1")

execfile is different because it is designed to run a sequence of Python statements in the current execution context. That's why sys.argv didn't change for you.

share|improve this answer
5  
I believe it's generally preferable to use subprocess.Popen over os.system: docs.python.org/library/subprocess.html#replacing-os-system. – katrielalex Sep 23 '10 at 20:15
1  
Yes, that's what the help for os.system says. However, for simple uses os.system is the simplest way to get the job done. It depends on what your needs are, of course. – Greg Hewgill Sep 23 '10 at 20:39
You can also use subprocess.check_call(). – MarioVilas Mar 13 at 11:01
up vote 19 down vote

This is inherently the wrong thing to do. If you are running a Python script from another Python script, you should communicate through Python instead of through the OS:

import script1

In an ideal world, you will be able to call a function inside script1 directly:

for i in range(whatever):
    script1.some_function(i)

If necessary, you can hack sys.argv. There's a neat way of doing this using a context manager to ensure that you don't make any permanent changes.

import contextlib
@contextlib.contextmanager
def redirect_argv(num):
    sys._argv = sys.argv[:]
    sys.argv=[str(num)]
    yield
    sys.argv = sys._argv

with redirect_argv(1):
    print(sys.argv)

I think this is preferable to passing all your data to the OS and back; that's just silly.

share|improve this answer
1  
It might be the "wrong" thing to do but what if the script you need to reference has no main or functions.... an import would execute the script at the time of import, which probably isn't what you want (and you don't want to refactor it because people are also using that script as is). os/subprocess could deal with such a case – Dan S Aug 21 '12 at 15:33
True... but that's a different question IMO! – katrielalex Aug 21 '12 at 16:08
Won't that fail for multithreaded scripts? – MarioVilas Mar 13 at 11:01
@MarioVilas probably, yes. – katrielalex Mar 13 at 11:42
up vote 14 down vote

Ideally, the Python script you want to run will be set up with code like this near the end:

def main(arg1, arg2, etc):
    # do whatever the script does


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

In other words, if the module is called from the command line, it parses the command line options and then calls another function, main(), to do the actual work. (The actual arguments will vary, and the parsing may be more involved.)

If you want to call such a script from another Python script, however, you can simply import it and call modulename.main() directly, rather than going through the operating system.

os.system will work, but it is the roundabout (read "slow") way to do it, as you are starting a whole new Python interpreter process each time for no raisin.

share|improve this answer
1  
Re: "no raisin." This is not an error. However, it was interesting to see how long it would take for someone unfamiliar with Futurama to "correct" it in a random Stack Overflow question: two years and three months. :-) – kindall Dec 29 '12 at 18:30
I laughed at "no raisin" simply because it was a ridiculous typo, then saw your comment and found a clip on YouTube. Even funnier. – armani May 20 at 15:51
I had a script with no main, but was able to introduce like so: 1. Separate function defs and standalone statements 2. Do the argument parsing under the "if name..." section 3. indent the rest of statements under def main(...) and have that logic operate on the method parameters. Then I was able to call the main method from another script (ex: A unit test) – Stan Kurdziel May 28 at 18:00
Yeah, Python really makes that kind of refactoring pretty easy. I have done similar things more than once myself! – kindall May 28 at 18:06
up vote 7 down vote

SubProcess module:
http://docs.python.org/dev/library/subprocess.html#using-the-subprocess-module

import subprocess
subprocess.Popen("script2.py 1", shell=True)

With this, you can also redirect stdin, stdout, and stderr.

share|improve this answer
up vote 0 down vote

If os.system isn't powerful enough for you, there's the subprocess module.

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.