Hands-on lab — Day 43: Installing Python and Virtual Environments

#!/usr/bin/env bash
# Day 043 lab — completed reference implementation.
# Creates a virtual environment in a temporary directory, proves that
# activation isolates python/pip, writes a requirements.txt, then
# deactivates and cleans everything up. Fully OFFLINE: no network needed.
#
# Run from the lab directory:
#   bash examples/venv_demo.sh
set -euo pipefail

# Work in a throwaway temp directory so nothing is left in your project.
# Resolve symlinks (on macOS /var is a link to /private/var) so later path
# comparisons against sys.prefix line up exactly.
work_dir="$(mktemp -d "${TMPDIR:-/tmp}/venv-demo.XXXXXX")"
work_dir="$(cd "${work_dir}" && pwd -P)"
# Always clean up, even if a command fails partway through.
cleanup() {
  # Leaving an active venv is harmless in a subshell, but deactivate if we can.
  type deactivate >/dev/null 2>&1 && deactivate || true
  rm -rf "${work_dir}"
}
trap cleanup EXIT

echo "=== Virtual Environment Demo ==="
echo "Working directory: ${work_dir}"
cd "${work_dir}"

echo
echo "--- Step 1: the interpreter ---"
python3 --version

echo
echo "--- Step 2: create the virtual environment (offline) ---"
python3 -m venv .venv
echo "Created .venv/ — contents of .venv/bin (or Scripts on Windows):"
ls .venv/bin >/dev/null 2>&1 && ls .venv/bin | sed 's/^/    /' || true

echo
echo "--- Step 3: which python BEFORE activation ---"
before="$(command -v python || echo '(no python on PATH)')"
echo "which python -> ${before}"

echo
echo "--- Step 4: activate and prove isolation ---"
# shellcheck disable=SC1091
source .venv/bin/activate
after="$(command -v python)"
echo "which python -> ${after}"
echo "which pip    -> $(command -v pip)"
prefix="$(python -c 'import sys; print(sys.prefix)')"
echo "sys.prefix   -> ${prefix}"

# Confirm sys.prefix really points inside our .venv folder.
case "${prefix}" in
  "${work_dir}"/.venv*) echo "OK: sys.prefix is inside the .venv — the environment is isolated." ;;
  *) echo "WARNING: sys.prefix is not inside .venv" ; exit 1 ;;
esac

echo
echo "--- Step 5: record dependencies in requirements.txt ---"
# A fresh venv installs no third-party packages; document that we rely on the
# standard library only, and pin the Python version used to build it.
{
  echo "# Built and verified with $(python --version)"
  echo "# This project uses only the Python standard library — no PyPI packages required."
} > requirements.txt
echo "requirements.txt:"
sed 's/^/    /' requirements.txt

echo
echo "--- Step 6: deactivate ---"
deactivate
echo "which python -> $(command -v python || echo '(no python on PATH)')  (back to global)"

echo
echo "=== Demo complete — temp directory will be removed on exit ==="

lesson_id: D043
day: 43
kind: configuration-activity
languages: [bash, python]
setup_commands:
  - cd labs/sections/programming-with-python/day-043-installing-python-and-virtual-environments
run_commands:
  - bash examples/venv_demo.sh
  - bash starter/venv_demo.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - '# nothing to clean: the scripts use a temp directory and remove it themselves'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-12'
executed_on: 'macOS (Apple Silicon), Python 3.14.0, bash tests/run_tests.sh → 11 checks, 0 failure(s).'

# Dependencies — Day 043 lab

**Just Python 3 and a POSIX shell.** There are no PyPI packages to install and
no network access is required at any step — creating a virtual environment uses
only tools that ship with Python.

- `python3` **≥ 3.8** (any modern 3.x is fine; the `venv` module has shipped
  with Python since 3.3). Preinstalled on macOS and most Linux distributions.
- `bash` ≥ 3.2 (preinstalled on macOS and Linux).

## Checking what you have

```bash
python3 --version
```

If that prints `Python 3.x.y`, you are ready.

