Python range() — range(1, n) Skips Index 0 Silently

# io.thecodeforge — Python tutorial
# Verified on CPython 3.12

import sys
import tracemalloc
import time

# ── Shallow vs true memory comparison ─────────────────────────────────────────
# sys.getsizeof() returns the SHALLOW size — the container and its pointer array.
# It does not include the memory consumed by the integer objects themselves.
# tracemalloc captures the true peak allocation including all object creation.

print("=== Shallow size (sys.getsizeof) ===")
million_range = range(1_000_000)
print(f"range(1_000_000)       : {sys.getsizeof(million_range):>12,} bytes (3 integers — start, stop, step)")

# Measure true allocation of list(range(1_000_000)) using tracemalloc
tracemalloc.start()
million_list = list(range(1_000_000))
_, peak_bytes = tracemalloc.get_traced_memory()
tracemalloc.stop()

shallow_bytes = sys.getsizeof(million_list)
print(f"list shallow size      : {shallow_bytes:>12,} bytes (pointer array only)")
print(f"list true peak alloc   : {peak_bytes:>12,} bytes (includes all integer objects)")
print(f"True memory ratio      : {peak_bytes // sys.getsizeof(million_range):,}x")
# True ratio is roughly 700,000x — far more than the shallow 166,667x suggests
# because integers above 256 are heap-allocated objects, not just pointer slots

# ── range() is a full sequence type ────────────────────────────────────────────
print("\n=== range() sequence capabilities ===")
page_offsets = range(0, 10_000, 250)  # database pagination rule: 40 pages of 250

print(f"First page offset  : {page_offsets[0]}")
print(f"Second page offset : {page_offsets[1]}")
print(f"Last page offset   : {page_offsets[-1]}")
print(f"Total pages        : {len(page_offsets)}")
print(f"Slice [1:4]        : {list(page_offsets[1:4])}")

# ── O(1) membership testing — equal-size comparison ─────────────────────────
# Both collections cover the same 5,000 even numbers.
# The algorithmic difference is structural, not scale-dependent.
print("\n=== Membership testing: range() vs list() — equal size ===")
SIZE = 5_000
big_range = range(0, SIZE * 2, 2)           # even numbers 0 to 9998 — 5,000 elements
big_list  = list(range(0, SIZE * 2, 2))     # same 5,000 even numbers as a list

target_present = SIZE * 2 - 2               # last element — worst case for list scan
target_absent  = SIZE * 2 - 1              # odd number — not in either collection

# range(): O(1) — arithmetic formula regardless of where the target sits
trials = 100_000
start = time.perf_counter_ns()
for _ in range(trials):
    _ = target_present in big_range
range_ns = (time.perf_counter_ns() - start) // trials

# list(): O(n) — scans from index 0, worst case visits all 5,000 elements
start = time.perf_counter_ns()
for _ in range(trials):
    _ = target_present in big_list
list_ns = (time.perf_counter_ns() - start) // trials

print(f"range membership (5K even nums, worst-case target): {range_ns:,} ns per check")
print(f"list membership  (5K even nums, worst-case target): {list_ns:,} ns per check")
print(f"Speed ratio at 5K elements: ~{list_ns // max(range_ns, 1)}x")
print(f"At 50M elements, range stays ~{range_ns:,} ns. List would take ~{range_ns * 10_000:,} ns.")
print(f"range() is O(1) — list() is O(n). The gap widens linearly with collection size.")

# ── Never convert range() unless you need list-specific mutability ────────────
print("\n=== Valid index/membership operations without list conversion ===")
work_range = range(0, 50, 5)   # 0, 5, 10, 15, 20, 25, 30, 35, 40, 45

print(f"Index access   : work_range[3]  = {work_range[3]}")
print(f"Negative index : work_range[-1] = {work_range[-1]}")
print(f"Membership     : 25 in work_range = {25 in work_range}")
print(f"Membership     : 27 in work_range = {27 in work_range}")
print(f"Length         : len(work_range)  = {len(work_range)}")

# io.thecodeforge — Python tutorial
# Verified on CPython 3.12

# ── Scenario: A payment processor retry scheduler ─────────────────────────────
# Retry a failed charge at increasing intervals.
# Retry delays (seconds): 5, 10, 15, 20, 25 (linear backoff, max 5 retries)

MAX_RETRIES = 5
BASE_DELAY_SECONDS = 5

print("=== Linear Backoff Retry Schedule ===")
for attempt_number in range(1, MAX_RETRIES + 1):  # range(1, 6) → 1,2,3,4,5
    # 1-based attempt numbering for human-readable logging
    # stop is MAX_RETRIES + 1 because stop is exclusive — without the +1, attempt 5 is never reached
    delay = attempt_number * BASE_DELAY_SECONDS
    print(f"Attempt {attempt_number}: retry after {delay}s")

