share
Stack OverflowCalling an external command in Python
[+1154] [32] freshWoWer
[2008-09-18 01:35:30]
[ python shell command subprocess external ]
[ http://stackoverflow.com/questions/89228/calling-an-external-command-in-python ]

How can I call an external command (as if I'd typed it at the Unix shell or Windows command prompt) from within a Python script?

[+1161] [2008-09-18 13:11:46] Eli Courtwright

Here's a summary of the ways to call external programs and the advantages and disadvantages of each:

  1. os.system("some_command with args") passes the command and arguments to your system's shell. This is nice because you can actually run multiple commands at once in this manner and set up pipes and input/output redirection. For example,
    os.system("some_command < input_file | another_command > output_file")
    However, while this is convenient, you have to manually handle the escaping of shell characters such as spaces, etc. On the other hand, this also lets you run commands which are simply shell commands and not actually external programs.
    see documentation [1]

  2. stream = os.popen("some_command with args") will do the same thing as os.system except that it gives you a file-like object that you can use to access standard input/output for that process. There are 3 other variants of popen that all handle the i/o slightly differently. If you pass everything as a string, then your command is passed to the shell; if you pass them as a list then you don't need to worry about escaping anything.
    see documentation [2]

  3. The Popen class of the subprocess module. This is intended as a replacement for os.popen but has the downside of being slightly more complicated by virtue of being so comprehensive. For example, you'd say

    print subprocess.Popen("echo Hello World", shell=True, stdout=PIPE).stdout.read()
    

    instead of

    print os.popen("echo Hello World").read()
    

    but it is nice to have all of the options there in one unified class instead of 4 different popen functions.
    see documentation [3]

  4. The call function from the subprocess module. This is basically just like the Popen class and takes all of the same arguments, but it simply waits until the command completes and gives you the return code. For example:

    return_code = subprocess.call("echo Hello World", shell=True)  
    

    see documentation [4]

  5. The os module also has all of the fork/exec/spawn functions that you'd have in a C program, but I don't recommend using them directly.

The subprocess module should probably be what you use.

Finally please be aware that for all methods where you pass the final command to be executed by the shell as a string and you are responsible for escaping it there are serious security implications if any part of the string that you pass can not be fully trusted (for example if a user is entering some/any part of the string). If unsure only use these methods with constants. To give you a hint of the implications consider this code

print subprocess.Popen("echo %s " % user_input, stdout=PIPE).stdout.read()

and imagine that the user enters "my mama didnt love me && rm -rf /".

[1] https://docs.python.org/2/library/os.html#os.system
[2] https://docs.python.org/2/library/os.html#os.popen
[3] https://docs.python.org/2/library/subprocess.html#popen-constructor
[4] https://docs.python.org/2/library/subprocess.html#subprocess.call

(7) You didn't mention the commands module - Casebash
(65) @Casebash: I didn't bother mentioning it because the documentation states that The subprocess module provides more powerful facilities for spawning new processes and retrieving their results. Using the subprocess module is preferable to using the commands module. I similarly didn't mention the popen2 module because it's also obsolete, and both it and the commands module are actually gone in Python 3.0 and later. In lieu of editing my answer, I'll let these comment be the way in which these modules are mentioned. - Eli Courtwright
(9) Great article on the use of subprocess here : doughellmann.com/PyMOTW/subprocess - PhoebeB
(4) commands module is deprecated now. - jldupont
(8) For many cases you don't need to instantiate a Popen object directly, you can use subprocess.check_call and subprocess.check_output - simao
(2) For those that are confused why he didn't convert the call example to a list: he added shell=True because the command is given as a string. This is false by default so a list is needed. - dlite922
1
[+1080] [2008-09-18 01:39:35] David Cournapeau [ACCEPTED]

Look at the subprocess module [1] in the stdlib:

from subprocess import call
call(["ls", "-l"])

The advantage of subprocess vs system is that it is more flexible (you can get the stdout, stderr, the "real" status code, better error handling, etc...). I think os.system is deprecated, too, or will be:

http://docs.python.org/library/subprocess.html#replacing-older-functions-with-the-subprocess-module

For quick/dirty/one time scripts, os.system is enough, though.

[1] http://docs.python.org/library/subprocess.html

(79) Can't see why you'd use os.system even for quick/dirty/one-time. subprocess seems so much better. - nosklo
(9) I agree completely that subprocess is better. I just had to write a quick script like this to run on an old server with Python 2.3.4 which does not have the subprocess module. - Liam
(21) here are the subprocess docs - daonb
For some reason, this only works if I do import subprocess. If I use from subprocess import call, I get a generic error message. - Brian Z
(2) @BrianZ That's because call uses Popen. I find it better to just always use Popen, then I can get the returncode, stderr & stdout if needed. - senorsmile
(3) call (..) Gave me an error on oython 2.7.6 : Traceback (most recent call last): File "E:\Ajit\MyPython\synonyms1.py", line 27, in <module> call("dir") <br/> File "C:\Python27\lib\subprocess.py", line 524, in call return Popen(*popenargs, **kwargs).wait() <br/> File "C:\Python27\lib\subprocess.py", line 711, in init errread, errwrite)<br/> File "C:\Python27\lib\subprocess.py", line 948, in _execute_child startupinfo)<br/> WindowsError: [Error 2] The system cannot find the file specified - goldenmean
(11) @goldenmean: my guess, there is no ls.exe on Windows. Try call("dir", shell=True) - J.F. Sebastian
Looking at the documentation and at your answer, I cannot understand why ['ls','-l'] is input as a list. It led me to believe that everything I would normally separate by a space I would put as a separate list element, but this broke. What's the purpose of the list? - Snoozer
@Snoozer: It handles escaping of spaces so 'command one two' is handled different from 'command "one two"'. See my answer: stackoverflow.com/a/23391049/117268 - Emil Stenström
2
[+86] [2008-09-18 18:20:46] EmmEff

