Hands-on lab — Day 46: Numbers, Math, and Precision

#!/usr/bin/env python3
"""Day 046 lab — Precision and Money Math (completed reference).

Runs five short demonstrations of how Python handles numbers and where
floating-point precision bites:

  1. The classic float trap: 0.1 + 0.2 is not exactly 0.3.
  2. Comparing floats safely with math.isclose.
  3. A shopping-cart total in float (wrong) vs Decimal (exact).
  4. Making change with floor division (//) and modulo (%).
  5. A few essentials from the math module (sqrt, floor, ceil).

Everything here uses only the Python standard library — no installs, no
network, no API keys. Run it with:

    python3 examples/precision_demo.py
"""

from decimal import Decimal, ROUND_HALF_UP
import math


def section(title):
    """Print a labelled section header so the output reads clearly."""
    print()
    print("=" * 60)
    print(title)
    print("=" * 60)


def demo_float_trap():
    section("1. The float trap: 0.1 + 0.2 != 0.3")
    total = 0.1 + 0.2
    print(f"0.1 + 0.2        = {total}")
    print(f"Is it exactly 0.3? {total == 0.3}")
    # A float prints its shortest round-tripping form, which hides the error.
    # Decimal(float) shows the exact value actually stored in the 64 bits.
    print(f"0.1 stored as    = {Decimal(0.1)}")
    print(f"0.1 + 0.2 stored = {Decimal(total)}")


def demo_isclose():
    section("2. Comparing floats safely with math.isclose")
    total = 0.1 + 0.2
    print(f"total == 0.3               -> {total == 0.3}")
    print(f"math.isclose(total, 0.3)   -> {math.isclose(total, 0.3)}")
    print(f"round(total, 2) == 0.3     -> {round(total, 2) == 0.3}")


def demo_money():
    section("3. Shopping cart: float (wrong) vs Decimal (exact)")
    prices_float = [19.99, 5.99, 2.50, 0.10, 0.20]
    prices_decimal = [Decimal(str(p)) for p in prices_float]

    float_total = sum(prices_float)
    decimal_total = sum(prices_decimal)

    print(f"Items: {prices_float}")
    print(f"float sum   = {float_total!r}")
    print(f"Decimal sum = {decimal_total}")
    print(f"float == 28.78?   {float_total == 28.78}")
    print(f"Decimal == 28.78? {decimal_total == Decimal('28.78')}")

    # Money is rounded to the nearest cent, half rounding up, the way a till does.
    rounded = decimal_total.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
    print(f"Charge the customer: ${rounded}")


def demo_change():
    section("4. Making change with // and %")
    # Work in whole cents (integers) so there is no float error at all.
    price_cents = 1275   # $12.75
    paid_cents = 2000    # $20.00
    change = paid_cents - price_cents
    print(f"Price ${price_cents / 100:.2f}, paid ${paid_cents / 100:.2f}")
    print(f"Change owed: {change} cents (${change / 100:.2f})")

    coins = [("dollar", 100), ("quarter", 25), ("dime", 10),
             ("nickel", 5), ("penny", 1)]
    remaining = change
    for name, value in coins:
        count = remaining // value   # how many whole coins of this size fit
        remaining = remaining % value  # what is left over after handing them out
        print(f"  {count} x {name} ({value}c)")
    print(f"Remaining after change: {remaining} cents")


def demo_math_module():
    section("5. The math module: sqrt, floor, ceil")
    print(f"math.sqrt(2)   = {math.sqrt(2)}")
    print(f"math.floor(3.7) = {math.floor(3.7)}")
    print(f"math.ceil(3.2)  = {math.ceil(3.2)}")
    print(f"math.pi        = {math.pi}")


def main():
    demo_float_trap()
    demo_isclose()
    demo_money()
    demo_change()
    demo_math_module()
    print()
    print("Done. See numbers-worksheet.md to record what you observed.")


if __name__ == "__main__":
    main()

