Hands-on lab — Day 47: Input, Output, and f-strings

#!/usr/bin/env python3
"""Day 047 lab — a friendly CLI greeter/calculator (reference solution).

Reads two numbers EITHER from a command-line argument OR from standard input,
so it is testable non-interactively:

    python3 io_demo.py 5 7
    echo "5 7" | python3 io_demo.py

It converts the input safely (a clear error on bad input), computes a small
stats line, and prints a nicely f-string-formatted, aligned report. On bad
input it writes a message to STANDARD ERROR and exits with a non-zero code, so
the failure is visible to a shell or a calling script.
"""
import sys


def read_raw() -> str:
    """Return the raw input text: the command-line argument if given,
    otherwise everything piped in on standard input."""
    if len(sys.argv) > 1:
        # Join all positional args so both `io_demo.py 5 7` and
        # `io_demo.py "5 7"` work.
        return " ".join(sys.argv[1:])
    return sys.stdin.read()


def parse_pair(raw: str) -> tuple[float, float]:
    """Split the raw text into exactly two numbers, converting safely.

    Raises ValueError with a clear message if there are not exactly two
    whitespace-separated tokens or if either token is not a number.
    """
    parts = raw.split()
    if len(parts) != 2:
        raise ValueError(f"expected two numbers, got {len(parts)}")
    try:
        return float(parts[0]), float(parts[1])
    except ValueError:
        # Re-raise with the original text so the message is actionable.
        raise ValueError(f"both inputs must be numbers (got {raw.strip()!r})")


def format_report(a: float, b: float) -> str:
    """Build the aligned, f-string-formatted report as one string."""
    total = a + b
    product = a * b
    mean = total / 2
    lines = [
        "Input values",
        f"  {'a':<9}{a:>8.2f}",
        f"  {'b':<9}{b:>8.2f}",
        "Results",
        f"  {'sum':<9}{total:>8.2f}",
        f"  {'product':<9}{product:>8.2f}",
        f"  {'mean':<9}{mean:>8.2f}",
    ]
    return "\n".join(lines)


def main() -> int:
    raw = read_raw()
    try:
        a, b = parse_pair(raw)
    except ValueError as err:
        # Diagnostics go to STDERR, never stdout, so a pipeline stays clean.
        print(f"error: {err}", file=sys.stderr)
        return 1
    print(format_report(a, b))
    return 0


if __name__ == "__main__":
    sys.exit(main())

lesson_id: D047
day: 47
kind: python-program
languages: [python]
setup_commands:
  - cd labs/sections/programming-with-python/day-047-input-output-and-f-strings
run_commands:
  - python3 examples/io_demo.py 5 7
  - echo "5 7" | python3 examples/io_demo.py
  - python3 starter/io_demo.py 8 3
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/io_demo.py  # optional: reset your work'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-12'
executed_on: 'macOS (Apple Silicon), Python 3.14, bash tests/run_tests.sh → 19 checks, 0 failures'

# Dependencies — Day 047 lab

**Only Python 3 and a POSIX shell.** This lab has no installable dependencies:

- `python3` (version 3.6 or newer — f-strings and their format specs work on
  every supported Python; the authoring machine used Python 3.14). Check with
  `python3 --version`.
- `bash` (preinstalled on macOS and every mainstream Linux distribution) to run
  the test script.
- Standard shell utilities used by the tests only: `echo`, `printf`, `grep`,
  `mktemp` — all part of the base system.

The program itself imports only `sys` from the Python standard library, so there
is deliberately no `requirements.txt` here. Everything runs offline, needs no
account or API key, and needs no elevated privileges.

## Installing Python (if needed)

- **macOS:** `brew install python` (Homebrew) or download from the official
  python.org installer. macOS may already ship a `python3`.
- **Linux:** `sudo apt install python3` (Debian/Ubuntu) or the equivalent for
  your distribution; most ship Python 3 already.
- **Windows:** install Python from the Microsoft Store or python.org, or use WSL
  and follow the Linux path.

#!/usr/bin/env python3
"""Day 047 lab starter — complete the five numbered exercises below.

Goal: read two numbers (from a command-line argument OR from standard input),
convert them safely, and print an aligned, f-string-formatted report. On bad
input, write an error to STANDARD ERROR and exit with a non-zero code.

See the finished target first:
    python3 examples/io_demo.py 5 7
    echo "5 7" | python3 examples/io_demo.py

Then complete each exercise, replacing every "FILL_ME_IN", and run:
    bash tests/run_tests.sh

The sentinel FILL_ME_IN below is how the test knows the lab is unfinished.
"""
import sys

FILL_ME_IN = "FILL_ME_IN"


def read_raw() -> str:
    """Exercise 1 — read the input from EITHER the command line OR stdin.

    If arguments were given (len(sys.argv) > 1), join sys.argv[1:] with a
    single space and return that string. Otherwise, return sys.stdin.read().
    Reading both ways is what makes the program testable without a keyboard.
    Replace the return below with that logic.
    """
    return FILL_ME_IN