I typically use:

import subprocess

p = subprocess.Popen('ls', shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
for line in p.stdout.readlines():
    print line,
retval = p.wait()

You are free to do what you want with the stdout data in the pipe. In fact, you can simply omit those parameters (stdout= and stderr=) and it'll behave like os.system().


(4) .readlines() reads all lines at once i.e., it blocks until the subprocess exits (closes its end of the pipe). To read in real time (if there is no buffering issues) you could: for line in iter(p.stdout.readline, ''): print line, - J.F. Sebastian
Could you elaborate on what you mean by "if there is no buffering issues"? If the process blocks definitely, the subprocess call also blocks. The same could happen with my original example as well. What else could happen with respect to buffering? - EmmEff
(5) the child process may use block-buffering in non-interactive mode instead of line-buffering so p.stdout.readline() (note: no s at the end) won't see any data until the child fills its buffer. If the child doesn't produce much data then the output won't be in real time. See the second reason in Q: Why not just use a pipe (popen())?. Some workarounds are provided in this answer (pexpect, pty, stdbuf) - J.F. Sebastian
the buffering issue only matters if you want output in real time and doesn't apply to your code that doesn't print anything until all data is received - J.F. Sebastian
@J.F.Sebastian tried your method, however every time a command is entered teh result of the previous command is printed out. - Paul
(1) @Paul: If your code produces unexpected results then you could create a complete minimal code example that reproduces the problem and post it as a new question. Mention what do you expect to happen and what happens instead. - J.F. Sebastian
All right took your advice stackoverflow.com/questions/15945585/… thanks! - Paul
3
[+55] [2010-02-12 10:15:34] newtover

Some hints on detaching the child process from the calling one (starting the child process in background).

Suppose you want to start a long task from a CGI-script, that is the child process should live longer than the CGI-script execution process.

The classical example from the subprocess module docs is:

import subprocess
import sys

# some code here

pid = subprocess.Popen([sys.executable, "longtask.py"]) # call subprocess

# some more code here

The idea here is that you do not want to wait in the line 'call subprocess' until the longtask.py is finished. But it is not clear what happens after the line 'some more code here' from the example.

My target platform was freebsd, but the development was on windows, so I faced the problem on windows first.

On windows (win xp), the parent process will not finish until the longtask.py has finished its work. It is not what you want in CGI-script. The problem is not specific to Python, in PHP community the problems are the same.

The solution is to pass DETACHED_PROCESS flag to the underlying CreateProcess function in win API. If you happen to have installed pywin32 you can import the flag from the win32process module, otherwise you should define it yourself:

DETACHED_PROCESS = 0x00000008

pid = subprocess.Popen([sys.executable, "longtask.py"],
                       creationflags=DETACHED_PROCESS).pid

On freebsd we have another problem: when the parent process is finished, it finishes the child processes as well. And that is not what you want in CGI-script either. Some experiments showed that the problem seemed to be in sharing sys.stdout. And the working solution was the following:

pid = subprocess.Popen([sys.executable, "longtask.py"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)

I have not checked the code on other platforms and do not know the reasons of the behaviour on freebsd. If anyone knows, please share your ideas. Googling on starting background processes in Python does not shed any light yet.


thanks for the answer! i noticed a possible "quirk" with developing py2exe apps in pydev+eclipse. i was able to tell that the main script was not detached because eclipse's output window was not terminating; even if the script executes to completion it is still waiting for returns. but, when i tried compiling to a py2exe executable, the expected behavior occurs (runs the processes as detached, then quits). i am not sure, but the executable name is not in the process list anymore. this works for all approaches (os.system("start *"), os.spawnl with os.P_DETACH, subprocs, etc.) - maranas
(1) @alexey-lebedev, I had no choice =) You are welcome! - newtover
Windows gotcha: even though I spawned process with DETACHED_PROCESS, when I killed my Python daemon all ports opened by it wouldn't free until all spawned processes terminate. WScript.Shell solved all my problems. Example here: pastebin.com/xGmuvwSx - Alexey Lebedev
you might also need CREATE_NEW_PROCESS_GROUP flag. See Popen waiting for child process even when the immediate child has terminated - J.F. Sebastian
4
[+42] [2008-09-18 01:42:30] SirWart

I'd recommend using the subprocess module instead of os.system because it does shell escaping for you and is therefore much safer: http://docs.python.org/library/subprocess.html

subprocess.call(['ping', 'localhost'])

And subprocess will allow you to easily attach to the input/output streams of the process, etc. - Joe Skora
(3) subprocess doesn't do shell escaping for you because it avoids using the shell entirely. It actually means that startup is a little faster and there's less overhead. - habnabit
5
[+22] [2010-10-07 07:09:04] athanassis

Check "pexpect" python library, too. It allows for interactive controlling of external programs/commands, even ssh, ftp, telnet etc. You can just type something like:

child = pexpect.spawn('ftp 192.168.0.24')

child.expect('(?i)name .*: ')

child.sendline('anonymous')

child.expect('(?i)password')

6
[+20] [2012-03-13 00:12:54] Jorge Eduardo Cardona

I always use fabric for this things like:

from fabric.operations import local
result = local('ls', capture=True)
print "Content:/n%s" % (result, )

But this seem to be a good tool: sh (Python subprocess interface) [1].

Look an example:

from sh import vgdisplay
print vgdisplay()
print vgdisplay('-v')
print vgdisplay(v=True)
[1] https://github.com/amoffat/sh

(1) sh is superior to subprocess module. It allows a better shell integration - Yauhen Yakimovich
7
[+15] [2008-09-18 01:37:49] Richard Franks
import os
cmd = 'ls -al'
os.system(cmd)

If you want to return the results of the command you need os.popen [1]:

[1] http://oreilly.com/catalog/lpython/chapter/ch09.html

popen is deprecated in favor of subprocess. - fwilson
8
[+14] [2011-04-28 20:29:29] F.C.

If what you need is the output from the command you are calling you can use subprocess.check_output since Python 2.7

>>> subprocess.check_output(["ls", "-l", "/dev/null"])
'crw-rw-rw- 1 root root 1, 3 Oct 18  2007 /dev/null\n'

9
[+12] [2012-10-28 05:14:01] Usman Khan

This is how I run my commands. This code has everything you need pretty much

from subprocess import Popen, PIPE
cmd = "ls -l ~/"
p = Popen(cmd , shell=True, stdout=PIPE, stderr=PIPE)
out, err = p.communicate()
print "Return code: ", p.returncode
print out.rstrip(), err.rstrip()

Passing commands as strings is normally a bad idea - Eric
I think it's acceptable for hard-coded commands, if it increases readability. - Adam Matan
10
[+10] [2013-04-18 01:09:33] Zuckonit

without the output of result

import os
os.system("your command here")

with output of result

import commands
commands.getoutput("your command here")
or
commands.getstatusoutput("your command here")

I like the part with output of result. I needed this for using in sublime console. - Ramsharan
11
[+9] [2013-04-11 17:17:53] Honza Javorek

In case you need to go only with standard library, use subprocess module [1]:

from subprocess import call
call(['ls', '-l'])

It is the recommended standard way. However, more complicated tasks (pipes, output, input, etc.) can be tedious to construct and write.

Note: shlex.split [2] can help you to parse the command for call and other subprocess functions in case you don't want (or you can't!) provide them in form of lists:

