What is subprocess Popen in Python?
`subprocess.Popen` is a low-level interface for running subprocesses, while subprocess.run is a high-level wrapper around Popen intended for ease of use. Popen allows you to start a new process and interact with its standard input, output, and error streams. It returns a handle to the running procedure that can be used to wait for the procedure to complete, check its return code, or abort it. run is a more flexible function that allows you to run a command and capture its results in a single call, allowing you to specify options for a command without having to create a Popen object and manage the streams yourself, such as whether to raise or exception if the command fails.
In general, you should use run if you just want to run the command and capture its output and Popen if you need more control over the process, such as interacting with its input and output streams. The Popen class takes the same arguments as run(), including args specifying which commands to run and other optional arguments such as stdin, stdout, stderr, shell, cwd, and env
Python Subprocess check_output
In the subprocess module, check_output
is a function that closely resembles run()
. It has the specific behavior of returning only the standard output of the command. However, it differs in how it handles command execution outcomes: if the command’s return code is non-zero, it triggers a CalledProcessError
exception. The check_output
function shares the same set of arguments as the run()
function. This includes the ‘args’ parameter, which defines the command to be executed, and it also accepts additional optional arguments like ‘stdin’, ‘stderr’, ‘shell’, ‘cwd’, and ‘env’.
Python3
import subprocess try : ans = subprocess.check_output([ "python" , "--version" ], text = True ) print (ans) except subprocess.CalledProcessError as e: print (f "Command failed with return code {e.returncode}" ) |
Python 3.7.17
Python Subprocess Pipe
The Python subprocess module empowers the creation and interaction with child processes, which enables the execution of external programs or commands. A standout feature of this module is the capacity to establish pipes, facilitating communication between the parent and child processes. To create such pipes, you can employ the subprocess module in combination with the Popen class. By specifying the ‘stdout’ or ‘stdin’ argument as ‘subprocess.PIPE’, you establish this interprocess communication channel. For instance, the code snippet below illustrates a pipe that connects the output of the ‘ls’ command to the input of the ‘grep’ command, which filters the output to display only the lines containing the word “file”.
Python3
import subprocess lsProcess = subprocess.Popen([ "ls" ], stdout = subprocess.PIPE, text = True ) grepProcess = subprocess.Popen( [ "grep" , "sample" ], stdin = ls_process.stdout, stdout = subprocess.PIPE, text = True ) output, error = grepProcess.communicate() print (output) print (error) |
sample_file
Python Subprocess Call
subprocess.call()
is a Python function within the subprocess module. It is employed to execute a command in a separate process and wait for its completion. The function returns a return code, which is typically zero for success and non-zero for failure. This function shares its arguments with subprocess.run()
, such as ‘args’ for specifying the command to be executed, along with optional parameters like ‘stdin’, ‘stdout’, ‘stderr’, ‘shell’, ‘cwd’, and ‘env’.
By default, the command’s standard output and error are directed to the same output streams as the parent process unless you explicitly redirect them using the ‘stdout’ and ‘stderr’ arguments.
Python3
import subprocess ans = subprocess.call([ "python" , "--version" ]) if ans = = 0 : print ( "Command executed." ) else : print ( "Command failed." , return_code) |
Python 3.7.17 Command executed.
Python subprocess module
The subprocess module present in Python(both 2.x and 3.x) is used to run new applications or programs through Python code by creating new processes. It also helps to obtain the input/output/error pipes as well as the exit codes of various commands. In this tutorial, we’ll delve into how to effectively use subprocessing modules to execute external functions from your Python code, pass data to them, and get results Whether you’re a beginner or an experienced Python user developer, this guide will prove useful with your skills and abilities.