def parse_pair(raw: str) -> tuple[float, float]:
    """Exercises 2 and 4 — turn the raw text into exactly two numbers, safely.

    Exercise 2 (convert): split raw into tokens with raw.split(); if there are
      not exactly two tokens, raise ValueError(f"expected two numbers, got
      {len(parts)}").
    Exercise 4 (handle bad input): convert with float(parts[0]) and
      float(parts[1]) inside a try/except ValueError, and in the except branch
      raise ValueError(f"both inputs must be numbers (got {raw.strip()!r})").
    Remember: input text is a str — float() is what makes it a number.
    """
    parts = raw.split()
    # ... your Exercise 2 length check goes here ...
    # ... your Exercise 4 try/except conversion goes here ...
    return float(parts[0]), float(parts[1])  # replace with the safe version


def format_report(a: float, b: float) -> str:
    """Exercise 3 — format each value right-aligned to width 8, two decimals.

    Each value below currently prints with no formatting. Give every number an
    f-string spec of the form {value:>8.2f} so the two columns line up and show
    exactly two decimal places (compare against examples/io_demo.py).
    """
    total = a + b
    product = a * b
    mean = total / 2
    lines = [
        "Input values",
        f"  {'a':<9}{a}",          # replace {a} with {a:>8.2f}
        f"  {'b':<9}{b}",          # replace {b} with {b:>8.2f}
        "Results",
        f"  {'sum':<9}{total}",    # replace {total} with the aligned spec
        f"  {'product':<9}{product}",
        f"  {'mean':<9}{mean}",
    ]
    return "\n".join(lines)


def main() -> int:
    raw = read_raw()
    try:
        a, b = parse_pair(raw)
    except ValueError as err:
        # Exercise 5 — write the error to STANDARD ERROR (not stdout) so it
        # never pollutes a pipeline, then signal failure with a non-zero code.
        # Add  file=sys.stderr  to the print below.
        print(f"error: {err}")  # <- add file=sys.stderr
        return 1
    print(format_report(a, b))
    return 0


if __name__ == "__main__":
    sys.exit(main())

# Day 047 worksheet — Input, Output, and f-strings

Fill this in from your own runs as you complete `io_demo.py`. Copy real values
straight from your terminal — the point is to *see* the behavior, not guess it.

## 1. Proof that `input()` returns a string

Run this in a Python shell (`python3`), type `5` when prompted, and record what
you see:

```python
x = input("x: ")
type(x)      # what does this report?  __________________
x            # what value is x?         __________________
x + x        # what does this print?    __________________  (why is it not 10?)
```

- `type(input("x: "))` reports: `______________________`
- Typing `5` gives the value: `______________________`
- One sentence, in your own words, on why `input()` returns text and not a number:
  `______________________________________________________________________`

## 2. The format spec you used

Write the exact f-string spec you used to right-align a number to two decimals
in a fixed-width column, and label each part:

- Spec: `f"{value:__________}"`
- The alignment character is `____` and it means `______________________`
- The width is `____` and it means `______________________`
- The `.2f` part means `______________________`

## 3. What your finished program prints

Run your completed program on the input `8 3` **both ways** and paste the output:

```text
$ python3 starter/io_demo.py 8 3
______________________________________________
______________________________________________
______________________________________________
______________________________________________
______________________________________________
______________________________________________

$ echo "8 3" | python3 starter/io_demo.py
(should be identical to the line above)
```

## 4. Why errors go to standard error

In two or three sentences, explain why `io_demo.py` prints its error message to
**standard error** instead of standard output, and what would go wrong in a
pipeline like `python3 io_demo.py | sort` if the error went to standard output
instead:

```
____________________________________________________________________________
____________________________________________________________________________
____________________________________________________________________________
```

#!/usr/bin/env bash
# Tests for the Day 047 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies that io_demo.py reads a pair of numbers from EITHER a command-line
# argument OR standard input, prints an aligned, two-decimal report, and — on
# bad input — writes a message to STDERR and exits non-zero. The reference is
# always held to a strict behavioral standard. The learner's starter is checked
# strictly once every FILL_ME_IN placeholder is gone, and structurally (does it
# still parse, does it still contain the scaffolding) before that.
#
# No network, no interactivity: every input is supplied via arg or pipe.
set -u

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
failures=0
checks=0

check() {
  local label="$1" ok="$2"
  checks=$((checks + 1))
  if [ "${ok}" = "yes" ]; then
    echo "  ok: ${label}"
  else
    echo "  FAIL: ${label}"
    failures=$((failures + 1))
  fi
}

