Hands-on lab — Day 44: Variables and Types

#!/usr/bin/env python3
"""Day 044 lab — a working tour of Python's core data model.

Run it with:  python3 examples/types_demo.py

It demonstrates, in order:
  1. A value of each core built-in type, printed with its type().
  2. Dynamic typing: one name re-bound to a different type.
  3. Mutability: a list mutated in place (id unchanged) versus a string
     "modified" (id changes because a new object is made).
  4. Safe type conversion with try/except so bad input is handled, not fatal.

Nothing here needs the network or any third-party package — only the
standard Python 3 interpreter you installed on Day 43.
"""


def show_core_types():
    """Assign one value of each core type and print each with its type()."""
    print("--- Core types ---")
    count = 42          # int   — a whole number
    price = 19.99       # float — a number with a fractional part
    is_open = True      # bool  — a truth value
    label = "widget"    # str   — text
    missing = None      # NoneType — the deliberate "no value" object

    # type(x).__name__ gives the short type name, e.g. 'int' instead of
    # "<class 'int'>", which reads more cleanly in a report.
    for name, value in [
        ("count", count),
        ("price", price),
        ("is_open", is_open),
        ("label", label),
        ("missing", missing),
    ]:
        print(f"{name:<10} = {str(value):<13} type = {type(value).__name__}")


def show_dynamic_typing():
    """Re-bind one name to a value of a different type — legal in Python."""
    print("\n--- Dynamic typing ---")
    thing = 100                       # thing points at an int
    print(f"thing = {thing} ({type(thing).__name__})")
    thing = "hello"                   # now it points at a str
    print(f"thing = {thing} ({type(thing).__name__})   <- same name, different type")


def show_mutability():
    """Show a list mutating in place (same id) vs a string making a new object."""
    print("\n--- Mutability ---")

    numbers = [1, 2, 3]
    id_before = id(numbers)
    numbers.append(4)                 # mutate the SAME list object in place
    print(f"list before: [1, 2, 3]  id unchanged after append: {id(numbers) == id_before}")

    text = "cat"
    id_before = id(text)
    text = text + "s"                 # builds a NEW string; text is re-bound
    print(f"str  before: cat        id changed after '+': {id(text) != id_before}")


def safe_int(raw):
    """Convert a string to an int, returning None instead of crashing on bad input."""
    try:
        return int(raw)
    except ValueError:
        return None


def show_safe_conversion():
    """Demonstrate safe type conversion with try/except ValueError."""
    print("\n--- Safe conversion ---")
    for raw in ["30", "oops"]:
        converted = safe_int(raw)
        if converted is None:
            print(f"{raw!r} -> could not convert (ValueError handled)")
        else:
            print(f"{raw!r}  -> {converted} ({type(converted).__name__})")


def main():
    show_core_types()
    show_dynamic_typing()
    show_mutability()
    show_safe_conversion()


if __name__ == "__main__":
    main()

lesson_id: D044
day: 44
kind: python-program
languages: [python]
setup_commands:
  - cd labs/sections/programming-with-python/day-044-variables-and-types
run_commands:
  - python3 examples/types_demo.py
  - python3 starter/types_demo.py
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/types_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.0, bash tests/run_tests.sh → 12 checks, 0 failure(s).'

# Dependencies — Day 044 lab

**Python 3 only.** This lab has zero third-party dependencies:

- `python3` (version 3.8 or newer; authored and tested on 3.14.0). Installed
  in the Day 43 lesson. Check yours with `python3 --version`.
- `bash` (3.2 or newer — preinstalled on macOS and every mainstream Linux
  distribution) to run the test script.

Everything the programs use — `type()`, `id()`, `int()`, `str()`, `float()`,
`isinstance()`, lists, and try/except — is part of the Python standard
language. There is deliberately no `requirements.txt` or `pip install` step;
the programs must run on a fresh Python installation with nothing added.

On Windows, invoke the interpreter as `python` if `python3` is not found, or
run the lab inside WSL for a Unix-style shell.

#!/usr/bin/env python3
"""Day 044 lab — YOUR working file. Complete the four numbered exercises.

Run it with:  python3 starter/types_demo.py

Each exercise names the exact function to use. Replace every `None` marked
with an "# exercise" comment with real code, then run the file. The finished
reference version is examples/types_demo.py — try to complete this yourself
first, then compare.
"""


def exercise_1_three_types():
    """Exercise 1: create variables of THREE different types and print each
    with its type name, using type(value).__name__.

    Pick three different types (for example an int, a str, and a bool).
    Replace the three `None` values below with values of your choice, then
    the loop will print each with its type.
    """
    print("--- Exercise 1: three types ---")
    value_a = None   # exercise 1a: assign an int, e.g. 7
    value_b = None   # exercise 1b: assign a str, e.g. "hello"
    value_c = None   # exercise 1c: assign a bool, e.g. True

    for name, value in [("value_a", value_a), ("value_b", value_b), ("value_c", value_c)]:
        print(f"{name} = {value!r}  type = {type(value).__name__}")


def exercise_2_safe_conversion():
    """Exercise 2: convert the string "42" to an int SAFELY.

    Use int(...) inside a try/except ValueError. Set `result` to the integer
    on success, or the string "conversion failed" if a ValueError is raised.
    Fill in the two exercise lines.
    """
    print("\n--- Exercise 2: safe conversion ---")
    raw = "42"
    result = None
    try:
        result = None   # exercise 2a: use int(raw) here
    except ValueError:
        result = None   # exercise 2b: set this to "conversion failed"
    print(f"{raw!r} converted to: {result!r}  type = {type(result).__name__}")