# ── Scenario: Counting backwards — leaderboard countdown ─────────────────────
print("\n=== Leaderboard Countdown (10 down to 1) ===")
for rank in range(10, 0, -1):  # start=10, stop=0 (exclusive), step=-1
    # stop=0 ensures rank 1 is included — stop is exclusive in both directions
    # range(10, 1, -1) would miss rank #1 — the same off-by-one in reverse
    print(f"  Rank #{rank}")

# ── Scenario: Reversing a list — when reversed() is cleaner than range ────────
print("\n=== reversed() for list reversal — no index arithmetic needed ===")
leaderboard = ["Alice", "Bob", "Charlie", "Diana", "Eve"]
for player in reversed(leaderboard):  # cleanest when you only need values, not indices
    print(f"  {player}")
# Use range(len(x)-1, -1, -1) only when you need the actual decreasing index value

# ── Scenario: Batch database writes — 100 records per batch ──────────────────
TOTAL_RECORDS = 450
BATCH_SIZE = 100

print("\n=== Batch Write Offsets ===")
for batch_start in range(0, TOTAL_RECORDS, BATCH_SIZE):  # 0, 100, 200, 300, 400
    # min() is critical here — without it, the final batch would request
    # indices 400 through 499, but only 400-449 exist
    batch_end = min(batch_start + BATCH_SIZE, TOTAL_RECORDS)
    record_count = batch_end - batch_start
    print(f"  Writing records [{batch_start}:{batch_end}] — {record_count} records")

# ── Scenario: Even-numbered port scanning for load balancer health checks ─────
PORT_START = 8080
PORT_END   = 8100
PORT_STEP  = 2

print("\n=== Even Port Range ===")
even_ports = list(range(PORT_START, PORT_END, PORT_STEP))  # small range — list is fine here
print(f"Ports to check: {even_ports}")

# ── Stop is always exclusive — demonstrating the rule across all forms ─────────
print("\n=== Stop Is Exclusive — Always ===")
print(f"range(5)         → {list(range(5))}")          # shorthand for range(0, 5, 1)
print(f"range(0, 5)      → {list(range(0, 5))}")       # 5 never appears
print(f"range(1, 6)      → {list(range(1, 6))}")       # when you need 1-5 inclusive
print(f"range(5, 0, -1)  → {list(range(5, 0, -1))}")   # 0 never appears
print(f"range(10, 10)    → {list(range(10, 10))}")     # empty when start == stop
print(f"range(10, 5)     → {list(range(10, 5))}")      # empty when start > stop with positive step

# io.thecodeforge — Python tutorial
# Verified on CPython 3.12

# ── Real scenario: processing invoice line items for billing ──────────────────
invoice_items = [
    {"sku": "WIDGET-A",    "qty": 3, "unit_price": 9.99},
    {"sku": "GADGET-B",    "qty": 1, "unit_price": 49.99},
    {"sku": "DOOHICKEY-C", "qty": 5, "unit_price": 4.50},
]

item_count = len(invoice_items)  # 3

# ── BUG 1: range(1, n) — skips index 0, first item silently missing ───────────
print("=== BUG 1: range(1, item_count) — skips first item ===")
bug1_total = 0.0
for i in range(1, item_count):  # produces 1, 2 — index 0 (WIDGET-A) never visited
    item = invoice_items[i]
    subtotal = item["qty"] * item["unit_price"]
    bug1_total += subtotal
    print(f"  Processed: {item['sku']} — ${subtotal:.2f}")
print(f"  Total billed: ${bug1_total:.2f}  ← WIDGET-A never billed (silent revenue loss)")

# ── BUG 2: range(0, n-1) — skips index n-1, last item silently missing ────────
# Stop is already exclusive. Subtracting 1 makes the loop visit 0 through n-2,
# skipping the final valid index n-1 (DOOHICKEY-C at index 2).
print("\n=== BUG 2: range(0, item_count - 1) — skips last item ===")
bug2_total = 0.0
for i in range(0, item_count - 1):  # produces 0, 1 — index 2 (DOOHICKEY-C) never visited
    item = invoice_items[i]
    subtotal = item["qty"] * item["unit_price"]
    bug2_total += subtotal
    print(f"  Processed: {item['sku']} — ${subtotal:.2f}")
print(f"  Total billed: ${bug2_total:.2f}  ← DOOHICKEY-C never billed (more silent revenue loss)")

# ── CORRECT: range(len(collection)) — covers every valid index ────────────────
print("\n=== CORRECT: range(len(invoice_items)) — all items processed ===")
correct_total = 0.0
for i in range(len(invoice_items)):  # produces 0, 1, 2 — every valid index visited
    item = invoice_items[i]
    subtotal = item["qty"] * item["unit_price"]
    correct_total += subtotal
    print(f"  Processed: {item['sku']} — ${subtotal:.2f}")
