Assign output of os.system to a variable and prevent it from being displayed on the screen

The mighty subprocess.Popen

subprocess.Popen is a Swiss army knife for handling subprocesses. It can do everything from executing complex shell commands to redirecting outputs and managing standard error.

import subprocess

with subprocess.Popen('your_command', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True) as proc:
    stdout, stderr = proc.communicate()
# stdout now quietly holds your command output, stderr houses any errors.


Dead simple, right? Just remember that while os.popen('command').read() might seem simpler, it doesn't provide the lavish control over the process that Popen gives.

subprocess.run and the CompletedProcess object

Let's simplify things a bit. If you're using Python 3.5 or newer, you can use subprocess.run to manage subprocesses in a more straightforward way:

result = subprocess.run(['your_command'], capture_output=True, text=True) # don't forget the magic arguments!
output = result.stdout


Who knew it could be that easy? By using run, we get a nice CompletedProcess object, making it even easier to get our hands on the command results.

Handling errors and creating utility functions

There's more to life than just success, and the same applies to subprocess management. With check=True, you can raise a CalledProcessError if the command exits with a non-zero status:

def run_command(command):
    # because let's face it, we often forget to check return codes. 😄
    result = subprocess.run(command, capture_output=True, text=True, check=True)
    return result.stdout.strip()


This approach also makes the process of capturing a command's output available as a reusable function.

Getting the most out of subprocess

There's even more to subprocess than capturing output quietly! For example, the universal_newlines=True argument can make handling outputs a lot more convenient. With its extensive features, it's definitely worth taking a deeper dive into the subprocess module in the Python documentation.

Dealing with prohibitions and potential pitfalls

While subprocess is a powerful tool, it's important to consider the trade-offs and potential pitfalls:

1. Error Handling: Not managing return codes or errors may lead to silent failures.
2. Shell Injection: Using shell=True can open the door to shell injection attacks.
3. Performance: Spawning subprocesses may have significant overhead.

By using best practices, checking return codes, and staying aware of potential security implications, you can avoid these issues.

Platform-specific considerations

Certain shell commands and syntax may not be available on all platforms. Although subprocess is platform-agnostic, it's important to ensure your commands are compatible with your target operating system.