How to Execute External Commands in Python with Subprocess Module

Executing external commands within a Python script can be essential for automating tasks, interacting with the operating system, or integrating with other software. The `subprocess` module in Python provides a robust and flexible way to call external commands as if they were typed in a shell or command prompt. In this article, we’ll explore how to effectively use the `subprocess` module to execute commands, handle input/output streams, and deal with errors.

1. Using to Execute Commands.

1.1 Running Simple Commands and Capturing Output.

The `` function is a convenient way to execute external commands. It allows you to specify the command as a list of strings, capturing the output, and handling errors. Let’s see an example:

import subprocess

# Execute a simple command
result =["dir", "d:\\"], capture_output=True, text=True, shell=True)

# Print the output

In this example, we use `` to execute the `dir` command, capturing its output as a string and printing it. The `capture_output=True` parameter ensures that the output is captured, while `text=True` decodes the output as a string.

2. Handling Input and Output Streams.

2.1 Redirecting Input/Output Streams.

The `subprocess` module allows you to redirect input and output streams of the external command. This is useful for providing input to the command or capturing its output in real-time. Here’s an example:

import subprocess

# Execute a command with input and output redirection
with open("output.txt", "w", encoding="utf-8") as outfile:["dir", "c:\\"], stdout=outfile, shell=True)

In this example, we execute the `dir  c:\\` command and redirect its output to a file named `output.txt`.

You can similarly redirect input streams using the `input` parameter like the below example.

import subprocess

# Command to execute
command = "findstr /i apple"

# Input text to be passed to the command
input_text = "I like apples\nDo you like oranges?\n"

# Using subprocess to execute the command and pass input text
    # Execute the command, passing input_text as input and capturing output
    result =, input=input_text, text=True, capture_output=True, shell=True)

    # Check if the command executed successfully
    if result.returncode == 0:
        # Print the output of the command
        # Print error message if the command failed
        print("Error:", result.stderr)
except FileNotFoundError:
    # Print error if the command is not found
    print("Error: Command not found.")


I like apples

3. Handling Errors and Exceptions.

3.1 Dealing with Command Execution Errors.

When executing external commands, it’s crucial to handle errors and exceptions gracefully. The `subprocess` module provides mechanisms for capturing errors and handling them appropriately. Consider the following example:

import subprocess

    # Execute a command that may raise an error["ls", "-l"], check=True, shell=True)
except subprocess.CalledProcessError as e:
    # Handle the error
    print(f"Error: {e}")

In this example, we attempt to execute a nonexistent command, which raises a `CalledProcessError`. We catch the error using a `try-except` block and handle it accordingly.

4. Conclusion.

The `subprocess` module in Python offers a powerful way to execute external commands within a script. By leveraging functions like ``, you can execute commands, handle input/output streams, and manage errors effectively. Whether you’re automating system tasks or integrating with other software, understanding how to use `subprocess` is essential for building robust Python applications.

5. Demo Video for This Article.

Leave a Comment

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.