17.1. subprocess
— Subprocess management¶
The subprocess
module allows you to spawn new processes, connect to their
input/output/error pipes, and obtain their return codes. This module intends to
replace several other, older modules and functions, such as:
os.system
os.spawn*
Information about how the subprocess
module can be used to replace these
modules and functions can be found in the following sections.
See also
PEP 324 – PEP proposing the subprocess module
17.1.1. Using the subprocess Module¶
This module defines one class called Popen
:
-
class
subprocess.
Popen
(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=())¶ Arguments are:
args should be a string, or a sequence of program arguments. The program to execute is normally the first item in the args sequence or the string if a string is given, but can be explicitly set by using the executable argument. When executable is given, the first item in the args sequence is still treated by most programs as the command name, which can then be different from the actual executable name. On Unix, it becomes the display name for the executing program in utilities such as ps.
On Unix, with shell=False (default): In this case, the Popen class uses
os.execvp()
like behavior to execute the child program. args should normally be a sequence. If a string is specified for args, it will be used as the name or path of the program to execute; this will only work if the program is being given no arguments.Note
shlex.split()
can be useful when determining the correct tokenization for args, especially in complex cases:>>> import shlex, subprocess >>> command_line = input() /bin/vikings -input eggs.txt -output "spam spam.txt" -cmd "echo '$MONEY'" >>> args = shlex.split(command_line) >>> print(args) ['/bin/vikings', '-input', 'eggs.txt', '-output', 'spam spam.txt', '-cmd', "echo '$MONEY'"] >>> p = subprocess.Popen(args) # Success!
Note in particular that options (such as -input) and arguments (such as eggs.txt) that are separated by whitespace in the shell go in separate list elements, while arguments that need quoting or backslash escaping when used in the shell (such as filenames containing spaces or the echo command shown above) are single list elements.
On Unix, with shell=True: If args is a string, it specifies the command string to execute through the shell. This means that the string must be formatted exactly as it would be when typed at the shell prompt. This includes, for example, quoting or backslash escaping filenames with spaces in them. If args is a sequence, the first item specifies the command string, and any additional items will be treated as additional arguments to the shell itself. That is to say, Popen does the equivalent of:
Popen(['/bin/sh', '-c', args[0], args[1], ...])
Warning
Executing shell commands that incorporate unsanitized input from an untrusted source makes a program vulnerable to shell injection, a serious security flaw which can result in arbitrary command execution. For this reason, the use of shell=True is strongly discouraged in cases where the command string is constructed from external input:
>>> from subprocess import call >>> filename = input("What file would you like to display?\n") What file would you like to display? non_existent; rm -rf / # >>> call("cat " + filename, shell=True) # Uh-oh. This will end badly...
shell=False does not suffer from this vulnerability; the above Note may be helpful in getting code using shell=False to work.
On Windows: the
Popen
class uses CreateProcess() to execute the child program, which operates on strings. If args is a sequence, it will be converted to a string in a manner described in Converting an argument sequence to a string on Windows.bufsize, if given, has the same meaning as the corresponding argument to the built-in open() function:
0
means unbuffered,1
means line buffered, any other positive value means use a buffer of (approximately) that size. A negative bufsize means to use the system default, which usually means fully buffered. The default value for bufsize is0
(unbuffered).Note
If you experience performance issues, it is recommended that you try to enable buffering by setting bufsize to either -1 or a large enough positive value (such as 4096).
The executable argument specifies the program to execute. It is very seldom needed: Usually, the program to execute is defined by the args argument. If
shell=True
, the executable argument specifies which shell to use. On Unix, the default shell is/bin/sh
. On Windows, the default shell is specified by theCOMSPEC
environment variable. The only reason you would need to specifyshell=True
on Windows is where the command you wish to execute is actually built in to the shell, egdir
,copy
. You don’t needshell=True
to run a batch file, nor to run a console-based executable.stdin, stdout and stderr specify the executed programs’ standard input, standard output and standard error file handles, respectively. Valid values are
PIPE
, an existing file descriptor (a positive integer), an existing file object, andNone
.PIPE
indicates that a new pipe to the child should be created. WithNone
, no redirection will occur; the child’s file handles will be inherited from the parent. Additionally, stderr can beSTDOUT
, which indicates that the stderr data from the applications should be captured into the same file handle as for stdout.If preexec_fn is set to a callable object, this object will be called in the child process just before the child is executed. (Unix only)
Warning
The preexec_fn parameter is not safe to use in the presence of threads in your application. The child process could deadlock before exec is called. If you must use it, keep it trivial! Minimize the number of libraries you call into.
Note
If you need to modify the environment for the child use the env parameter rather than doing it in a preexec_fn. The start_new_session parameter can take the place of a previously common use of preexec_fn to call os.setsid() in the child.
If close_fds is true, all file descriptors except
0
,1
and2
will be closed before the child process is executed. (Unix only). The default varies by platform: Always true on Unix. On Windows it is true when stdin/stdout/stderr areNone
, false otherwise. On Windows, if close_fds is true then no handles will be inherited by the child process. Note that on Windows, you cannot set close_fds to true and also redirect the standard handles by setting stdin, stdout or stderr.Changed in version 3.2:
Changed in version 3.2: The default for close_fds was changed from
False
to what is described above.
pass_fds is an optional sequence of file descriptors to keep open
between the parent and child. Providing any pass_fds forces
close_fds to be True
. (Unix only)
New in version 3.2:
New in version 3.2: The pass_fds parameter was added.
If cwd is not None
, the child’s current directory will be changed to cwd
before it is executed. Note that this directory is not considered when
searching the executable, so you can’t specify the program’s path relative to
cwd.
If restore_signals is True (the default) all signals that Python has set to SIG_IGN are restored to SIG_DFL in the child process before the exec. Currently this includes the SIGPIPE, SIGXFZ and SIGXFSZ signals. (Unix only)
Changed in version 3.2:
Changed in version 3.2: restore_signals was added.
If start_new_session is True the setsid() system call will be made in the child process prior to the execution of the subprocess. (Unix only)
Changed in version 3.2:
Changed in version 3.2: start_new_session was added.
If env is not None
, it must be a mapping that defines the environment
variables for the new process; these are used instead of the default
behavior of inheriting the current process’ environment.
Note
If specified, env must provide any variables required for the program to
execute. On Windows, in order to run a side-by-side assembly the
specified env must include a valid SystemRoot
.
If universal_newlines is True
, the file objects stdout and stderr are
opened as text files, but lines may be terminated by any of '\n'
, the Unix
end-of-line convention, '\r'
, the old Macintosh convention or '\r\n'
, the
Windows convention. All of these external representations are seen as '\n'
by the Python program.
Note
This feature is only available if Python is built with universal newline
support (the default). Also, the newlines attribute of the file objects
stdout
, stdin
and stderr
are not updated by the
communicate()
method.
If given, startupinfo will be a STARTUPINFO
object, which is
passed to the underlying CreateProcess
function.
creationflags, if given, can be CREATE_NEW_CONSOLE
or
CREATE_NEW_PROCESS_GROUP
. (Windows only)
Popen objects are supported as context managers via the with
statement:
on exit, standard file descriptors are closed, and the process is waited for.
with Popen(["ifconfig"], stdout=PIPE) as proc:
log.write(proc.stdout.read())
Changed in version 3.2:
Changed in version 3.2: Added context manager support.
-
subprocess.
PIPE
¶ Special value that can be used as the stdin, stdout or stderr argument to
Popen
and indicates that a pipe to the standard stream should be opened.
-
subprocess.
STDOUT
¶ Special value that can be used as the stderr argument to
Popen
and indicates that standard error should go into the same handle as standard output.
17.1.1.1. Convenience Functions¶
This module also defines the following shortcut functions:
-
subprocess.
call
(*popenargs, **kwargs)¶ Run command with arguments. Wait for command to complete, then return the
returncode
attribute.The arguments are the same as for the
Popen
constructor. Example:>>> retcode = subprocess.call(["ls", "-l"])
Warning
Like
Popen.wait()
, this will deadlock when usingstdout=PIPE
and/orstderr=PIPE
and the child process generates enough output to a pipe such that it blocks waiting for the OS pipe buffer to accept more data.
-
subprocess.
check_call
(*popenargs, **kwargs)¶ Run command with arguments. Wait for command to complete. If the exit code was zero then return, otherwise raise
CalledProcessError
. TheCalledProcessError
object will have the return code in thereturncode
attribute.The arguments are the same as for the
Popen
constructor. Example:>>> subprocess.check_call(["ls", "-l"]) 0
Warning
See the warning for
call()
.
-
subprocess.
check_output
(*popenargs, **kwargs)¶ Run command with arguments and return its output as a byte string.
If the exit code was non-zero it raises a
CalledProcessError
. TheCalledProcessError
object will have the return code in thereturncode
attribute and output in theoutput
attribute.The arguments are the same as for the
Popen
constructor. Example:>>> subprocess.check_output(["ls", "-l", "/dev/null"]) b'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'
The stdout argument is not allowed as it is used internally. To capture standard error in the result, use
stderr=subprocess.STDOUT
:>>> subprocess.check_output( ... ["/bin/sh", "-c", "ls non_existent_file; exit 0"], ... stderr=subprocess.STDOUT) b'ls: non_existent_file: No such file or directory\n'
New in version 3.1:
New in version 3.1.
-
subprocess.
getstatusoutput
(cmd)¶ Return
(status, output)
of executing cmd in a shell.Execute the string cmd in a shell with
os.popen()
and return a 2-tuple(status, output)
. cmd is actually run as{ cmd ; } 2>&1
, so that the returned output will contain output or error messages. A trailing newline is stripped from the output. The exit status for the command can be interpreted according to the rules for the C functionwait()
. Example:>>> subprocess.getstatusoutput('ls /bin/ls') (0, '/bin/ls') >>> subprocess.getstatusoutput('cat /bin/junk') (256, 'cat: /bin/junk: No such file or directory') >>> subprocess.getstatusoutput('/bin/junk') (256, 'sh: /bin/junk: not found')
Availability: UNIX.
-
subprocess.
getoutput
(cmd)¶ Return output (stdout and stderr) of executing cmd in a shell.
Like
getstatusoutput()
, except the exit status is ignored and the return value is a string containing the command’s output. Example:>>> subprocess.getoutput('ls /bin/ls') '/bin/ls'
Availability: UNIX.
17.1.1.2. Exceptions¶
Exceptions raised in the child process, before the new program has started to
execute, will be re-raised in the parent. Additionally, the exception object
will have one extra attribute called child_traceback
, which is a string
containing traceback information from the child’s point of view.
The most common exception raised is OSError
. This occurs, for example,
when trying to execute a non-existent file. Applications should prepare for
OSError
exceptions.
A ValueError
will be raised if Popen
is called with invalid
arguments.
check_call() will raise CalledProcessError
, if the called process returns
a non-zero return code.
17.1.1.3. Security¶
Unlike some other popen functions, this implementation will never call /bin/sh implicitly. This means that all characters, including shell metacharacters, can safely be passed to child processes.