import shlex
from subprocess import call
call(shlex.split('ls -l'))

If you do not mind external dependencies, install and use sh [3]:

from sh import ifconfig
print ifconfig('wlan0')

It is the best and the most developer-friendly subprocess wrapper I have seen. It is under active development, it has good documentation and you will be usually able to solve any of your tasks on just couple of lines and in a very readable form. The only thing you need to do to have it available is to type pip install sh in your terminal :-)

[1] http://docs.python.org/2/library/subprocess.html
[2] https://docs.python.org/2/library/shlex.html#shlex.split
[3] https://pypi.python.org/pypi/sh

12
[+8] [2008-09-18 01:53:27] Martin W

os.system is OK, but kind of dated. It's also not very secure. Instead, try subprocess. subprocess does not call sh directly and is therefore more secure than os.system.

Get more information at http://docs.python.org/lib/module-subprocess.html


13
[+7] [2008-09-18 01:37:24] nimish
import os
os.system("your command")

Note that this is dangerous, since the command isn't cleaned. I leave it up to you to google for the relevant docs on the 'os' and 'sys' modules. There are a bunch of functions (exec* , spawn*) that will do similar things.


14
[+6] [2008-09-18 01:43:56] William Keller

os.system has been superceeded by the subprocess module. Use subproccess instead.