lesson_id: D046
day: 46
kind: python-program
languages: [python]
setup_commands:
  - cd labs/sections/programming-with-python/day-046-numbers-math-and-precision
run_commands:
  - python3 examples/precision_demo.py
  - python3 starter/precision_demo.py
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/precision_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 → 9 checks, 0 failure(s).'

# Dependencies — Day 046 lab

**Only Python 3 itself.** Everything this lab uses ships in the CPython
standard library — there is nothing to `pip install`:

- `python3` ≥ 3.8 (any modern CPython; the lab was executed on 3.14).
- The `decimal` module (standard library) — exact base-10 arithmetic.
- The `math` module (standard library) — `sqrt`, `floor`, `ceil`, `isclose`.
- `bash` (to run `tests/run_tests.sh`) — preinstalled on macOS and Linux.

Check your Python version:

```bash
python3 --version
```

If that prints `Python 3.x.y`, you are ready. There is deliberately no
`requirements.txt` here: the point of the lab is that precision-correct money
math needs no third-party library at all — the batteries are already
included. Course 3 of the course previews **NumPy**, which you *would*
install for array math, but this lab does not need it.

# Numbers worksheet — Day 046

Fill this in as you complete the exercises in `precision_demo.py`. Everything
you need appears in the program's own output; copy the real values you see.

## 1. The float trap

Run `python3 examples/precision_demo.py` (or your completed starter) and record:

- `0.1 + 0.2` prints as: `________________________________`
- Is it exactly equal to `0.3`? (`True` / `False`): `______`
- The exact value of `0.1` actually stored in the 64 bits (the long
  `Decimal(0.1)` line): `________________________________________________`

One sentence, in your own words, on *why* `0.1` cannot be stored exactly:

```
______________________________________________________________________
```

## 2. Comparing floats safely

- `total == 0.3` gives: `______`
- `math.isclose(total, 0.3)` gives: `______`

Which of these should you use when comparing two computed floats, and why?

```
______________________________________________________________________
```

## 3. The exact Decimal total

For the cart `[19.99, 5.99, 2.50, 0.10, 0.20]`:

- `float` sum prints as: `________________________________`
- `Decimal` sum prints as: `______`
- The amount the customer is charged: `$______`

Why did you build the Decimals from **strings** (`Decimal("19.99")`) rather
than from floats (`Decimal(19.99)`)?

```
______________________________________________________________________
```

## 4. Floor division vs true division

For a change amount of `725` cents:

- `725 / 100` (true division, `/`) gives: `______`
- `725 // 100` (floor division, `//`) gives: `______`
- `725 % 100` (modulo, `%`) gives: `______`

One sentence on when you would reach for `//` and `%` instead of `/`:

```
______________________________________________________________________
```

#!/usr/bin/env python3
"""Day 046 lab starter — Precision and Money Math.

Complete the five numbered exercises below. Each one names the exact tool to
use. Run the file after each change to see your progress:

    python3 starter/precision_demo.py

The finished reference version lives in examples/precision_demo.py — try each
exercise yourself first, then compare. Record your answers in
starter/numbers-worksheet.md.
"""

from decimal import Decimal
import math