## If Python 3 is missing

Install it once, using the package-manager skills from Day 13:

- **macOS:** `brew install python` (Homebrew), or download the installer from
  the official python.org downloads page.
- **Debian/Ubuntu Linux:** `sudo apt update && sudo apt install python3 python3-venv`
- **Fedora Linux:** `sudo dnf install python3`
- **Windows:** install from the official python.org downloads page (tick "Add
  Python to PATH"), or use WSL and follow the Linux instructions.

On some minimal Debian/Ubuntu systems the `venv` module is packaged
separately — that is why `python3-venv` is listed above. If
`python3 -m venv .venv` complains that `venv` is unavailable, install that
package.

This lab installs nothing else. Later labs will declare their Python packages
in a `requirements.txt`, which is exactly the reproducibility habit this lesson
introduces.

#!/usr/bin/env bash
# Day 043 lab — YOUR working file.
#
# The scaffolding (temp directory, cleanup, the interpreter check) is done for
# you. Your job is the four numbered exercises below: replace each placeholder
# line with the single command named in its comment. The completed reference is
# examples/venv_demo.sh — try to do it yourself first, then compare.
#
# Everything here is OFFLINE: no network is needed at any step.
#
# Run from the lab directory:
#   bash starter/venv_demo.sh
set -euo pipefail

# --- Scaffolding (already done for you) ---
work_dir="$(mktemp -d "${TMPDIR:-/tmp}/venv-demo.XXXXXX")"
cleanup() {
  type deactivate >/dev/null 2>&1 && deactivate || true
  rm -rf "${work_dir}"
}
trap cleanup EXIT

echo "=== Virtual Environment Demo (starter) ==="
echo "Working directory: ${work_dir}"
cd "${work_dir}"

echo
echo "--- The interpreter (already done) ---"
python3 --version

echo
echo "--- Exercise 1: create a virtual environment named .venv ---"
# Replace the next line with:  python3 -m venv .venv
echo "EXERCISE_1_NOT_DONE: create the .venv here"

echo
echo "--- Exercise 2: activate the environment ---"
# Replace the next line with:  source .venv/bin/activate
echo "EXERCISE_2_NOT_DONE: activate the .venv here"

echo
echo "--- Exercise 3: prove isolation ---"
# After activating, these two commands prove the environment is active.
# Replace the next line with BOTH commands (one per line):
#   command -v python
#   python -c 'import sys; print("sys.prefix:", sys.prefix)'
echo "EXERCISE_3_NOT_DONE: print 'which python' and sys.prefix here"

echo
echo "--- Exercise 4: deactivate the environment ---"
# Replace the next line with:  deactivate
echo "EXERCISE_4_NOT_DONE: deactivate the .venv here"

echo
echo "=== Done — temp directory will be removed on exit ==="
echo "When all four EXERCISE_*_NOT_DONE lines are replaced, run tests/run_tests.sh."

# Virtual environment worksheet — Day 043

Fill this in for **your** machine as you work through the exercises. The goal is
to see, with your own eyes, that activating a virtual environment changes which
Python you are using.

## 1. Your Python

Run `python3 --version` and record the output:

- My Python version: `____________________`

## 2. `which python` before activation

Before activating any environment, run `which python` (or `command -v python`)
and record the full path:

- Before activation, `which python` prints: `____________________`

## 3. Create and activate

Run these from a scratch folder:

```bash
mkdir venv-demo && cd venv-demo
python3 -m venv .venv
source .venv/bin/activate
```

- Did your prompt gain a `(.venv)` marker? (yes / no): `______`

## 4. `which python` after activation

With the environment active, run `which python` again:

- After activation, `which python` prints: `____________________`
- Is this path different from step 2? (yes / no): `______`

## 5. Prove isolation with `sys.prefix`

Run:

```bash
python -c "import sys; print(sys.prefix)"
```

- `sys.prefix` prints: `____________________`
- Does this path end in `.venv`? (yes / no): `______`

## 6. Explain it (4–6 sentences)

In your own words, what did activation change, and why does `sys.prefix`
pointing inside `.venv` prove your project's packages are isolated from the
global Python?

```
____________________________________________________________________

____________________________________________________________________

____________________________________________________________________
```

## 7. Clean up

```bash
deactivate
cd .. && rm -rf venv-demo
```

- After `deactivate`, `which python` prints: `____________________`
  (it should match step 2 again).

#!/usr/bin/env bash
# Tests for the Day 043 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies, entirely OFFLINE, that a virtual environment can be created, that
# activation isolates the interpreter (sys.prefix points inside the venv), and
# that cleanup leaves nothing behind. Also checks that the completed example
# script runs and that the starter still ships its four exercises.
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
}