(4) Perhaps an example of using subprocess? - Michael Mior
15
[+6] [2012-11-15 17:13:22] Joe

I recommend trying Envoy [1]. It's a wrapper for subprocess, which in turn aims to replace [2] the older modules and functions. Envoy is subprocess for humans.

Example usage from the readme [3]:

>>> r = envoy.run('git config', data='data to pipe in', timeout=2)

>>> r.status_code
129
>>> r.std_out
'usage: git config [options]'
>>> r.std_err
''

Pipe stuff around too:

>>> r = envoy.run('uptime | pbcopy')

>>> r.command
'pbcopy'
>>> r.status_code
0

>>> r.history
[<Response 'uptime'>]
[1] https://github.com/kennethreitz/envoy
[2] http://docs.python.org/2/library/subprocess.html
[3] https://github.com/kennethreitz/envoy#readme

16
[+5] [2011-01-18 19:21:44] cdunn2001

subprocess.check_call is convenient if you don't want to test return values. It throws an exception on any error.


17
[+4] [2010-01-08 21:11:30] Atinc Delican

There is another difference here which is not mentioned above.

subprocess.Popen executes the as a subprocess. In my case, I need to execute file which needs to communicate with another program .

I tried subprocess, execution was successful. However could not comm w/ . everything normal when I run both from the terminal.

One more: (NOTE: kwrite behaves different from other apps. If you try below with firefox results will not be the same)