def main():
    # ------------------------------------------------------------------
    # Exercise 1: show the float error.
    # Add 0.1 and 0.2 with the + operator, store it in `total`, and print it.
    # Then print whether `total` is exactly equal to 0.3 using ==.
    # Replace the two placeholder lines below.
    total = 0.0  # <-- Exercise 1: change 0.0 to 0.1 + 0.2
    print(f"0.1 + 0.2 = {total}")
    print(f"Equals 0.3 exactly? {total == 0.3}")

    # ------------------------------------------------------------------
    # Exercise 2: compare floats safely.
    # Set `close` to the result of math.isclose(total, 0.3).
    # It should be True even though the == check above is False.
    close = None  # <-- Exercise 2: change None to math.isclose(total, 0.3)
    print(f"math.isclose(total, 0.3) = {close}")

    # ------------------------------------------------------------------
    # Exercise 3: compute an exact total with Decimal.
    # Build Decimals from the STRING form of each price (Decimal("19.99")),
    # never from the float, then sum them. The exact answer is 28.78.
    prices = ["19.99", "5.99", "2.50", "0.10", "0.20"]
    decimal_total = Decimal("0")  # <-- Exercise 3: sum Decimal(p) for p in prices
    print(f"Decimal cart total = {decimal_total}")
    print(f"Exactly 28.78? {decimal_total == Decimal('28.78')}")

    # ------------------------------------------------------------------
    # Exercise 4: use // (floor division).
    # A customer is owed 725 cents in change. How many whole dollars (100c)
    # is that? Use // to get the integer count.
    change_cents = 725
    dollars = 0  # <-- Exercise 4: change 0 to change_cents // 100
    print(f"{dollars} whole dollars in {change_cents} cents")

    # ------------------------------------------------------------------
    # Exercise 5: use % (modulo).
    # After handing out the whole dollars, how many cents are left over?
    # Use % to get the remainder.
    leftover_cents = 0  # <-- Exercise 5: change 0 to change_cents % 100
    print(f"{leftover_cents} cents left over after the dollars")


if __name__ == "__main__":
    main()

#!/usr/bin/env bash
# Tests for the Day 046 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Runs the reference program and confirms the numeric facts it demonstrates:
# the Decimal cart total is exact, math.isclose treats 0.1+0.2 as 0.3, and
# floor division / modulo give the expected whole numbers. No network access.
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
}

# --- 1. The reference program runs cleanly and prints its sections. --------
echo "Running examples/precision_demo.py ..."
if output="$(python3 "${lab_dir}/examples/precision_demo.py" 2>&1)"; then
  check "program exits successfully" "yes"
else
  check "program exits successfully" "no"
  echo "${output}" | sed 's/^/    /'
fi

echo "${output}" | grep -q "0.30000000000000004" \
  && check "shows the exact float result of 0.1 + 0.2" "yes" \
  || check "shows the exact float result of 0.1 + 0.2" "no"

echo "${output}" | grep -q "Charge the customer: \$28.78" \
  && check "charges the exact Decimal total of \$28.78" "yes" \
  || check "charges the exact Decimal total of \$28.78" "no"

echo "${output}" | grep -q "7 x dollar" \
  && check "making change gives 7 whole dollars" "yes" \
  || check "making change gives 7 whole dollars" "no"

# --- 2. Direct numeric assertions with python3 -c. -------------------------
echo "Checking numeric facts directly ..."

python3 -c "assert (0.1 + 0.2) != 0.3, 'expected float error'" \
  && check "0.1 + 0.2 != 0.3 in float (the trap is real)" "yes" \
  || check "0.1 + 0.2 != 0.3 in float (the trap is real)" "no"

python3 -c "import math; assert math.isclose(0.1 + 0.2, 0.3), 'isclose should be True'" \
  && check "math.isclose(0.1 + 0.2, 0.3) is True" "yes" \
  || check "math.isclose(0.1 + 0.2, 0.3) is True" "no"

python3 -c "from decimal import Decimal; prices=['19.99','5.99','2.50','0.10','0.20']; assert sum(Decimal(p) for p in prices) == Decimal('28.78'), 'Decimal total must be exact'" \
  && check "Decimal cart total is exactly 28.78" "yes" \
  || check "Decimal cart total is exactly 28.78" "no"

python3 -c "assert 725 // 100 == 7, 'floor division wrong'; assert 725 % 100 == 25, 'modulo wrong'" \
  && check "725 // 100 == 7 and 725 % 100 == 25" "yes" \
  || check "725 // 100 == 7 and 725 % 100 == 25" "no"

python3 -c "from decimal import Decimal; assert Decimal('0.1') + Decimal('0.2') == Decimal('0.3'), 'Decimal from strings must be exact'" \
  && check "Decimal('0.1') + Decimal('0.2') == Decimal('0.3')" "yes" \
  || check "Decimal('0.1') + Decimal('0.2') == Decimal('0.3')" "no"

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