Python os.system Function

Last modified April 11, 2025

This comprehensive guide explores Python's os.system function, which executes shell commands. We'll cover command execution, return values, security considerations, and practical examples.

Basic Definitions

The os.system function executes a command in a subshell. It takes a string command and returns the exit status of the process.

Key characteristics: blocks until completion, uses system shell (/bin/sh on Unix, cmd.exe on Windows), returns 0 on success, non-zero on failure.

Executing a Simple Command

The most basic usage of os.system runs a single shell command. This example demonstrates executing the 'ls' command on Unix-like systems.

simple_command.py

import os

# Execute a simple command
return_code = os.system("ls -l")

# Print the return code
print(f"Command returned: {return_code}")

# Check if command succeeded
if return_code == 0:
    print("Command executed successfully")
else:
    print("Command failed")

This runs 'ls -l' in the shell and captures the return code. A return code of 0 typically indicates success, while non-zero indicates failure.

Note that the command output goes directly to stdout, not captured by Python. For output capture, consider subprocess.run instead.

Running System Commands

os.system can execute any system command available in the shell. This example shows system information commands on different platforms.

system_commands.py

import os
import platform

# Platform-specific commands
system = platform.system()

if system == "Linux":
    os.system("uname -a")
    os.system("df -h")
elif system == "Windows":
    os.system("systeminfo")
    os.system("wmic diskdrive get size")
elif system == "Darwin":
    os.system("sw_vers")
    os.system("diskutil list")
else:
    print("Unsupported system")

This script detects the operating system and runs appropriate system commands. The output appears directly in the console where Python is running.

Platform detection helps write cross-platform scripts that adapt to different operating systems automatically.

Creating and Managing Files

os.system can interact with the filesystem using shell commands. This example demonstrates file creation, copying, and deletion.

file_management.py

import os

# Create a file
os.system("echo 'Hello World' > test.txt")

# Copy the file
os.system("cp test.txt test_copy.txt")

# List files
os.system("ls -l *.txt")

# Delete files
os.system("rm test.txt test_copy.txt")

# Verify deletion
os.system("ls -l *.txt || echo 'No text files found'")

This script performs basic file operations using shell commands. Each command runs sequentially, with the next starting only after the previous completes.

While Python has built-in file operations, shell commands can be useful for complex operations or when integrating with existing shell scripts.

Environment Variables in Commands

Shell commands can use environment variables, which can be set from Python. This example shows how to pass Python variables to shell commands.

environment_vars.py

import os

# Set variables in Python
username = "testuser"
log_dir = "/var/log"

# Use variables in shell commands
os.system(f"echo 'Processing logs for {username}'")
os.system(f"ls -l {log_dir} | head -n 5")

# Set environment variables
os.environ["TEMP_DIR"] = "/tmp"
os.system('echo "Temporary directory is $TEMP_DIR"')

# Complex command with variables
file_count = 5
os.system(f"for i in $(seq 1 {file_count}); do touch file_$i.txt; done")
os.system("ls file_*.txt")

Python variables can be interpolated into shell commands using f-strings. Environment variables set in Python are available to the subshell.

Be cautious with variable interpolation to avoid shell injection vulnerabilities. Sanitize any user-provided input.

Command Chaining and Pipelines

Shell features like command chaining and pipelines work with os.system. This example demonstrates combining multiple commands.

command_chaining.py

import os

# Simple command chain
os.system("date && echo 'Command successful' || echo 'Command failed'")

# Pipeline example
os.system("ps aux | grep python | head -n 5")

# Complex pipeline with redirection
os.system("grep -r 'import os' . 2>/dev/null | wc -l > count.txt")

# Read the result back
with open("count.txt") as f:
    print(f"Found {f.read().strip()} occurrences")

# Clean up
os.system("rm count.txt")

This shows how to use shell features like && (AND), || (OR), and | (pipeline). Output redirection works as in normal shell usage.

Command chaining can make complex operations concise, but may reduce readability for those unfamiliar with shell syntax.

Handling Command Output

While os.system doesn't capture output, we can redirect to files. This example shows techniques for working with command output.

command_output.py

import os

# Redirect output to a file
os.system("ls -l / > dir_listing.txt")

# Read the output file
with open("dir_listing.txt") as f:
    print("Directory listing:")
    print(f.read())

# Temporary file pattern
import tempfile
with tempfile.NamedTemporaryFile() as tmp:
    os.system(f"uname -a > {tmp.name}")
    print("\nSystem info:")
    print(tmp.read().decode())

# Error handling
os.system("ls nonexistent_dir 2> errors.txt")
with open("errors.txt") as f:
    print("\nErrors:")
    print(f.read())

Output can be captured by redirecting to files, then reading those files. Temporary files provide a cleaner approach than manually managing files.

For more advanced output handling, consider subprocess.Popen or subprocess.run.

Security Considerations

Shell injection: Avoid unsanitized user input in commands
Platform differences: Commands may behave differently across OS
Error handling: Check return codes for command success
Alternatives: Prefer subprocess for more control
Environment: Commands run in subshell with current environment

Best Practices

Input sanitization: Always sanitize dynamic command parts
Return code checking: Verify commands succeeded
Platform awareness: Test commands on target platforms
Error handling: Handle potential command failures
Documentation: Document shell dependencies clearly

Source References

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Python tutorials.

Ebooks