The World of Python Programming

How to Run System Commands in Python: Complete Guide with Examples

APIs & External Libraries
目次

1. What Does Running Commands in Python Mean?

Python is a programming language widely used for automating various tasks, and one of its key advantages is the ability to execute command-line operations directly from a program. With Python, you can call OS functions to automate file operations and system management. In this article, we will cover everything from the basics to advanced techniques of running system commands with Python.

2. Basic Methods to Run Commands in Python

The most basic ways to run commands in Python are by using os.system() or the subprocess module. Each method has its pros and cons, so it’s important to choose the right one depending on the situation.

2.1 Running Commands with os.system()

os.system() is a simple way to run system commands from a Python program. For example:
import os
os.system('ls')
This method is easy to use, but it cannot capture the command output and raises security concerns. Therefore, it is generally not recommended. Nowadays, the more controllable subprocess module is preferred.

2.2 Running Commands with subprocess.run()

subprocess.run() is the recommended way to run commands in Python. It allows you to capture results and handle errors more safely and flexibly.
import subprocess
subprocess.run(['ls', '-l'])
This code executes the ls -l command and displays the result in standard output. subprocess.run() works synchronously, meaning it waits until the command finishes before proceeding. This is especially useful for file operations and system management tasks.
侍エンジニア塾

3. Advanced Command Execution: Async and Piping

For more advanced scenarios, the subprocess module supports asynchronous execution and piping, enabling efficient automation of complex workflows.

3.1 Asynchronous Execution with subprocess.Popen()

Asynchronous processing lets you continue with the next task without waiting for the command to finish, making it useful for running multiple tasks simultaneously. For example:
import subprocess
proc = subprocess.Popen(['sleep', '5'])
print("The command is running")
This code runs the sleep 5 command asynchronously and immediately prints “The command is running.” Async execution is useful for time-consuming commands or parallel tasks.

3.2 Piping Multiple Commands Together

When you need to chain multiple commands, piping is very convenient. For instance, reading a file and writing its contents to another file can be done like this:
import subprocess
with open('input.txt') as input_file, open('output.txt', 'w') as output_file:
    subprocess.run(['cat'], stdin=input_file, stdout=output_file)
This code reads the contents of input.txt using the cat command and writes it to output.txt. One of the powerful features of subprocess.run() is the ability to connect standard input and output streams via pipes.

4. Error Handling and Capturing Output

When running commands, handling errors and retrieving results are critical. The subprocess module is designed to handle these tasks flexibly.

4.1 Capturing Standard Output and Error

With subprocess.run(), you can capture both standard output and error output. For example:
import subprocess
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)
print(result.stdout)
Here, specifying capture_output=True captures the standard output of the command. Error output can be accessed via result.stderr.

4.2 Error Handling with Exceptions

If an error occurs during command execution, Python raises an exception. You can use a try-except block to handle errors gracefully.
import subprocess
try:
    subprocess.run(['invalid_command'], check=True)
except subprocess.CalledProcessError as e:
    print(f"An error occurred: {e}")
Here, check=True ensures that an exception is raised if the command fails, allowing you to log or handle errors appropriately.
RUNTEQ（ランテック）｜超実戦型エンジニア育成スクール

5. Differences on Windows, Mac, and Linux

Running commands in Python can behave differently depending on the operating system. In particular, Windows and Unix-like systems (Linux and macOS) differ in command syntax and behavior.

5.1 Running Commands on Windows

On Windows, commands are executed using Command Prompt or PowerShell. For example, to display a directory listing:
import subprocess
subprocess.run(['dir'], shell=True)
On Windows, shell=True must be specified to run internal shell commands.

5.2 Running Commands on Unix-like Systems

On Linux and macOS, shell commands can be executed directly. For example:
import subprocess
subprocess.run(['ls', '-l'])
Command syntax is generally simpler on Unix-like systems compared to Windows.

6. Conclusion

By running commands with Python, you can automate file management and system operations to improve efficiency. The subprocess module supports everything from basic execution to async and piping, making it suitable for a wide range of scenarios. With proper error handling and awareness of OS differences, you can leverage Python to perform flexible and reliable command execution. By mastering these techniques, you can not only streamline daily tasks but also enhance your overall programming skills. Try applying these methods in your projects to see the benefits firsthand.
侍エンジニア塾