Difference between subprocess.run and subprocess.Popen

The core of the module subprocessis subprocess.Popen, for its part it subprocess.runwas added in Python 3.5 and is basically a wrapper oversubprocess.Popen and that was created to integrate and unify various old functions like subprocess.call. It basically allows you to run a command on a thread and wait until it finishes.

The keyword is "wait", it run blocks the main process until the command executed in the child process finishes while with subprocess.Popenyou can continue doing things in the parent process in parallel in the meantime, calling to subprocess.communicatepass or receive data from the threads whenever you want .

As already mentioned, subprocess.runit only makes it easier to use, below it calls subprocess.Popenand makes use of subprocess.comunicate. In fact, all arguments are passed directly to the Popenminus-three constructor:

• timeout: it is passed to Popen.communicategenerating an exception TimeoutExpiredif the process does not return before it. However, unlike what happens with Popen.comunicateraw, before throwing the exception instructions are sent to kill the child process and wait.

• input: is also passed to Popen.communicate. As a caveat, when this argument is used internally Popen associates stdin with a pipe ( stdin = subprocess.PIPE) so it should not be used in conjunction with the argument stdin.

• check: If the process exits with a non-zero exit code, an exception will be thrown CalledProcessError.

On the other hand, subproccess.run it returns an objectsubprocess.CompletedProcess representing the result of a terminated process:

• subprocess.CompletedProcess.args: are the arguments used to launch the process, in direct relation to the object passed to the argument argsof subprocess.run.

• subprocess.CompletedProcess.returncode: is simply the exit status of the process. Typically 0 indicates that the process was executed correctly, although logically it is something that is defined by the process itself.

• subprocess.CompletedProcess.stdout: captures the standard output of the thread or Noneif it has not been captured. It is a byte string or a text string ( str) if it was passed Trueto the argument universal_newlines=Trueof subprocess.run. In order to capture the output it is necessary to redirect it via a pipe by calling subprocess.runviastdout=subperocess.PIPE

• subprocess.CompletedProcess.stderr: exactly the same as the previous attribute, only for stderr.

• subprocess.CompletedProcess.check_returncode(): Just as when defined checkas Truein the constructor of subprocess.run, this method when called throws an exception CalledProcessErrorif the thread's return code is not zero.

At this point, the second question you raise about when to use one or the other is already answered. What you have to ask yourself is do I want to wait for the command to execute and finish before continuing execution in the parent process? . If so, use subprocess.run. You can obviously achieve the same thing with subprocess.Popen+ comunicate(), but it requires more code and work (hence the rationale for run).

For a very simplified example, let's imagine we have the following Python script on a *nix system that we're going to run as a thread:

import select
import sys
import time


for i in range(10):
    time.sleep(1)
    if select.select([sys.stdin], [], [], 0.0)[0]:
        if sys.stdin.read() == "salir":
            break
print(f"Se ha esperado {i} segundos")

as an example, it doesn't do anything, it just takes about 10 seconds for the process to finish but we can stop it at any time if we send it "exit" via stdin.

If we launch the process via subprocess.run , our parent process is blocked for the 10 seconds that the child takes to return without further ado:

import subprocess


process = subprocess.run(args=["python", "dropdownlist.py"],
                           stdout=subprocess.PIPE,
                           stdin=subprocess.PIPE,
                           encoding='utf8'
                           )
print(process.stdout)

Waited 10 seconds

Once the thread is launched, our main process blocks and only continues (executing print(process.stdout)) when the thread terminates.

Instead using subprocess.Popenwe can do other things while the process is running and eventually communicate with it at some point to stop it:

import subprocess
import time


process = subprocess.Popen(args=["python", "dropdownlist.py"],
                           stdout=subprocess.PIPE,
                           stdin=subprocess.PIPE,
                           encoding='utf8'
                           )

time.sleep(5) # hacemos cualquier cosa mientra tanto
out, _ = process.communicate("salir")
print(out)

5 seconds waited

Imagine that you have a CLI program that plays audio files and at the same time that it plays, it returns certain information via standard output such as the progress and also allows you to send commands to pause, resume, etc. If you want to run such a program from a Python script, you could consider two possibilities. If you just want to play a file from start to finish and meanwhile your Python script just waits and does nothing, that subprocess.runwould be your simplest choice. If you want to be able to stop, resume, etc. the playback while using the information that the player sends subprocess.Popen+ comunicate(to send the commands and receive the information that the player sends via stdout) is the right option.

Following the same logic, if you want to issue several threaded commands intended to run in parallel, you should use subprocess.Popensince it would subprocess.runexecute them serially.