# Full behavioral checks — run against any COMPLETE program.
run_strict_checks() {
  local script="$1" arg_out stdin_out bad_code bad_stderr bad_stdout tmp_err tmp_out

  echo "Testing ${script} (strict behavior) ..."
  tmp_err="$(mktemp)"
  tmp_out="$(mktemp)"

  # 1. Argument mode: `io_demo.py 5 7` exits 0.
  if arg_out="$(python3 "${script}" 5 7 2>/dev/null)"; then
    check "runs with command-line arguments (exit 0)" "yes"
  else
    check "runs with command-line arguments (exit 0)" "no"
  fi

  # 2. Stdin mode: `echo "5 7" | io_demo.py` exits 0.
  if stdin_out="$(echo "5 7" | python3 "${script}" 2>/dev/null)"; then
    check "runs with piped stdin (exit 0)" "yes"
  else
    check "runs with piped stdin (exit 0)" "no"
  fi

  # 3. The two input modes must agree.
  if [ "${arg_out}" = "${stdin_out}" ]; then
    check "argument and stdin modes produce identical output" "yes"
  else
    check "argument and stdin modes produce identical output" "no"
  fi

  # 4. Report structure and aligned, two-decimal values.
  echo "${arg_out}" | grep -q '^Input values$' && check "prints 'Input values' header" "yes" || check "prints 'Input values' header" "no"
  echo "${arg_out}" | grep -q '^Results$' && check "prints 'Results' header" "yes" || check "prints 'Results' header" "no"
  echo "${arg_out}" | grep -qE '(^| )12\.00$' && check "sum of 5 and 7 shown as 12.00 (two decimals)" "yes" || check "sum of 5 and 7 shown as 12.00 (two decimals)" "no"
  echo "${arg_out}" | grep -qE '(^| )35\.00$' && check "product shown as 35.00" "yes" || check "product shown as 35.00" "no"
  echo "${arg_out}" | grep -qE '(^| )6\.00$' && check "mean shown as 6.00" "yes" || check "mean shown as 6.00" "no"

  # 5. Bad input -> non-zero exit, a message on STDERR, and nothing on stdout.
  echo "5 hello" | python3 "${script}" 1>"${tmp_out}" 2>"${tmp_err}"
  bad_code=$?
  bad_stderr="$(cat "${tmp_err}")"
  bad_stdout="$(cat "${tmp_out}")"
  rm -f "${tmp_err}" "${tmp_out}"

  [ "${bad_code}" -ne 0 ] && check "bad input exits non-zero" "yes" || check "bad input exits non-zero" "no"
  [ -n "${bad_stderr}" ] && check "bad input writes a message to stderr" "yes" || check "bad input writes a message to stderr" "no"
  [ -z "${bad_stdout}" ] && check "bad input prints nothing to stdout" "yes" || check "bad input prints nothing to stdout" "no"
}

# Structural checks — run against an UNFINISHED starter.
run_structural_checks() {
  local script="$1"
  echo "Testing ${script} (structure only) ..."
  python3 -c 'import sys; compile(open(sys.argv[1]).read(), sys.argv[1], "exec")' "${script}" 2>/dev/null && check "starter is valid Python (parses)" "yes" || check "starter is valid Python (parses)" "no"
  grep -q 'sys.argv' "${script}" && check "starter references sys.argv (reading an argument)" "yes" || check "starter references sys.argv (reading an argument)" "no"
  grep -q 'sys.stdin' "${script}" && check "starter references sys.stdin (reading a pipe)" "yes" || check "starter references sys.stdin (reading a pipe)" "no"
  grep -q 'sys.stderr' "${script}" && check "starter references sys.stderr (error channel)" "yes" || check "starter references sys.stderr (error channel)" "no"
}

# --- python -c sanity checks (the concepts the lab teaches) ---------------
echo "Concept checks (python3 -c) ..."
printf '5\n' | python3 -c 'import sys; assert type(sys.stdin.readline().rstrip("\n")) is str' && check "a line read from input is a str" "yes" || check "a line read from input is a str" "no"
python3 -c 'assert f"{7.5:>10.2f}" == "      7.50"' && check "f-string {7.5:>10.2f} right-aligns to width 10" "yes" || check "f-string {7.5:>10.2f} right-aligns to width 10" "no"
python3 -c 'assert f"{1234567.891:,.2f}" == "1,234,567.89"' && check "f-string thousands separator works" "yes" || check "f-string thousands separator works" "no"
python3 -c 'assert "5" + "7" == "57" and int("5") + int("7") == 12' && check "converting input turns concatenation into addition" "yes" || check "converting input turns concatenation into addition" "no"
echo

run_strict_checks "${lab_dir}/examples/io_demo.py"
echo

# The starter ships with FILL_ME_IN placeholders. Once the learner has replaced
# every one, hold their script to the same strict standard.
if grep -q 'FILL_ME_IN' "${lab_dir}/starter/io_demo.py"; then
  echo "Note: starter/io_demo.py still has unfinished exercises (FILL_ME_IN)."
  run_structural_checks "${lab_dir}/starter/io_demo.py"
else
  run_strict_checks "${lab_dir}/starter/io_demo.py"
fi

echo
echo "${checks} checks, ${failures} failure(s)."
[ "${failures}" -eq 0 ]