subprocess Part 2: Capture Output & Pipe Input

By the end of this lesson you can:

• Capture a command's output with capture_output=True and text=True.
• Read result.stdout and result.stderr as strings.
• Send data to a command's standard input with input=.
• Parse captured output into Python data you can use.

Every command-line program has three text streams:

stdin   (0)  input fed INTO the program
stdout  (1)  the program's normal OUTPUT
stderr  (2)  error/diagnostic messages, kept separate from stdout

Capturing output as text

import subprocess

result = subprocess.run(
    ["git", "rev-parse", "--short", "HEAD"],
    capture_output=True,    # grab stdout and stderr
    text=True,              # decode bytes → str (instead of raw bytes)
)
print("commit:", result.stdout.strip())   # e.g. "abc1234"

• capture_output=True collects stdout and stderr instead of letting them print to your terminal.
• text=True decodes the bytes to a normal string. Without it you get bytes and have to .decode() yourself.
• Output usually ends in a newline — .strip() is your friend.

stdout vs. stderr

result = subprocess.run(
    ["python", "-c", "import sys; print('hi'); print('oops', file=sys.stderr)"],
    capture_output=True, text=True,
)
print(repr(result.stdout))   # 'hi\n'
print(repr(result.stderr))   # 'oops\n'

Keeping them separate is powerful: you can parse the real results from stdout while logging problems from stderr, without them tangling together.

The everyday shorthand

# capture_output=True is just shorthand for these two:
result = subprocess.run(
    ["ls"],
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    text=True,
)

You'll see both forms in the wild; capture_output=True is the modern, concise version.

Feeding input on stdin

result = subprocess.run(
    ["sort"],                 # 'sort' reads lines from stdin
    input="banana\napple\ncherry\n",
    capture_output=True, text=True,
)
print(result.stdout)          # apple / banana / cherry, sorted

input= sends a string straight to the program's stdin — exactly like typing it (or piping a file). Great for tools that read from stdin.

Combine with check=True for safety

try:
    r = subprocess.run(["git", "log", "-1", "--format=%s"],
                       capture_output=True, text=True, check=True)
    print("last commit:", r.stdout.strip())
except subprocess.CalledProcessError as e:
    print("git failed:", e.stderr)      # the error text is right here

When check=True raises, the exception still carries e.stdout and e.stderr — so you can report exactly what went wrong.

Goal: gather a few facts about the current git repo by capturing the output of several git commands, and present them as a tidy summary.

import subprocess

def git(*args: str) -> str:
    """Run a git command and return its trimmed stdout."""
    result = subprocess.run(["git", *args],
                            capture_output=True, text=True, check=True)
    return result.stdout.strip()

def dashboard() -> None:
    branch  = git("rev-parse", "--abbrev-ref", "HEAD")
    commit  = git("rev-parse", "--short", "HEAD")
    author  = git("log", "-1", "--format=%an")
    subject = git("log", "-1", "--format=%s")

    # count files changed but not committed
    status = git("status", "--porcelain")
    dirty  = len(status.splitlines()) if status else 0

    print(f"Branch:        {branch}")
    print(f"Latest commit: {commit} by {author}")
    print(f"Message:       {subject}")
    print(f"Uncommitted:   {dirty} file(s)")

dashboard()

Branch:        develop-python
Latest commit: 277a0e8 by aljay
Message:       updated full level 3 lessons
Uncommitted:   2 file(s)

Read the code

The git() helper captures and trims output once, so each fact is a clean one-liner. We parse git status --porcelain (one line per changed file) just by counting lines — captured text becomes Python data we can measure. This is the whole pattern of Level 7: run a tool, capture its output, turn it into something your program understands. Print these to a file and you have a daily repo report.

Add capture_output=True, text=True to subprocess.run and you get the command's result.stdout and result.stderr as strings — kept separate so results and errors don't tangle. Use input= to feed text to a program's stdin, and chain tools by passing one command's captured stdout as the next command's input (no shell=True needed). Combined with check=True — whose exception still carries stderr — you can run any CLI tool, read its results, and turn them into Python data. That makes the entire ecosystem of command-line programs callable from your scripts.