How to Executing Linux Commands and Scripts from Python

This guide will walk you through executing Linux commands and shell scripts directly from your Python code, providing you with the flexibility to automate system tasks and build more powerful applications.

The Foundation: subprocess.run

At the heart of this process lies the subprocess.run function, a powerful tool from Python's built-in subprocess module. This function allows you to execute external commands and scripts, capturing their output and managing their execution status.

Simple Command Execution

Let's start with a basic example: displaying the text "Ubuntu Shell" using the echo command.

import subprocess

subprocess.run(["echo", "Ubuntu Shell"])
    

Here, we're providing subprocess.run with a list containing the command name (echo) and its argument (Ubuntu Shell). Running this script will directly execute the echo command in your terminal.

Working with Parameters

You can easily incorporate parameters into your Linux commands. For instance, let's list the contents of a directory with details using the ls -l command:

import subprocess
subprocess.run(["ls", "-l"])
    

This code will execute the ls command with the -l flag, providing a detailed listing of the current directory.

Running Shell Scripts

Executing a shell script from your Python code is similar to running a single command. Let's consider a simple script (script.sh) that prompts the user for their name and greets them:

#!/bin/bash

echo "Please enter your name:"
read name

echo "Hello, $name!"
    

To run this script from Python, simply specify the sh command along with the script's path as arguments to subprocess.run:

import subprocess
subprocess.run(["sh", "./script.sh"])
    

This will execute the script.sh file, interacting with the user as defined within the script.

Understanding Execution Status

To gain insights into the execution of your commands and scripts, subprocess.run offers valuable attributes:

• stdout: Captures the standard output (the data printed to the console) of the executed command.

• stderr: Captures the standard error output (any errors encountered during execution).

• returncode: Returns the exit status code of the command. A code of 0 typically indicates successful execution, while other values indicate errors or failures.

Let's illustrate this by running the echo command and inspecting its output, standard error, and return code:

import subprocess

process = subprocess.run(["echo", "Ubuntu Shell"], capture_output=True, text=True)

print(process.stdout)
print(process.stderr)
print(process.returncode)
    

Here, capture_output=True ensures the output is captured, and text=True converts the captured output to text for easier handling. Running this code will print the output, any error messages, and the exit code.

Capturing Command Output

Storing the output of a command or script within a Python variable allows you to further process it within your program. Here's how to capture the output of the echo command:

import subprocess

output = subprocess.run(["echo", "Ubuntu Shell"], capture_output=True, text=True).stdout.strip("\n")
print(output)
    

We use capture_output=True and text=True to capture and convert the output to text. The .stdout.strip("\n") removes any trailing newline characters for cleaner output.

The Power of Automation

By combining these techniques, you can build powerful automation workflows. Imagine a script that checks the disk space available, sends an email alert if it falls below a threshold, and then automatically cleans up temporary files. This is just one example of the countless possibilities.

Conclusion

Mastering the art of executing Linux commands and scripts from your Python code unlocks a world of automation potential. Whether you're streamlining system administration tasks or building sophisticated applications, subprocess.run provides the flexibility and control you need to interact with your operating system directly from your Python scripts.