What Is The Difference Between Subprocess.popen And Subprocess.run

subprocess.Popen and subprocess.run are two different ways to interact with and run external processes in Python using the subprocess module.

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 subprocess.Popen:

  • 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 .wait() or .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 subprocess.run:

  • 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)
Code language: Python (python)

Learn More : Learn Subprocess.run() in Python [Step-by-Step Examples]

here’s a table summarizing the key differences between subprocess.Popen and subprocess.run:

ReturnsPopen objectCompletedProcess object
Command and ArgumentsList of stringsString or list of strings
Waits for CompletionNo (must call .wait() or .communicate())Yes (waits for the process to complete)
Captures Standard OutputOptional (can redirect)Yes (automatically captured)
Captures Standard ErrorOptional (can redirect)Yes (automatically captured)
Input/Output RedirectionHighly configurableLimited, but possible (through arguments)
SimplicityMore flexible, but requires more codeSimpler and more convenient
Recommended in Python 3.5+NoYes

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.Popen and subprocess.run based on your specific needs and requirements. Here are some guidelines for when to use each of them:

Use subprocess.Popen when:

  1. 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.
  2. Interactive Processes: You are dealing with interactive processes that require ongoing interaction while they are running.
  3. 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.
  4. 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.
  5. Advanced Scenarios: You have advanced scenarios, like dealing with complex piping or chaining multiple processes together.

Use subprocess.run when:

  1. Simplicity: You want a simple and straightforward way to run an external command, capture its output, and wait for it to complete.
  2. Python 3.5+: You are using Python 3.5 or later, as subprocess.run is available in Python 3.5 and newer versions.
  3. 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.
  4. Error Handling: You want a convenient way to capture the return code, standard output, and standard error of the command in a CompletedProcess object.
  5. Readability: You prioritize code readability and simplicity, as subprocess.run provides 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.


In summary, 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.

Read More;

  • Aniket Singh

    Aniket Singh holds a B.Tech in Computer Science & Engineering from Oriental University. He is a skilled programmer with a strong coding background, having hands-on experience in developing advanced projects, particularly in Python and the Django framework. Aniket has worked on various real-world industry projects and has a solid command of Python, Django, REST API, PostgreSQL, as well as proficiency in C and C++. He is eager to collaborate with experienced professionals to further enhance his skills.

Leave a Comment