echo "Testing venv creation and isolation (offline) ..."

# Python 3 must be available.
if command -v python3 >/dev/null 2>&1; then
  check "python3 is available" "yes"
else
  check "python3 is available" "no"
  echo
  echo "${checks} checks, ${failures} failure(s)."
  exit 1
fi

# 1. A venv can be created in a throwaway temp directory.
# Resolve symlinks so the path lines up with what sys.prefix reports.
work_dir="$(mktemp -d "${TMPDIR:-/tmp}/venv-test.XXXXXX")"
work_dir="$(cd "${work_dir}" && pwd -P)"
created="no"
if python3 -m venv "${work_dir}/.venv" >/dev/null 2>&1; then created="yes"; fi
check "python3 -m venv creates an environment" "${created}"

# 2. The environment has an activate script and a python interpreter.
[ -f "${work_dir}/.venv/bin/activate" ] && check "environment has bin/activate" "yes" || check "environment has bin/activate" "no"
[ -x "${work_dir}/.venv/bin/python" ] && check "environment has its own python" "yes" || check "environment has its own python" "no"

# 3. After activation, sys.prefix points INSIDE the venv.
prefix=""
# shellcheck disable=SC1090
if source "${work_dir}/.venv/bin/activate" 2>/dev/null; then
  prefix="$(python -c 'import sys; print(sys.prefix)' 2>/dev/null)"
  which_python="$(command -v python)"
  type deactivate >/dev/null 2>&1 && deactivate || true
fi
case "${prefix}" in
  "${work_dir}"/.venv*) check "sys.prefix points inside the venv" "yes" ;;
  *) check "sys.prefix points inside the venv" "no" ;;
esac
case "${which_python:-}" in
  "${work_dir}"/.venv/bin/python) check "activation redirects 'which python' into the venv" "yes" ;;
  *) check "activation redirects 'which python' into the venv" "no" ;;
esac

# 4. Cleanup leaves nothing behind.
rm -rf "${work_dir}"
[ ! -e "${work_dir}" ] && check "cleanup leaves nothing behind" "yes" || check "cleanup leaves nothing behind" "no"

# 5. The completed example script runs end to end and confirms isolation.
if out="$(bash "${lab_dir}/examples/venv_demo.sh" 2>&1)"; then
  check "examples/venv_demo.sh exits successfully" "yes"
  echo "${out}" | grep -q "the environment is isolated" && check "example confirms isolation" "yes" || check "example confirms isolation" "no"
else
  check "examples/venv_demo.sh exits successfully" "no"
  echo "${out}" | sed 's/^/    /'
fi

# 6. The example leaves no temp directory behind (it cleans up its own).
leftover="$(find "${TMPDIR:-/tmp}" -maxdepth 1 -name 'venv-demo.*' 2>/dev/null | wc -l | tr -d ' ')"
[ "${leftover}" = "0" ] && check "example cleans up its temp directory" "yes" || check "example cleans up its temp directory" "no"

# 7. The starter still ships its four exercises for the learner.
starter="${lab_dir}/starter/venv_demo.sh"
missing=0
for n in 1 2 3 4; do
  grep -q "EXERCISE_${n}_NOT_DONE" "${starter}" || missing=1
done
[ "${missing}" = "0" ] && check "starter ships all four exercises" "yes" || check "starter ships all four exercises" "no"

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