subprocess.run are two different ways to interact with and run external processes in Python using the
They serve similar purposes but have some key differences in terms of how they are used and what they return.
Subprocess.popen Vs Subprocess.run
subprocess.Popen is a class that is used to create a new process and execute a command in that process.
It returns a Popen object, which represents the newly created process. This object allows you to communicate with and control the external process in various ways.
Some important points about
- You can specify command and arguments as a list of strings.
- It does not wait for the process to complete by default; you need to call
.communicate()on the Popen object if you want to wait.
- It provides more control over input and output streams, allowing you to interact with the process while it’s running.
- You can redirect the standard input, standard output, and standard error of the child process.
- It is more flexible but requires more code to manage the process.
import subprocess cmd = ["ls", "-l"] process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = process.communicate()Code language: Python (python)
subprocess.run is a higher-level function introduced in Python 3.5 (PEP 478) that simplifies the process of running external commands and waiting for them to complete. It returns a CompletedProcess object, which contains information about the completed process. Some key points about
- You pass the command and arguments as a single string or a list of strings.
- It waits for the process to complete by default.
- It automatically captures and returns the standard output and standard error of the child process as text.
- It is a more convenient and recommended way to run external commands in Python 3.5 and later.
import subprocess cmd = ["ls", "-l"] result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) print(result.returncode) print(result.stdout) print(result.stderr)Code language: Python (python)
here’s a table summarizing the key differences between
|Returns||Popen object||CompletedProcess object|
|Command and Arguments||List of strings||String or list of strings|
|Waits for Completion||No (must call ||Yes (waits for the process to complete)|
|Captures Standard Output||Optional (can redirect)||Yes (automatically captured)|
|Captures Standard Error||Optional (can redirect)||Yes (automatically captured)|
|Input/Output Redirection||Highly configurable||Limited, but possible (through arguments)|
|Simplicity||More flexible, but requires more code||Simpler and more convenient|
|Recommended in Python 3.5+||No||Yes|
These differences should help you decide which one to use based on your specific use case and requirements.
When to Use subprocess.Popen vs. subprocess.run
You should use
subprocess.run based on your specific needs and requirements. Here are some guidelines for when to use each of them:
- Fine-Grained Control: You need fine-grained control over the child process, its input, output, and error streams, and you are comfortable managing these aspects programmatically.
- Interactive Processes: You are dealing with interactive processes that require ongoing interaction while they are running.
- Custom Input/Output Handling: You want to customize how the child process’s input and output are handled, such as reading and writing to streams manually.
- Background Processes: You need to start a process and continue with other tasks in your Python script without waiting for the process to complete immediately.
- Advanced Scenarios: You have advanced scenarios, like dealing with complex piping or chaining multiple processes together.
- Simplicity: You want a simple and straightforward way to run an external command, capture its output, and wait for it to complete.
- Python 3.5+: You are using Python 3.5 or later, as
subprocess.runis available in Python 3.5 and newer versions.
- Basic Command Execution: Your use case involves running a command with basic input and output requirements, and you don’t need to interact with the process while it’s running.
- Error Handling: You want a convenient way to capture the return code, standard output, and standard error of the command in a CompletedProcess object.
- Readability: You prioritize code readability and simplicity, as
subprocess.runprovides a more concise way to achieve common subprocess tasks.
In general, if your task involves running simple external commands and capturing their output and return codes,
subprocess.run is a more convenient choice. However, if you need more control or are dealing with complex subprocess interactions,
subprocess.Popen is the way to go.
subprocess.Popen provides more control and flexibility, while
subprocess.run is a higher-level, simplified approach for running external commands and is often preferred for its ease of use and improved readability, especially in Python 3.5 and later versions. The choice between them depends on your specific requirements and the level of control you need over the external process.
- Python Subprocess Tutorial
- Subprocess Python Stdout
- Python Subprocess Stderr
- Python Asyncio Subprocess [Asynchronous Subprocesses]
- Multiple Commands With SSH Using Python Subprocess
- Python Subprocess Run In Background
- Python Execute Shell Command And Get Output
- Face Recognition Based Attendance System Using Python
- Python Subprocess Pipe With Example
- Python Subprocess Interactive
- Python Subprocess AWK
- What is subprocess.wait() With Example