print(f"  Total billed: ${correct_total:.2f}  ← Correct")

# ── BETTER: enumerate() when you need index AND value ─────────────────────────
# enumerate() eliminates range() entirely — off-by-one is structurally impossible
# because enumerate() always produces the correct index for each item.
print("\n=== BETTER: enumerate() — index and value together, no range() needed ===")
enum_total = 0.0
for line_number, item in enumerate(invoice_items, start=1):  # 1-based line numbers
    subtotal = item["qty"] * item["unit_price"]
    enum_total += subtotal
    print(f"  Line {line_number}: {item['sku']} — ${subtotal:.2f}")
print(f"  Total billed: ${enum_total:.2f}  ← Correct, and off-by-one structurally impossible")

# ── Post-loop assertion: catch off-by-one before declaring success ─────────────
# This single line catches all three failure modes — range(1,n), range(0,n-1),
# range(0,n+1) — before partial results are written anywhere downstream.
print("\n=== Post-loop count assertion (add this to every batch processor) ===")
expected_count = len(invoice_items)
processed_count = 0
for item in invoice_items:
    processed_count += 1
assert processed_count == expected_count, (
    f"Expected {expected_count} records, processed {processed_count} — "
    f"possible off-by-one in range() call"
)
print(f"  Assertion passed: {processed_count}/{expected_count} records confirmed")

# io.thecodeforge — Python tutorial
# Verified on CPython 3.12

import itertools

order_ids       = ["ORD-001", "ORD-002", "ORD-003", "ORD-004"]
order_statuses  = ["shipped", "pending", "cancelled", "shipped"]
priority_scores = [72, 45, 91, 38]

# ── range(n): pure counted loop — no collection involved ─────────────────────
print("=== range(n): run exactly N times ===")
for reminder_number in range(3):  # 0, 1, 2 — the count is all that matters here
    print(f"  Sending reminder #{reminder_number + 1}")
# Use _ instead of reminder_number when the value is genuinely unused:
# for _ in range(3): send_reminder()

# ── Direct iteration: reading values only — cleanest form ─────────────────────
print("\n=== Direct for-in: cleanest when index is irrelevant ===")
for order_id in order_ids:  # no range(), no index, no collection[i]
    print(f"  Dispatching notification for {order_id}")

# ── enumerate(): need position AND value — building an audit trail ─────────────
print("\n=== enumerate(): index + value together ===")
failed_positions = []
for position, order_id in enumerate(order_ids, start=1):
    # position tells us exactly where in the batch this failed — essential for error logs
    if order_id == "ORD-003":
        failed_positions.append(position)
        print(f"  Position {position}: {order_id} — FAILED")
    else:
        print(f"  Position {position}: {order_id} — OK")
print(f"  Failed at positions: {failed_positions}")

# ── zip(): two sequences in lockstep — and the silent truncation trap ──────────
print("\n=== zip(): walking two lists together ===")
for order_id, status in zip(order_ids, order_statuses):
    print(f"  {order_id} → {status}")

# ── zip() silent truncation — the bug zip() hides when lengths differ ─────────
print("\n=== zip() silent truncation — shorter list silently wins ===")
four_orders   = ["ORD-001", "ORD-002", "ORD-003", "ORD-004"]
three_statuses = ["shipped", "pending", "cancelled"]  # one fewer than orders

print("  With zip() — ORD-004 is silently dropped, no error raised:")
for order_id, status in zip(four_orders, three_statuses):
    print(f"    {order_id} → {status}")

print("  With zip_longest() — all orders processed, missing status filled:")
for order_id, status in itertools.zip_longest(four_orders, three_statuses, fillvalue="UNKNOWN"):
    print(f"    {order_id} → {status}")

# ── range(len(x)): legitimate use — in-place modification by index ─────────────
print("\n=== range(len(x)): in-place update — the one valid use case ===")
print(f"  Before: {priority_scores}")
for i in range(len(priority_scores)):   # need the index to WRITE BACK to the list
    if priority_scores[i] < 50:
        priority_scores[i] = 0          # zero out low-priority scores in place
print(f"  After:  {priority_scores}")
# This is the one case range(len(x)) is genuinely justified — you need the index to mutate

# ── O(1) membership testing — the interview question most candidates miss ──────
print("\n=== O(1) membership testing ===")
batch_offsets = range(0, 10_000_000, 100)   # valid page start positions
print(f"  Is 5000 a valid offset?    {5000 in batch_offsets}")
print(f"  Is 5001 a valid offset?    {5001 in batch_offsets}")
print(f"  Is 9999900 a valid offset? {9999900 in batch_offsets}")
# Each check is O(1) regardless of range size — no iteration, no scanning