If you try os.system("kwrite"), program flow freezes until user closes kwrite. To overcome that I tried instead os.system(konsole -e kwrite). This time program continued to flow but kwrite became the subprocess of the konsole.

Anyone runs the kwrite not being a subprocess (i.e. at the system monitor it must be appear at the leftmost edge of the tree)

Thanks


18
[+4] [2012-06-11 22:28:35] Saurabh Bangad

os.system does not allow you to store results, so if you want to store results in some list or something subprocess.call works.


19
[+4] [2013-04-17 14:10:06] Jens Timmerman

There are a lot of different ways to run external commands in python, and all of them have their own plus sides and drawbacks.

My colleagues and me have been writing python sysadmin tools, so we need to run a lot of external commands, and sometimes you want them to block or run asynchronously, time-out, update every second...

There are also different ways of handling the return code and errors, and you might want to parse the output, and provide new input (in an expect [1] kind of style) Or you will need to redirect stdin, stdout and stderr to run in a different tty (e.g., when using screen)

So you will probably have to write a lot of wrappers around the external command. So here is a python module which we have written which can handle almost anything you would want, and if not, it's very flexible so you can easily extend it:

https://github.com/hpcugent/vsc-base/blob/master/lib/vsc/utils/run.py

[1] http://en.wikipedia.org/wiki/Expect

20
[+3] [2008-09-18 01:43:30] Ben Hoffstein

http://www.python.org/doc/2.5/lib/module-subprocess.html

...or for a very simple command:

import os
os.system('cat testfile')

21
[+3] [2012-07-16 15:16:24] admire

you can use Popen, then you can check procedure's status

from subprocess import Popen

proc = Popen(['ls', '-l'])
if proc.poll() is None:
    proc.kill()

Check this out subprocess.Popen [1]

[1] http://docs.python.org/library/subprocess.html#popen-objects

22
[+3] [2012-07-25 06:51:50] codelover

Very simplest way to run any command and get result back:

from commands import getstatusoutput

try:
    return getstatusoutput("ls -ltr")
except Exception, e:
    return None

I like this one: is this going to be deprecated in python 3.0? - 20050 8519 21102 26896 16937
23
[+3] [2013-06-19 23:18:34] imagineerThis

Just to add to the discussion, if you include using a Python console, you can call external commands from ipython. While in the ipython prompt, you can call call shell commands by prefixing '!'. You can also combine python code with shell, and assign the output of shell scripts to python variables.

For instance:

In [9]: mylist = !ls

In [10]: mylist
Out[10]:
['file1',
 'file2',
 'file3',]

24
[+2] [2012-08-13 18:36:32] mdwhatcott

I quite like shell_command [1] for its simplicity. It's built on top of the subprocess module.

[1] http://shell-command.readthedocs.org/en/latest/index.html

25
[+2] [2013-04-18 17:39:50] Colonel Panic

The subprocess module [1] described above by Eli is very powerful, but the syntax to make a bog-standard system call and inspect its output, is unnecessarily prolix.

The easiest way to make a system call is with the commands module [2] (Linux only).

> import commands
> commands.getstatusoutput("grep matter alice-in-wonderland.txt")
(0, "'Then it doesn't matter which way you go,' said the Cat.")

The first item in the tuple is the return code of the process. The second item is its standard output (and standard error, merged).


The Python devs have 'deprecated' the commands module, but that doesn't mean you shouldn't use it. Only that they're not developing it anymore, which is okay, because it's already perfect (at its small but important function).

[1] http://docs.python.org/2/library/subprocess.html
[2] http://docs.python.org/2/library/commands.html

