Retrieving the output of subprocess.call()

Going deeper: understand and explore alternatives

The right function for the mission

Different missions require different tools. While subprocess.run() is your Swiss Army knife, some tasks might require the surgical precision of subprocess.Popen() with stdout=subprocess.PIPE. Pick your weapon of choice according to the complexity of the task and your Python version constraints.

import subprocess
# Python's about to launch a process, stand back!
with subprocess.Popen(['ls', '-l'], stdout=subprocess.PIPE, text=True) as proc:
    output, _ = proc.communicate()  # Python, the undercover spy, eavesdrops on the output


Sniff out errors like a bloodhound

Errors are like rats. You don't want them, but you can't ignore them. By passing both stderr=subprocess.PIPE and stdout, Python turns into a bloodhound, sniffing out errors as well as output.

result = subprocess.run(['ls', '-la'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
print(f"Output: {result.stdout}")
print(f"Error: {result.stderr if result.stderr else 'Rats! No errors found.'}")


Code notation: More universal than Esperanto

Different systems, different dialects. That's why we have shlex.split() for tokenizing command strings, giving us a syntax more universal than Esperanto, and enhancing compatibility across platforms.

import shlex, subprocess
# Remember to mind your sentence structure here
command = shlex.split("ls -la")
result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
print(result.stdout)


Decoding Hogwarts letters

Sometimes, the output is like a Hogwarts letter while your app only understands Muggle English. By choosing text=True your output is decoded into a human-friendly string format. If not, you'll have a bunch of cryptic bytes to decode.

Take a hint from Indiana Jones

Remember to use the correct tools! subprocess.call() works like an archaeologist cataloguing artifact (exit status), while run() and check_output() are the scribes, capturing every detail of the output.

Hacks, tips, and things that make you go "Hmm...”

Ready for all scenarios

Mistakes happen, but Python can take it on the chin. It's always ready with CalledProcessError. A solid defence against potential errors entails good error handling.

try:
    # Python listening for whispers of a ghost command
    output = subprocess.check_output(['false_command'], stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
    # A boo-boo happened, let's clean up and move on
    print(f"An error occurred: {e.output}")


Debunking misunderstandings

A common pitfall is trying to use StringIO with subprocess.call() for output capture. But this is like fitting a round peg in a square hole and ends up serving no purpose.

Quick hands, clean job

Avoid cluttering up your code with temporary output files. Instead, opt for the swift and clean approach using pipes with Popen() and communicate().

Python evolution

Beware that subprocess.run() is a Python 3.5+ luxury. For earlier versions, fall back on the robust but verbose Popen() or the succinct and reliable submariner check_output().