S005 · Python Variables & Types — Mental Model of Memory

def greet(name: str, times: int = 1) -> str:
    return (f"hello, {name}! " * times).strip()
 
items: list[str] = []
counts: dict[str, int] = {}
maybe_age: int | None = None

"""s005_memory_model.py — the exercises that install the mental model."""
from __future__ import annotations
import copy
 
# =========================
# Part 1 · Names and objects
# =========================
print("--- Part 1 ---")
 
x = [1, 2, 3]
y = x
y.append(4)
print("x:", x)                  # PREDICT: ?
print("y:", y)                  # PREDICT: ?
print("x is y:", x is y)        # PREDICT: ?
print("id(x) == id(y):", id(x) == id(y))
 
# Rebinding vs mutation
a = [1, 2, 3]
b = a
b = b + [4]                     # NEW list — rebind
print("a:", a)                  # PREDICT: ?
print("b:", b)                  # PREDICT: ?
print("a is b:", a is b)        # PREDICT: ?
 
# =========================
# Part 2 · Immutable ‘change’
# =========================
print("\n--- Part 2 ---")
 
s = "hello"
t = s
s = s + " world"                # rebind — strings are immutable
print("s:", s)                  # PREDICT: ?
print("t:", t)                  # PREDICT: ?
 
n = 5
m = n
n += 1                          # rebind — ints are immutable
print("n:", n, "m:", m)         # PREDICT: ?
 
# =========================
# Part 3 · The mutable-default trap
# =========================
print("\n--- Part 3 ---")
 
def bad_append(item, target=[]):
    target.append(item)
    return target
 
print(bad_append("a"))          # PREDICT: ?
print(bad_append("b"))          # PREDICT: ?
print(bad_append("c", []))      # PREDICT: ?
 
def good_append(item, target=None):
    target = [] if target is None else target
    target.append(item)
    return target
 
print(good_append("a"))
print(good_append("b"))
print(good_append("c", []))
 
# =========================
# Part 4 · Copy vs deep copy
# =========================
print("\n--- Part 4 ---")
 
grid = [[0, 0, 0], [0, 0, 0]]
shallow = grid.copy()           # or list(grid)
deep = copy.deepcopy(grid)
grid[0][0] = 99
print("grid:", grid)
print("shallow:", shallow)      # PREDICT: shares inner lists?
print("deep:", deep)            # PREDICT: fully isolated?
 
# =========================
# Part 5 · is vs ==
# =========================
print("\n--- Part 5 ---")
 
small_a = 100
small_b = 100
print("small ints — a is b:", small_a is small_b)  # PREDICT: ?
 
big_a = 100_000
big_b = 100_000
print("big ints — a is b:", big_a is big_b)        # PREDICT: ?
 
# CPython caches small ints in [-5, 256]. Above that, identity is not guaranteed.
# NEVER rely on it — use == for value, is only for singletons (None, True, False).
 
# =========================
# Part 6 · Types you should know
# =========================
print("\n--- Part 6 ---")
 
samples: dict[str, object] = {
    "int": 42,
    "float": 3.14,
    "bool": True,
    "str": "hi",
    "list": [1, 2],
    "tuple": (1, 2),
    "dict": {"a": 1},
    "set": {1, 2, 3},
    "none": None,
    "bytes": b"raw",
}
for name, val in samples.items():
    mutable = val.__class__.__name__ in {"list", "dict", "set", "bytearray"}
    print(f"  {name:<6} type={type(val).__name__:<10} mutable={mutable}")