(4) Deprecated doesn't only mean "isn't developed anymore" but also "you are discouraged from using this". Deprecated features may break anytime, may be removed anytime, or may dangerous. You should never use this in important code. Deprecation is merely a better way than removing a feature immediately, because it gives programmers the time to adapt and replace their deprecated functions. - Misch
(1) Just to prove my point: "Deprecated since version 2.6: The commands module has been removed in Python 3. Use the subprocess module instead." - Misch
It's not dangerous! The Python devs are careful only to break features between major releases (ie. between 2.x and 3.x). I've been using the commands module since 2004's Python 2.4. It works the same today in Python 2.7. - Colonel Panic
(5) With dangerous, I didn't mean that it may be removed anytime (that's a different problem), neither did I say that it is dangerous to use this specific module. However it may become dangerous if a security vulnerability is discovered but the module isn't further developed or maintained. (I don't want to say that this module is or isn't vulnerable to security issues, just talking about deprecated stuff in general) - Misch
26
[+2] [2014-03-14 02:59:05] Jake W

After some research, I have the following code which works very well for me. It basically prints both stdout and stderr in real time. Hope it helps someone else who needs it.

stdout_result = 1
stderr_result = 1


def stdout_thread(pipe):
    global stdout_result
    while True:
        out = pipe.stdout.read(1)
        stdout_result = pipe.poll()
        if out == '' and stdout_result is not None:
            break

        if out != '':
            sys.stdout.write(out)
            sys.stdout.flush()


def stderr_thread(pipe):
    global stderr_result
    while True:
        err = pipe.stderr.read(1)
        stderr_result = pipe.poll()
        if err == '' and stderr_result is not None:
            break

        if err != '':
            sys.stdout.write(err)
            sys.stdout.flush()


def exec_command(command, cwd=None):
    if cwd is not None:
        print '[' + ' '.join(command) + '] in ' + cwd
    else:
        print '[' + ' '.join(command) + ']'

    p = subprocess.Popen(
        command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd
    )

    out_thread = threading.Thread(name='stdout_thread', target=stdout_thread, args=(p,))
    err_thread = threading.Thread(name='stderr_thread', target=stderr_thread, args=(p,))

    err_thread.start()
    out_thread.start()

    out_thread.join()
    err_thread.join()

    return stdout_result + stderr_result

27
[+1] [2014-04-30 14:37:04] Emil Stenström

I tend to use subprocess [1] together with shlex [2] (to handle escaping of quoted strings):

>>> import subprocess, shlex
>>> command = 'ls -l "/your/path/with spaces/"'
>>> call_params = shlex.split(command)
>>> print call_params
["ls", "-l", "/your/path/with spaces/"]
>>> subprocess.call(call_params)
[1] https://docs.python.org/2/library/subprocess.html
[2] https://docs.python.org/2/library/shlex.html

28
[+1] [2014-05-01 20:49:01] houqp

Shameless plug, I wrote a library for this :P https://github.com/houqp/shell.py

It's basically a wrapper for popen and shlex for now. It also supports piping commands so you can chain commands easier in Python. So you can do things like:

ex('echo hello shell.py') | "awk '{print $2}'"

29
[+1] [2014-08-24 21:46:12] amehta

A simple way is to use the os module:

import os
os.system('ls')

Alternatively you can also use the subprocess module

import subprocess
subprocess.check_call('ls')

If you want the result to be stored in a variable try:

import subprocess
r = subprocess.check_output('ls')

30
[0] [2014-04-12 11:58:23] andrusr

Use subprocess.call [1]:

from subprocess import call

# using list
call(["echo", "Hello", "world"])

# single string argument varies across platforms so better split it
call("echo Hello world".split(" "))
[1] https://docs.python.org/2/library/subprocess.html

31
[0] [2014-10-10 17:41:13] stuckintheshuck

There is also Plumbum [1]

>>> from plumbum import local
>>> ls = local["ls"]
>>> ls
LocalCommand(<LocalPath /bin/ls>)
>>> ls()
u'build.py\ndist\ndocs\nLICENSE\nplumbum\nREADME.rst\nsetup.py\ntests\ntodo.txt\n'
>>> notepad = local["c:\\windows\\notepad.exe"]
>>> notepad()                                   # Notepad window pops up
u''                                             # Notepad window is closed by user, command returns
[1] http://plumbum.readthedocs.org/en/latest/

32