Python is a versatile programming language with a wide range of features that make it popular among developers. One of these features is the ability to execute external programs or system commands. This is useful when you need to automate tasks or interact with the operating system on which Python is running. In this blog post, we will explore how to execute a program or call a system command in Python, with code examples and step-by-step instructions.

1. Using the os module to execute a program

The os module in Python provides a way to interact with the operating system. It can be used to execute external programs by calling the os.system() function. This function takes a string argument that represents the command to be executed. For example, if you want to execute the ls command on a Unix-based system, you can use the following code:

import os


This will execute the ls command and print the output to the console. You can also use this method to execute other programs, such as a Python script or an executable file.

2. Using the subprocess module to execute a program

While the os.system() function is a simple way to execute a program, it has some limitations. For example, it doesn’t provide a way to capture the output of the command or pass arguments to the program. To overcome these limitations, you can use the subprocess module in Python.

The subprocess module provides several functions for executing external programs, including,, and subprocess.Popen(). These functions provide more flexibility than the os.system() function, allowing you to capture the output of the program, pass arguments, and control the input and output streams.

Here’s an example of using the function to execute the ls command and capture the output:

import subprocess

result =["ls", "-l"], capture_output=True, text=True)

In this code, we pass a list of arguments to the function, which includes the command to be executed and any arguments to that command. We also set the capture_output argument to True to capture the output of the command and the text argument to True to return the output as a string instead of bytes.

3. Using the os and subprocess modules to call a system command

In addition to executing external programs, you can also call system commands using Python. System commands are built-in commands that are available on the operating system, such as cd, mkdir, and rm.

To call a system command in Python, you can use the os.system() function or the function. For example, to create a new directory using the mkdir command, you can use the following code:

import os
import subprocess

# Using os.system() function
os.system("mkdir new_directory")

# Using function["mkdir", "new_directory"])

Both of these functions will execute the mkdir command and create a new directory called new_directory.

4. Handling errors and exceptions

When executing external programs or system commands in Python, it’s important to handle errors and exceptions. External programs may not always execute successfully, and system commands may fail if the user doesn’t have the necessary permissions or if the command doesn’t exist.

To handle errors and exceptions when using the subprocess module, you can use the check_returncode attribute of the CompletedProcess object. This attribute will raise a CalledProcessError exception if the return code of the process is non-zero, indicating that an error occurred. Here’s an example:

import subprocess

    result =["nonexistent_command"], capture_output=True, text=True, check=True)
except subprocess.CalledProcessError as e:
    print("An error occurred:", e)

In this code, we’re trying to execute a non-existent command using the function. Since this command doesn’t exist, an error will occur and the check_returncode attribute will raise a CalledProcessError exception. We’re catching this exception and printing a custom error message.

5. Security considerations

Executing external programs or system commands in Python can pose security risks if not done correctly. Malicious input or commands can cause unexpected and potentially harmful behavior, such as deleting or modifying files on the system.

To minimize these risks, it’s important to validate user input and sanitize any input that may be used as a command or argument. You should also limit the privileges of the user running the Python script to prevent unauthorized access to the system.


In this blog post, we’ve explored how to execute a program or call a system command in Python, using the os and subprocess modules. We’ve also discussed error handling and security considerations when using these functions. By using these techniques, you can automate tasks and interact with the operating system in a safe and controlled way.

Leave a Reply