def exercise_3_list_is_mutable():
    """Exercise 3: show that a list is MUTABLE.

    Start from [1, 2, 3], record id() before, append the number 4, then print
    whether the id stayed the same (it should — a list mutates in place).
    Fill in the two exercise lines.
    """
    print("\n--- Exercise 3: a list is mutable ---")
    numbers = [1, 2, 3]
    id_before = id(numbers)
    # exercise 3a: append the number 4 to `numbers` using numbers.append(...)
    same_object = None   # exercise 3b: set to (id(numbers) == id_before)
    print(f"numbers is now {numbers}  same object after append: {same_object}")


def exercise_4_none_vs_zero():
    """Exercise 4: distinguish absent (None) from present-but-zero (0).

    Write a check that prints "absent" when value is None and "present"
    otherwise — even when the value is 0. Use `is not None` (NOT a plain
    truthiness test, which would wrongly call 0 absent). Fill in the exercise line.
    """
    print("\n--- Exercise 4: None vs zero ---")
    for value in [0, None, 5]:
        present = None   # exercise 4: set to (value is not None)
        label = "present" if present else "absent"
        print(f"value = {value!r}  -> {label}")


def main():
    exercise_1_three_types()
    exercise_2_safe_conversion()
    exercise_3_list_is_mutable()
    exercise_4_none_vs_zero()


if __name__ == "__main__":
    main()

# Types worksheet — Day 044

Fill this in using the Python REPL (start it with `python3`). Verify every
answer live rather than from memory, and paste the REPL lines that prove each
claim. Keep this worksheet — the next lesson on strings builds on it.

## 1. The type of three values

Choose three values of three *different* types. For each, run `type(value)`
in the REPL and record the result.

| Value you tested | `type(value)` reports | Type name |
| ---------------- | --------------------- | --------- |
| _e.g._ `42`      |                       |           |
|                  |                       |           |
|                  |                       |           |

Paste your REPL lines here:

```text
(paste, e.g.)
>>> type(42)
<class 'int'>
```

## 2. Is a string mutable?

Answer in one sentence: **is a `str` mutable or immutable?**

> Your answer:

Now prove it with `id()`. Record `id(s)` before and after "changing" a
string, and say whether the id stayed the same or changed, and what that
tells you.

```text
(paste your REPL session, e.g.)
>>> s = "cat"
>>> id(s)
...
>>> s = s + "s"
>>> id(s)
...
```

> What the ids show:

## 3. A conversion that fails

Find one type conversion that raises an error. Record exactly what you
converted, the exact error message, and *why* it fails (in terms of this
lesson).

- **What you converted:** _e.g._ `int("3.5")`
- **Exact error:**
- **Why it fails:**

```text
(paste your REPL line and the traceback)
```

## Check

- [ ] Every row of section 1 is filled with a real REPL result.
- [ ] Section 2 states mutable/immutable correctly and cites id() evidence.
- [ ] Section 3 shows a real conversion error with an explanation.

#!/usr/bin/env bash
# Tests for the Day 044 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies that the example program prints the expected type names and the
# correct mutability results, and independently asserts Python's data-model
# behaviour with `python3 -c`. No network access is used.
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
}

# Require a working Python 3 interpreter.
if ! command -v python3 >/dev/null 2>&1; then
  echo "FAIL: python3 not found on PATH — install Python 3 (see Day 43)."
  exit 1
fi

echo "Testing examples/types_demo.py ..."
if ! output="$(python3 "${lab_dir}/examples/types_demo.py" 2>&1)"; then
  check "example program exits successfully" "no"
  echo "${output}" | sed 's/^/    /'
  echo
  echo "${checks} checks, ${failures} failure(s)."
  exit 1
fi
check "example program exits successfully" "yes"

# Each core type name must appear in the output.
for type_name in "type = int" "type = float" "type = bool" "type = str" "type = NoneType"; do
  echo "${output}" | grep -q "${type_name}" \
    && check "prints '${type_name}'" "yes" \
    || check "prints '${type_name}'" "no"
done

# Dynamic typing: the same name shows two different types.
echo "${output}" | grep -q "same name, different type" \
  && check "shows dynamic re-binding" "yes" \
  || check "shows dynamic re-binding" "no"

# Mutability results: list id unchanged after append; str id changed after '+'.
echo "${output}" | grep -q "id unchanged after append: True" \
  && check "list mutates in place (id unchanged)" "yes" \
  || check "list mutates in place (id unchanged)" "no"
echo "${output}" | grep -q "id changed after '+': True" \
  && check "string is immutable (new object on '+')" "yes" \
  || check "string is immutable (new object on '+')" "no"

# Safe conversion: good input converts, bad input is handled, not fatal.
echo "${output}" | grep -q "'30'  -> 30 (int)" \
  && check "safe conversion succeeds on '30'" "yes" \
  || check "safe conversion succeeds on '30'" "no"
echo "${output}" | grep -q "could not convert (ValueError handled)" \
  && check "safe conversion handles bad input" "yes" \
  || check "safe conversion handles bad input" "no"

# Independent assertion of the data model, straight from the interpreter.
echo "Asserting the data model with python3 -c ..."
if python3 -c '
a = [1, 2, 3]
b = a
b.append(4)
assert a == [1, 2, 3, 4], "aliasing: a should see b'"'"'s append"
assert isinstance(True, int), "bool is a subtype of int"
s = "cat"; before = id(s); s = s + "s"
assert id(s) != before, "str must be a new object after +"
n = [1]; before = id(n); n.append(2)
assert id(n) == before, "list must mutate in place"
try:
    int("3.5"); raise SystemExit("int(\"3.5\") should have raised ValueError")
except ValueError:
    pass
assert bool("False") is True, "non-empty string is truthy"
'; then
  check "python3 -c data-model assertions pass" "yes"
else
  check "python3 -c data-model assertions pass" "no"
fi

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