Programming in Python · Chapter 5

Loop Structures: `for` and `while`

Loop Structures & Batch Data Processing

Separate changing data from fixed processing logic:
write the rule for a single step once, and let the computer repeat it automatically.

Chapter Introduction

Two Repetitive Tasks and the Limits of Sequential Code

Two Kinds of Repetitive Tasks

Batch execution across independent items: Sending a sports meet notice to over 20,000 students, repeating the same independent step each time.
Step-by-step accumulation: Computing semester GPA via GPA = Σ(Credits × Grade Points) / Σ(Credits), where each step updates the running total from the step before it.

Two Limits of Sequential Code

Code grows with data size: Notifying 20,000 students requires 20,000 lines; changing the message template means editing every line by hand.
Cannot adapt to variable item counts: Students take 5 or 8 courses in different semesters, so a fixed-length formula cannot fit every transcript.

Two Loop Statements in Python: (1) for loop: steps through a sequence whose range or item count is known in advance (such as rosters or course lists); (2) while loop: repeats as long as a condition holds when the iteration count is unknown beforehand (such as saving monthly until reaching a target).

5.1 Case Description · Task Prompt

Sending Sports Meet Notices to Students 1 to 3

Send an autumn sports meet notice to students 1, 2, and 3 in order, and then print a single completion message: All notices sent.

Analyzing the Task

The message wording is identical on every line; only the student ID (1, 2, 3) changes from one line to the next.
How can we separate the changing ID from the fixed printing action instead of writing three near-identical print() statements?

Expected Output

Sending sports meet notice to student 1
Sending sports meet notice to student 2
Sending sports meet notice to student 3
All notices sent.

Core Goal: Decouple the sequence of student IDs from the action of sending a single notice, and let a loop repeat that action automatically.

5.1 Case Code · Solution

From Repetitive Lines to Repeated Execution with `for`

Sequential Code (Three Repeated Lines)

print("Sending sports meet notice to student 1")
print("Sending sports meet notice to student 2")
print("Sending sports meet notice to student 3")

for Loop Version (Decoupling Data from Action)

for student_id in range(1, 4):
    print(f"Sending sports meet notice to student {student_id}")

print("All notices sent.")

5.1.1 Core Mechanism & Naming Guidance

How `for` Loop Iteration Works and Variable Naming

Fetch the next integer in orderTake the next integer from range(1, 4) and assign it to the loop variable student_id.
Execute the indented block (the loop body)Fetching one item and running the loop body once is called one iteration.
Advance automatically to the next passNo manual increment is needed; Python fetches the next number until the sequence is exhausted.

Key Note (Naming the Loop Variable): student_id is a user-defined variable name, not a built-in keyword. If you rename it in the header, update its references inside the loop body to match. Choose descriptive nouns (such as student_id, month, or price) so the code reads clearly.

5.1.2 Basic Syntax

`for` Loop Syntax Template, Indentation Rules, and Practice

for loop_variable in range(start, stop):
    loop_body_statement_1
    loop_body_statement_2
    ...

statement_executed_after_loop_ends

for and in work as a keyword pair, and the trailing colon : introduces the loop body.
Every statement in the loop body is indented by 4 spaces beneath for.
When a line returns to the same indentation level as for, it sits outside the loop and runs only once after all iterations finish.

5.1 In-Class Check: Replace range(1, 4) with range(1, 5) and then range(7, 10).

(1) range(1, 5) prints IDs 1, 2, 3, 4 plus the final notice (5 lines); (2) range(7, 10) prints IDs 7, 8, 9 plus the final notice (4 lines).

5.2.1 From Start to Stop

The Half-Open Interval Rule of `range()` and Its Two Benefits

Print Integers 1 Through 5 (Set Stop to 6)

for number in range(1, 6):
    print(number)

Two Benefits of Half-Open `[start, stop)`

Item count is simply stop - start: range(1, 6) contains 6 - 1 = 5 integers; 12 months are written as range(1, 13).
Adjacent intervals join without overlap: Splitting into range(1, 5) and range(5, 9) ends the first batch at 4 and starts the second at 5, never duplicating or dropping 5.

Core Rule: When stepping upward by 1, set the stop argument to n + 1 whenever you want the loop to include the integer n.

5.2.1 Guided Practice · Task Prompt

Printing a Right-Angled Triangle of n Rows of Asterisks

Write a function print_triangle(n) that takes a positive integer n and prints a right-angled triangle of n rows of asterisks (*).

Pattern Analysis

Row 1 prints 1 asterisk (*), and Row 2 prints 2 asterisks (**).
In general, Row i prints exactly i asterisks across n total rows.
In Python, multiplying a string by a positive integer i ("*" * i) repeats that character i times.

Expected Output for n = 4

*
**
***
****

Boundary Question: For the row index to step through 1, 2, ..., n, what stop argument should we pass to range()?

5.2.1 Guided Practice · Solution

Implementing the Triangle Function with `range(1, n + 1)`

PYTHON

def print_triangle(n):
    for i in range(1, n + 1):
        print("*" * i)


# Function call: print a 4-row right triangle
print_triangle(4)

Key Takeaway: Writing range(1, n) by mistake produces only 1, 2, 3 when n = 4, omitting the fourth row entirely—a classic off-by-one error.

5.2.2 Start, Stop, and Step

Three Calling Forms of `range()`, Countdowns, and Constraints

Syntax Form	Rule	Example	Generated Sequence
`range(stop)`	Stop only: starts at `0` by default, steps by `+1` (count equals `stop`)	`range(4)`	`0, 1, 2, 3`
`range(start, stop)`	Start and stop: steps by `+1` by default, excludes `stop`	`range(1, 4)`	`1, 2, 3`
`range(start, stop, step)`	Specifies start, stop, and step size, excluding `stop`	`range(1, 7, 2)`	`1, 3, 5`

Countdown with a Negative Step (From 3 Down to Before 0)

for remaining_days in range(3, 0, -1):
    print(f"Days until opening: {remaining_days}")

Output (Yields 3, 2, 1 in Turn)

Days until opening: 3
Days until opening: 2
Days until opening: 1

Key Note (Argument Constraints): All arguments to range() must be integers. Passing a float (such as range(1, 4, 0.5)) raises a TypeError; passing a step size of 0 raises a ValueError because the sequence cannot advance.

5.2.3 Boundaries and Empty Sequences

Matching Step Direction with Stop Bounds and Empty Sequences

Expression	Generated Integers	Iterations	Reason
`range(1, 4)`	`1, 2, 3`	3	`start < stop`; adding 1 moves from 1 toward 4
`range(4)`	`0, 1, 2, 3`	4	Starts at 0 by default and adds 1, producing 4 integers
`range(3, 0, -1)`	`3, 2, 1`	3	`start > stop`; subtracting 1 moves from 3 down toward 0
`range(3, 3)`	(none / empty)	0	`start == stop`; excluding 3 leaves no integers
`range(3, 0)`	(none / empty)	0	Default step is `+1`; stepping up from 3 moves away from 0

Key Note (Empty Sequences): Positive steps require values strictly < stop; negative steps require values strictly > stop. When the start value violates this bound, range() produces an empty sequence—Python skips the loop body without error and continues below. 5.2 Check: Months 1–6 use range(1, 7); even months 2, 4, 6 use range(2, 7, 2).

5.3.1 Case Description · Task Prompt

Summing from 1 to N: The Accumulator

Compute and print the sum of all integers from 1 through a positive integer n (for example, n = 5).

Why Do We Need an Accumulator?

In a for loop, the loop variable is overwritten by the next value on every iteration.
To combine values across iterations, we must define a separate variable before the loop to hold the running subtotal—called an accumulator.

Expected Output for n = 5

Sum of integers from 1 to 5: 15

Accounting Ledger Analogy

Beginning Balance + Current Transaction = Ending Balance

Core Mechanism: The running subtotal computed at the end of each step serves as the starting balance for the next step.

5.3.1 Case Code · Solution

Summing with an Accumulator and Tracing State Updates

PYTHON (Stop Set to n + 1 to Include n)

n = 5
total = 0  # Initialize accumulator to 0

for number in range(1, n + 1):
    total = total + number

print(f"Sum of integers from 1 to {n}: {total}")

Stage	`number`	Before Add	Expression	After Add
Init	—	—	Set initial 0	0
Iter 1	1	0	`0 + 1`	1
Iter 2	2	1	`1 + 2`	3
Iter 3	3	3	`3 + 3`	6
Iter 4	4	6	`6 + 4`	10
Iter 5	5	10	`10 + 5`	15

Key Note (Evaluation Order & Augmented Assignment): total = total + number evaluates the right-hand expression first (adding number to the old value of total) and then stores the result back into total. In Python, this is often written as total += number; incrementing a counter by 1 is written as count += 1.

5.3.2 Key Note: Initialization and Output Placement

Common Pitfalls: Loop Resets and `print()` Placement

Buggy Example: Resetting the Accumulator Inside the Loop Body

n = 5

for number in range(1, n + 1):
    total = 0  # Bug: resets total to 0 on every iteration
    total = total + number

print(f"Incorrect total: {total}")

Incorrect total: 5

5.3.3 Case Description · Task Prompt

Combining Loops and Conditionals: Filtering and Counting

Inspect all integers from 1 through 10, print each integer that is divisible by 3, and count how many such integers exist.

Task Breakdown and the Counter

Step through candidates: Use a for loop to inspect each integer from 1 through 10.
Filter by condition: Check whether the remainder after dividing by 3 is zero (number % 3 == 0).
Count matches: Maintain a counter variable count, adding 1 each time a number passes the test.

Expected Output

3
6
9
Numbers divisible by 3: 3

Combined Pattern: The outer for loop steps through candidate items, while the inner if statement filters which items get processed.

5.3.3 Case Code · Solution

Outer `for` Traversal with Inner `if` Filtering

PYTHON

n = 10
count = 0  # Initialize match counter to 0

for number in range(1, n + 1):
    if number % 3 == 0:
        print(number)
        count = count + 1  # Or count += 1

print(f"Numbers divisible by 3: {count}")

Key Note (Indentation Determines What You Count): Dedenting count += 1 to align with if (4 spaces) increments count on every pass regardless of divisibility—counting all 10 inspected numbers instead of the 3 matching numbers.

5.3.4 Application Case · Task Prompt

Accumulating Monthly Spending Increases Across a Quarter

A department plans a 3-month quarterly budget: Month 1 spending is 1200 yuan, and planned spending rises by 100 yuan each month thereafter (1200, 1300, and 1400 yuan).

Requirements and Formula

Monthly formula: Month Spending = 1200 + (month - 1) × 100.
Print each month's planned spending and accumulate the quarterly total.
When the number of budget months is positive, compute and print the average monthly spending (formatted to 2 decimal places).

Expected Output

Month 1: planned spending 1200 yuan
Month 2: planned spending 1300 yuan
Month 3: planned spending 1400 yuan
Total planned spending: 3900 yuan
Average monthly spending: 1300.00 yuan

Three-Step Workflow: (1) Initialize parameters and accumulator → (2) Compute monthly cost, add to total, and print item → (3) Print total and compute average after exiting.

5.3.4 Application Case · Solution

Accumulating on the Fly and Guarding Division by Zero

PYTHON (Setup → Loop Iteration → Post-Loop Summary)

month_count = 3
total_cost = 0

for month in range(1, month_count + 1):
    monthly_cost = 1200 + (month - 1) * 100
    total_cost = total_cost + monthly_cost
    print(f"Month {month}: planned spending {monthly_cost} yuan")

print(f"Total planned spending: {total_cost} yuan")

if month_count > 0:
    average_cost = total_cost / month_count
    print(f"Average monthly spending: {average_cost:.2f} yuan")
else:
    print("No budget months; cannot calculate average spending")

5.3.4 Extended Implementation

Two-Stage Processing: Store in a List First, Then Traverse to Sum

PYTHON (Decoupling Data Generation from Aggregation)

month_count = 3
monthly_costs = []  # Empty list to store monthly figures

# Stage 1: Compute monthly budget and append to list
for month in range(1, month_count + 1):
    cost = 1200 + (month - 1) * 100
    monthly_costs.append(cost)
    print(f"Month {month}: planned spending {cost} yuan")

# Stage 2: Traverse list elements directly to sum
total_cost = 0
for cost in monthly_costs:
    total_cost += cost

print(f"Total planned spending: {total_cost} yuan")

5.4.1 Case Description · Task Prompt

Unknown Iteration Counts: Saving Toward a Target Reserve

A startup begins with 1000 yuan in seed capital and adds 600 yuan at the end of each month. How many full months will it take for the reserve to reach or exceed 2500 yuan?

Why Is `range()` Unsuitable Here?

Before running the calculation, we do not know how many months will be needed.
When to stop depends on the running balance as it changes during execution.
Whenever the iteration count is unknown beforehand and depends on runtime state, use a while loop.

Expected Output

End of month 1: balance 1600.00 yuan
End of month 2: balance 2200.00 yuan
End of month 3: balance 2800.00 yuan
Target reached in 3 months

Continuation vs. Stopping Condition: We stop once the reserve reaches 2500 yuan (>= 2500), so we continue while the reserve is still below 2500 yuan (reserve < target).

5.4.1 Case Code · Solution

Keep Adding Monthly Funds While the Reserve Is Below Target

PYTHON

reserve = 1000
target = 2500
monthly_addition = 600
months = 0  # Initialize counter: 0 months elapsed at start

while reserve < target:
    reserve += monthly_addition
    months = months + 1
    print(f"End of month {months}: balance {reserve:.2f} yuan")

print(f"Target reached in {months} months")

Re-evaluating After Each Pass: After each pass through the loop body, execution returns to the while header and re-tests reserve < target using the updated balance, exiting as soon as the condition becomes False.

5.4.2 Test Before Executing

`while` Loop Syntax and Two Key Runtime Behaviors

initialize_state_variables

while condition_expression:
    statements_to_repeat_while_true
    update_state_toward_termination

statements_executed_after_loop_ends

Check	Before Check	`< 2500`	Action and Result
Check 1	1000	True	Add to 1600, `months = 1`
Check 2	1600	True	Add to 2200, `months = 2`
Check 3	2200	True	Add to 2800, `months = 3`
Check 4	2800	False	Stop and exit loop

Two Core Runtime Behaviors: (1) Test before running: If the starting state already meets the target (e.g., reserve = 3000), Check 1 is immediately False, so the loop body runs 0 times and reports 0 months; (2) The condition is re-tested at the top of each pass, not mid-body.

5.4.3 Key Note: Updating State Variables

Three Essential Links and Four Common Infinite Loop Traps

All Three Links Are Essential: (1) Initialize state before the loop → (2) Test the continuation condition in the header → (3) Update state inside the body toward termination.

Common Bug	Code Symptom	Why It Loops Forever	Fix
1. Missing state update	Prints inside body without `reserve += ...`	`reserve` stays at 1000; condition stays `True`	Update the state variable inside the loop body
2. Misindented update	Aligns `reserve += ...` with `while`	Update sits outside the loop; state never advances	Indent the update by 4 spaces inside the loop body
3. Wrong step direction	Writes `reserve -= ...` when target is 2500	Balance shrinks further below 2500 on every pass	Ensure each update moves closer to the stopping bound
4. Updating wrong variable	Tests `reserve < target`, updates only `months`	The tested variable `reserve` never changes	Update the variable tested by the `while` condition

Stopping an Infinite Loop: If your terminal prints endlessly or hangs, press Ctrl + C in the terminal (raising KeyboardInterrupt) or click the Stop button in your IDE to terminate the process.

5.4.4 Choosing Between for and while

Selection Criteria and Comparing the Three Control Links

Loop Type	When to Use	Typical Business Scenarios
`for` loop	Iteration count is known in advance, or traversing a known collection	Stepping through Months 1–12, student rosters, or fixed lists of orders
`while` loop	Iteration count is unknown beforehand and depends on changing runtime state	Saving funds until hitting a target; reading user input until a stop signal

Fixed-Count Comparison: Printing 1 Through 3

# Option 1: for loop (handles init, check, and step)
for number in range(1, 4):
    print(number)

# Option 2: while loop (requires 3 manual lines)
number = 1              # 1. Initialize
while number <= 3:      # 2. Test bound
    print(number)
    number += 1         # 3. Manual step

Selection Rule of Thumb

Whenever the range or iteration count is known in advance, prefer a for loop: it keeps all range bookkeeping in the header and cannot forget to advance the loop variable.

5.4 Practice: Test target = 2200 (exact hit → 2 months), 2500 (passes target → 3 months), and 1000 (already met → 0 months).

5.5.1 Case Description · Task Prompt

Exiting Early After Finding a Match: Target Profit Planning

A product sells for 50 yuan per unit, has a unit variable cost of 30 yuan, and carries 1000 yuan in fixed costs. Among integer sales volumes from 1 to 200 units, find the smallest volume that earns a profit of at least 1000 yuan.

CVP Formula and Early Exit

Profit formula: Profit = (Unit Price - Unit Cost) × Quantity - Fixed Cost.
Testing quantities in ascending order, the first volume that reaches 1000 yuan is the minimum qualifying volume; larger volumes need not be checked.
If no volume qualifies, print a not-found notice; finally print Search finished.

Expected Output

First qualifying sales volume: 100 units
Corresponding profit: 1000 yuan
Search finished

The break Statement: Immediately terminates the innermost enclosing loop and jumps to the first statement below that loop.

5.5.1 Case Code · Solution

Exiting Early with `break` and Tracking Matches with `found`

PYTHON

unit_price = 50
unit_cost = 30
fixed_cost = 1000
target_profit = 1000
found = False  # Initialize flag variable: False before search starts

for quantity in range(1, 201):
    profit = (unit_price - unit_cost) * quantity - fixed_cost
    if profit >= target_profit:
        found = True
        print(f"First qualifying sales volume: {quantity} units")
        print(f"Corresponding profit: {profit} yuan")
        break

if not found:
    print("No qualifying sales volume found between 1 and 200 units")
print("Search finished")

5.5.2 Case Description · Task Prompt

Skipping the Current Iteration: Trade Fair Maintenance Fees

A trade fair runs for 7 days (Days 1 through 7), but the venue closes on Day 3 for maintenance. Each open day costs 80 yuan in maintenance fees, whereas closed days cost nothing.

Requirements and Skipping Logic

Step through Days 1 to 7; when reaching closed Day 3, skip billing and printing for that day and move directly to Day 4.
Print each open day, and report the total open days and total maintenance fee at the end.

Expected Output

Day 1: venue open
Day 2: venue open
Day 4: venue open
Day 5: venue open
Day 6: venue open
Day 7: venue open
Open days: 6
Total maintenance fee: 480 yuan

The continue Statement: Ends the current iteration immediately, skipping the remaining lines in the loop body and starting the next iteration.

5.5.2 Case Code · Solution

Skipping Closed Days with `continue` as a Guard Clause

PYTHON

closed_day = 3
daily_cost = 80
open_days = 0
total_cost = 0

for day in range(1, 8):
    if day == closed_day:
        continue

    open_days += 1
    total_cost += daily_cost
    print(f"Day {day}: venue open")

print(f"Open days: {open_days}")
print(f"Total maintenance fee: {total_cost} yuan")

5.5.3 & 5.5.4 Key Notes & Comparison

The `continue` Trap in `while` Loops and Control Statements

5.5.3 Safe Placement of continue Inside a while Loop

record_no = 0
while record_no < 4:
    record_no += 1  # Increment BEFORE continue!
    if record_no == 2:
        continue
    print(f"Checking record {record_no}")

How `continue` Differs in `for` vs. `while`

In a for loop, continue automatically fetches the next item; in a while loop, it jumps back to re-test the header condition—if record_no += 1 sits below continue, the increment is skipped and the loop hangs forever!

Statement	Allowed Scope	What It Stops	Where Execution Goes Next	Typical Business Scenario
`continue`	Inside loop only	Current iteration only	Jumps to current loop header for next pass	Skip closed days, missing markers, or invalid inputs
`break`	Inside loop only	Innermost enclosing loop	Jumps to first statement below that loop	Stop searching once the first qualifying item is found
`return`	Inside `def` only	Entire enclosing function	Exits function and returns value to caller	Hand back the final result immediately from any loop depth

5.6.1 & 5.6.2 Organizing Loops in Functions

Parameterizing Loop Bounds and Placing `return` Properly

Correct: Return After the Loop Completes

def sum_integers(n: int) -> int:
    """Return the sum of integers from 1 to n."""
    total = 0
    for number in range(1, n + 1):
        total += number
    return total  # Aligned with for

print(sum_integers(5))   # 15
print(sum_integers(0))   # 0

Buggy: Indenting return Inside the Loop Body

def incorrect_sum(n: int) -> int:
    total = 0
    for number in range(1, n + 1):
        total += number
        return total  # Bug: exits on Iteration 1

print(incorrect_sum(5))  # 1
print(incorrect_sum(0))  # None

Two Rules for Placing return in Loop Functions: (1) Aggregation tasks (sums, averages, counts): Wait until all iterations finish by placing return outside the loop body; (2) First-match search tasks (minimum qualifying volume, first over-threshold order): Place return inside the if branch in the loop to exit as soon as a match is found.

5.6.3 Case Description · Task Prompt

Updating Two State Variables: The Fibonacci Sequence

In the Fibonacci sequence, Term 0 is 0, Term 1 is 1, and every term from Term 2 onward equals the sum of the two preceding terms. Write a function fibonacci(n: int) -> int that returns Term n.

Term Index n	0	1	2	3	4	5	6	7
Fibonacci Value	0	1	1	2	3	5	8	13

Recurrence and the Sliding Window: Term 2 is 1 = 0 + 1, Term 3 is 2 = 1 + 1, Term 4 is 3 = 1 + 2, and so on. Computing the next term does not require storing the entire history—only the two immediately preceding terms, like a two-slot sliding window shifting one step right on each pass.

Design Question: How should we maintain two state variables for the current window and shift them one step right on each iteration without losing data?

5.6.3 Case Code · Solution

Shifting a Two-Variable Window with a Temporary Variable

PYTHON (Output: 0 1 1 13)

def fibonacci(n: int) -> int:
    """Return Term n of the Fibonacci sequence (Term 0 is 0)."""
    previous = 0
    current = 1
    for step in range(n):
        next_value = previous + current
        previous = current
        current = next_value
    return previous

print(fibonacci(0), fibonacci(1), fibonacci(2), fibonacci(7))

Completed Shifts	`previous`	`current`	Sequence Terms Held
0 (start)	0	1	Term 0, Term 1
1	1	1	Term 1, Term 2
2	1	2	Term 2, Term 3
3	2	3	Term 3, Term 4
4	3	5	Term 4, Term 5
5	5	8	Term 5, Term 6

Key Notes: (1) After n shifts, previous holds Term n (returning the initial 0 when n = 0); (2) Save the sum in a temporary variable next_value first before updating previous and current so the old value of previous is not overwritten prematurely.

Core Concepts Part I · Exercise 1 Prompt

Sum of Odd Integers from 1 to N

Write a function that takes a non-negative integer n and returns the sum of all odd integers from 1 through n (including n when n is odd; returning 0 when n = 0).

Test Input `n`	Expected Return	Calculation Detail
`0`	`0`	No odd integers in range; returns initial sum 0
`1`	`1`	Single odd integer: 1
`6`	`9`	Sums odd integers: `1 + 3 + 5 = 9`
`7`	`16`	Includes odd upper bound: `1 + 3 + 5 + 7 = 16`

Three Loop Design Questions: (1) What accumulator variable holds the sum? (2) How does each pass update it? (3) What stop bound and step size should range() use?

Core Concepts Part I · Exercise 1 Solution

Summing Odd Integers with a Step Size of 2

PYTHON

def sum_odd_numbers(n: int) -> int:
    """Return the sum of odd integers from 1 to n (n >= 0)."""
    total = 0
    for number in range(1, n + 1, 2):
        total += number
    return total

print(sum_odd_numbers(0))
print(sum_odd_numbers(1))
print(sum_odd_numbers(6))
print(sum_odd_numbers(7))

Two Equivalent Approaches: Instead of stepping by 2 with range(1, n + 1, 2), you can also loop over range(1, n + 1) and filter with if number % 2 != 0: inside the body; setting the stop bound to n + 1 ensures an odd n is included.

Core Concepts Part I · Exercise 2 Prompt

Minimum Months to Reach a Reserve Target

Write a function that takes an initial balance, a month-end contribution, and a target balance, and uses a while loop to return the minimum number of full months needed to reach or exceed the target.

Initial (yuan)	Monthly (yuan)	Target (yuan)	Expected Months	Business Scenario
1000	600	2200	2	Reaches 2200 yuan exactly at the end of Month 2
1000	600	2500	3	Reaches 2800 yuan at the end of Month 3 (passes target)
2500	600	2500	0	Initial balance already meets target; 0 months needed
3000	600	2500	0	Initial balance already exceeds target; returns 0

Boundary Requirement: When the initial balance already meets or exceeds the target, the loop body must not run and the function must return 0.

Core Concepts Part I · Exercise 2 Solution

Packaging a `while` Loop Inside a Function to Count Months

PYTHON

def months_to_target(initial: int, monthly: int, target: int) -> int:
    """Count full months needed to reach target (in integer yuan)."""
    reserve = initial
    months = 0

    while reserve < target:
        reserve += monthly
        months += 1

    return months


print(months_to_target(1000, 600, 2200))
print(months_to_target(1000, 600, 2500))
print(months_to_target(2500, 600, 2500))
print(months_to_target(3000, 600, 2500))

Core Concepts Part I · Exercise 3 Prompt

Purchasing Within Budget and Inventory Limits

A department buys identical office supplies one unit at a time, deducting the unit price from the remaining budget. Purchasing stops when the remaining budget cannot cover another unit or supplier inventory runs out.

Stock (units)	Unit Price (yuan)	Budget (yuan)	Expected Count	Boundary Check Focus
10	80	250	3	Buying 3 leaves 10 yuan, which cannot pay for a 4th unit
10	80	240	3	Buying 3 spends the entire budget (0 yuan remaining)
2	80	250	2	Budget has money left, but supplier stock is only 2 units
10	80	0	0	Zero budget cannot buy a single unit
0	80	250	0	Zero stock cannot supply any units

Required Structure: Combine a for loop over range(), a break statement, and a counter variable to return the maximum units purchased.

Core Concepts Part I · Exercise 3 Solution

Capping Stock in the Outer Loop and Checking Budget Inside

PYTHON

def count_affordable_items(stock: int, unit_price: int, budget: int) -> int:
    """Return purchased item count; stock, budget >= 0, unit_price > 0."""
    remaining = budget
    item_count = 0

    for attempt in range(stock):
        if remaining < unit_price:
            break
        remaining -= unit_price
        item_count += 1

    return item_count

print(count_affordable_items(10, 80, 250))
print(count_affordable_items(10, 80, 240))
print(count_affordable_items(2, 80, 250))
print(count_affordable_items(10, 80, 0))
print(count_affordable_items(0, 80, 250))

Core Concepts Part I · Exercise 4 Prompt

Debugging State Updates in the Fibonacci Recurrence

Buggy Code (Omits Temporary Variable; Prints 4 Instead of 2)

def incorrect_fibonacci(n: int) -> int:
    previous = 0
    current = 1

    for step in range(n):
        previous = current
        current = previous + current

    return previous

print(incorrect_fibonacci(3))  # Prints 4

Completed Iteration	`previous` Value	`current` Value
0 (start)	0	1
1	To fill	To fill
2	To fill	To fill
3	To fill	To fill

Debugging Task: Fill in the trace table in assignment order to see where the values diverge, fix the code, and explain why testing only n = 1 misses this bug.

Core Concepts Part I · Exercise 4 Solution

Tracing the Overwrite Bug and Fixing It with a Temp Variable

Iteration	`previous`	`current`	How the Overwrite Bug Happens
0 (start)	0	1	Initial state is correct
1	1	2	`previous = current` sets 1; then `current = 1 + 1` sets 2 (old 0 was lost)
2	2	4	`previous = current` sets 2; then `current = 2 + 2` sets 4
3	4	8	`previous = current` sets 4; then `current = 4 + 4` sets 8 (doubles each pass)

Fixed Code (Tests 0, 1, 2, 3, 6 → Outputs 0, 1, 1, 2, 8)

def fibonacci(n: int) -> int:
    previous = 0
    current = 1
    for step in range(n):
        next_value = previous + current
        previous = current
        current = next_value
    return previous

Why does n = 1 miss the bug?

After Iteration 1, previous is set to 1, which happens to match Term 1 (1) by coincidence while current already holds the corrupted 2!

Always test loop functions across three cases: 0 iterations, 1 iteration, and multiple iterations.

Core Concepts Part II · 5.7 Basic List Operations

Part II Roadmap, Defining Lists, and Appending with `.append()`

Part II Tier	Sections	Core Focus and Business Applications
1. List basics & traversal	5.7, 5.8	Store discrete orders or records in lists; use `for` loops to sum, filter, and bill
2. Grid evaluation	5.9	Use two-level nested loops to evaluate price × quantity grids and project profits
3. Traversal helpers	5.10, 5.11	Pair sequence numbers with items via `enumerate()`; use the loop `else` clause
4. Continuous input	5.12	Combine `while True` and a sentinel value for interactive data entry and summary

5.7.1 Defining Lists [] with len() & 5.7.2 Appending via .append()

order_amounts = [85.0, 99.0, 120.0]
print(order_amounts, len(order_amounts))  # [85.0, 99.0, 120.0] 3

expenses = []
expenses.append(25.0)
expenses.append(68.5)
print(expenses, len(expenses))            # [25.0, 68.5] 2

Key Note: In-Place Mutation

.append() modifies the existing list in place and returns None.

Never write expenses = expenses.append(25.0)—doing so overwrites your list variable with None!

5.7.3 Accessing Elements by Position

Zero-Based Indexing: Offsets and Out-of-Range Guards

Everyday Term	Python Index	Access Expression	Retrieved Amount
1st order	`0`	`order_amounts[0]`	85.0 yuan
2nd order	`1`	`order_amounts[1]`	99.0 yuan
3rd order	`2`	`order_amounts[2]`	120.0 yuan

Reading Elements by Index

order_amounts = [85.0, 99.0, 120.0]

print(f"First order amount: {order_amounts[0]:.2f} yuan")
print(f"Third order amount: {order_amounts[2]:.2f} yuan")

First order amount: 85.00 yuan
Third order amount: 120.00 yuan

Key Note (Offsets and IndexError): An index measures the offset (number of steps forward) from the first element, so numbering starts at 0. A 3-element list has valid indices 0, 1, 2 (up to len - 1); accessing order_amounts[3] or empty_list[0] raises an IndexError: list index out of range.

5.8.1 Accessing Elements Directly

List Traversal and Iterables

Traversing List Elements Directly

expenses = [25.0, 68.5, 16.5]

for expense in expenses:
    print(f"Expense: {expense:.2f} yuan")

print("All expenses displayed.")

Expense: 25.00 yuan
Expense: 68.50 yuan
Expense: 16.50 yuan
All expenses displayed.

for loop_variable in iterable:
    process_current_element

The loop variable expense receives each element's value directly, rather than its index position.

Traversal: Stepping through every element of a container in order.

Iterable: Any object that yields its elements one by one in a for ... in loop (such as range, lists, strings, or dicts).

5.8.2 Case Description · Task Prompt

Sales Summary: Accumulation, Filtering, and Valid Counts

A store logs 4 consecutive days of revenue in sales_records = [1200.0, -1.0, 0.0, 1500.0]. Skip missing reports, and compute the reported days, total reported sales, and average daily sales.

Data Conventions

Valid reported sales are non-negative (>= 0.0), where 0.0 means the store was open and earned zero revenue.
Days with missing reports due to system outages are marked with the special value -1.0.

Expected Output

Reported days: 3
Total reported sales: 2700.00 yuan
Average reported daily sales: 900.00 yuan

Key Accounting Question: When computing average daily sales, should we divide by the valid reported days (3) or by the total list length (4)?

5.8.2 Case Code · Solution

Filtering Missing Markers and Two Key Accounting Rules

PYTHON

sales_records = [1200.0, -1.0, 0.0, 1500.0]
total_sales = 0.0
valid_count = 0  # Count only valid reported days

for sales in sales_records:
    if sales == -1.0:
        continue
    total_sales += sales
    valid_count += 1

print(f"Reported days: {valid_count}")
print(f"Total reported sales: {total_sales:.2f} yuan")

if valid_count > 0:
    average_sales = total_sales / valid_count
    print(f"Average reported daily sales: {average_sales:.2f} yuan")
else:
    print("No valid records; cannot calculate average")

5.8.3 Case Description · Task Prompt

Order Billing: Calling a Single-Order Function Inside a Loop

An e-commerce platform offers free shipping on orders of 99 yuan or more and charges 6 yuan shipping below 99 yuan. Given the order list [85.0, 99.0, 120.0], compute each order's payable amount and sum the batch total.

Modular Function Design

Write a single-order function calculate_payment(order_amount) that applies the shipping rule to one order.
Write a batch function calculate_batch_payment(order_amounts) that calls the single-order function inside a loop to sum the batch total.

Expected Output

Batch total payment: 310.00 yuan
Empty batch total payment: 0.00 yuan

The three orders bill at 91.0, 99.0, and 120.0 yuan, totaling 310.00 yuan.

Design Question: What maintenance advantage do we gain by splitting single-order billing and batch summation into two separate functions?

5.8.3 Case Code · Solution

Separation of Concerns: Single-Order vs. Batch Billing

PYTHON

def calculate_payment(order_amount: float) -> float:
    """Calculate payable amount including shipping for one order."""
    if order_amount >= 99.0:
        shipping_fee = 0.0
    else:
        shipping_fee = 6.0
    return order_amount + shipping_fee

def calculate_batch_payment(order_amounts: list) -> float:
    """Sum payable amounts across a batch; return 0.0 for empty list."""
    total_payment = 0.0
    for amount in order_amounts:
        payment = calculate_payment(amount)
        total_payment += payment
    return total_payment

orders = [85.0, 99.0, 120.0]
print(f"Batch total payment: {calculate_batch_payment(orders):.2f} yuan")
print(f"Empty batch total payment: {calculate_batch_payment([]):.2f} yuan")

5.9.1 Case Description · Task Prompt

Repeating for Each Item: Price × Quantity Profit Grids

Given a unit variable cost of 30.0 yuan and fixed costs of 1000.0 yuan, evaluate profit across all combinations of candidate prices prices = [50.0, 60.0] and candidate quantities quantities = [100, 200].

Two-Dimensional Grid Evaluation

CVP formula: Profit = (Price - Unit Cost) × Quantity - Fixed Cost.
For each candidate price, test every candidate quantity in turn (2 × 2 = 4 combinations in total).

Expected Output

Price: 50.00 yuan, Quantity: 100 units, Profit: 1000.00 yuan
Price: 50.00 yuan, Quantity: 200 units, Profit: 3000.00 yuan
Price: 60.00 yuan, Quantity: 100 units, Profit: 2000.00 yuan
Price: 60.00 yuan, Quantity: 200 units, Profit: 5000.00 yuan

Nested Loop: Placing one loop inside the body of another loop to step through two-dimensional combinations.

5.9.1 Case Code · Solution

Two-Level Nested Loops and the Clock-Hand Rhythm

PYTHON

prices = [50.0, 60.0]
quantities = [100, 200]
unit_cost = 30.0
fixed_cost = 1000.0

for price in prices:
    for quantity in quantities:
        profit = (price - unit_cost) * quantity - fixed_cost
        print(
            f"Price: {price:.2f} yuan, Quantity: {quantity} units, "
            f"Profit: {profit:.2f} yuan"
        )

Step	Outer `price`	Inner `quantity`	Resulting `profit`
1	50.0 yuan	100 units	1000.00 yuan
2	50.0 yuan	200 units	3000.00 yuan
3	60.0 yuan	100 units	2000.00 yuan
4	60.0 yuan	200 units	5000.00 yuan

Key Note (Hour and Minute Hands): Each time the outer loop advances by one step, the inner loop completes a full cycle from start to finish. A two-level nested loop evaluates the Cartesian product of both lists, running the inner body len(outer) × len(inner) times (2 × 2 = 4 times).

5.9.2 Case Description · Task Prompt

Finding the First Qualifying Volume for Each Candidate Price

Given candidate prices prices = [50.0, 60.0], ascending quantities quantities = [100, 200, 300], unit cost 30.0 yuan, and fixed cost 1000.0 yuan:

Requirements and Inner Early Exit

For each candidate price, find only the first quantity in ascending order that earns a profit of at least 2500.0 yuan.
Once a qualifying quantity is found for the current price, skip larger quantities (such as 300 units) and move on to the next candidate price.

Expected Output

Price 50.00 yuan: first qualifying volume is 200 units
Price 60.00 yuan: first qualifying volume is 200 units

Core Question: When break executes inside the inner loop, does it exit both loops or only the inner loop?

5.9.2 Case Code · Solution

`break` Exits Only the Innermost Loop

PYTHON

prices = [50.0, 60.0]
quantities = [100, 200, 300]
unit_cost = 30.0
fixed_cost = 1000.0
target_profit = 2500.0

for price in prices:
    for quantity in quantities:
        profit = (price - unit_cost) * quantity - fixed_cost
        if profit >= target_profit:
            print(
                f"Price {price:.2f} yuan: "
                f"first qualifying volume is {quantity} units"
            )
            break

Key Note (Scope of break in Nested Loops): In nested loops, break exits only the innermost loop that directly contains it; the outer loop continues to its next iteration normally. Likewise, continue skips only the current iteration of the innermost loop.

5.10 Retrieving Both Index and Value

Built-in Function `enumerate()` and Unpacking

Numbered Output with enumerate(expenses, start=1)

expenses = [25.0, 68.5, 16.5]

for item_no, expense in enumerate(expenses, start=1):
    print(f"Expense #{item_no}: {expense:.2f} yuan")

Expense #1: 25.00 yuan
Expense #2: 68.50 yuan
Expense #3: 16.50 yuan

Iteration	`item_no` (Number)	`expense` (Value)
Pass 1	`1`	`25.0`
Pass 2	`2`	`68.5`
Pass 3	`3`	`16.5`

Key Note (Unpacking and Start Number): (1) enumerate() yields a (number, element) pair on each pass, and for item_no, expense in ... assigns them to two variables via unpacking; (2) Omitting start begins numbering at 0; pass start=1 for 1-based business reports.

5.11 Case Description · Task Prompt

When a Loop Finishes Without `break`: Credit Overdue Audit

Given a customer's overdue days across three recent billing cycles in overdue_days = [0, 0, 0] (where 0 means paid on time and a positive integer gives overdue days), audit whether any overdue record exists.

Audit Rules

Inspect each entry; as soon as an overdue entry (days > 0) appears, print Overdue record found: X days overdue and stop immediately with break.
If all entries are checked without finding any overdue record, print No overdue records found; finally print Audit finished.

Expected Output for [0, 0, 0]

No overdue records found
Audit finished

Python Feature: Both for and while loops accept an aligned else: clause that runs only when the loop finishes without triggering break.

5.11 Case Code · Solution

The Loop `else` Clause: Read `else` as `no_break`

PYTHON (Note else: Aligned Vertically with for)

overdue_days = [0, 0, 0]

for days in overdue_days:
    if days > 0:
        print(f"Overdue record found: {days} days overdue")
        break
else:
    print("No overdue records found")

print("Audit finished")

Input `overdue_days`	How the Loop Ends	Run `else`?
`[0, 0, 0]` (clean)	Checks all 3 items; no `break` hit	Yes
`[0, 12, 0]` (overdue)	Hits `break` on 2nd item	No
`[]` (empty list)	0 iterations; no `break` hit	Yes

Key Note (Do Not Confuse Loop else with "Loop Did Not Run"): For [0, 0, 0], the loop runs 3 full iterations and still enters else! Think of loop else as no_break: it runs whenever the loop finishes without hitting break. In practice, using a flag variable found = False or early return inside a function works equally well.

5.12 Case Description · Task Prompt

Continuous Input: Sentinel Values and Interactive Loops

Sentinel Value: A special value that cannot occur in normal business data, agreed upon as the signal to end input (and not itself counted as data).

Interactive Store Revenue Entry Rules

Continuously read daily sales typed at the keyboard (valid sales are >= 0).
Entering -1 signals the end of input (the sentinel value).
Entering any other negative number prints Amount cannot be negative; please re-enter and continues prompting.
Once input ends, print the number of reported days and total reported sales.

Session for Inputs 120, -2, 0, 80, -1

Enter daily sales (-1 to stop): 120
Enter daily sales (-1 to stop): -2
Amount cannot be negative; please re-enter
Enter daily sales (-1 to stop): 0
Enter daily sales (-1 to stop): 80
Enter daily sales (-1 to stop): -1
Reported days: 3
Total reported sales: 200.00 yuan

5.12 Case Code · Solution

Two-Stage "Collect Then Aggregate" Design and Key Rules

PYTHON (Stage 1: while True Entry → Stage 2: for Traversal Summary)

sales_records = []

while True:
    amount = float(input("Enter daily sales (-1 to stop): "))
    if amount == -1.0:
        break
    if amount < 0.0:
        print("Amount cannot be negative; please re-enter")
        continue
    sales_records.append(amount)

total_sales = 0.0
for amount in sales_records:
    total_sales += amount
record_count = len(sales_records)

print(f"Reported days: {record_count}")
print(f"Total reported sales: {total_sales:.2f} yuan")

Core Concepts Part II · Exercise 1 Prompt

Listing All Price × Quantity Plans That Meet Target Profit

Given unit variable cost 30.0 yuan, fixed cost 1000.0 yuan, candidate prices prices = [50.0, 60.0], candidate quantities quantities = [100, 200, 300], and target profit 3000.0 yuan:

Requirements

Use a two-level nested loop (outer loop over prices, inner loop over quantities) to evaluate every combination.
Print every combination that earns a profit of at least 3000.0 yuan, and print the total count of qualifying plans at the end.

Expected Output

Price: 50.00 yuan, Quantity: 200 units, Profit: 3000.00 yuan
Price: 50.00 yuan, Quantity: 300 units, Profit: 5000.00 yuan
Price: 60.00 yuan, Quantity: 200 units, Profit: 5000.00 yuan
Price: 60.00 yuan, Quantity: 300 units, Profit: 8000.00 yuan
Qualifying plans: 4

Contrast Question: Because this task asks for all qualifying plans rather than the first qualifying volume (Section 5.9.2), should the inner loop include break?

Core Concepts Part II · Exercise 1 Solution

Full Grid Filtering and Counter Initialization Scope

PYTHON

prices = [50.0, 60.0]
quantities = [100, 200, 300]
unit_cost = 30.0
fixed_cost = 1000.0
target_profit = 3000.0
plan_count = 0

for price in prices:
    for quantity in quantities:
        profit = (price - unit_cost) * quantity - fixed_cost
        if profit >= target_profit:
            plan_count += 1
            print(
                f"Price: {price:.2f} yuan, Quantity: {quantity} units, "
                f"Profit: {profit:.2f} yuan"
            )

print(f"Qualifying plans: {plan_count}")

Core Concepts Part II · Exercise 2 Prompt

Locating the First Order That Exceeds an Audit Threshold

Write a function that takes a list order_amounts and an audit threshold, and uses enumerate(..., start=1) to return the 1-based number of the first order strictly exceeding (>) the threshold (or 0 if none exceeds it).

Order List `order_amounts`	Threshold `threshold`	Expected Return	Business Scenario
`[500.0, 1000.0, 1200.0, 1500.0]`	1000.0	3	Order 2 equals 1000.0 (not over); Order 3 is the first over
`[1200.0, 500.0]`	1000.0	1	Order 1 exceeds threshold immediately; returns 1
`[500.0, 1000.0]`	1000.0	0	No order strictly exceeds 1000.0; returns 0 after loop
`[]`	1000.0	0	Empty list skips the loop and returns 0 directly

Boundary Check: "Strictly exceeds" corresponds to the comparison operator > (an order equal to the threshold does not trigger an alert).

Core Concepts Part II · Exercise 2 Solution

Compact Sequential Search in a Function: Early `return`

PYTHON

def find_first_large_order(order_amounts: list, threshold: float) -> int:
    """Return 1-based number of first order > threshold, or 0 if none."""
    for order_no, amount in enumerate(order_amounts, start=1):
        if amount > threshold:
            return order_no
    return 0

print(find_first_large_order([500.0, 1000.0, 1200.0, 1500.0], 1000.0))
print(find_first_large_order([1200.0, 500.0], 1000.0))
print(find_first_large_order([500.0, 1000.0], 1000.0))
print(find_first_large_order([], 1000.0))

Compact Sequential Search Pattern: When searching for the first match inside a function, return immediately inside the if branch and place a fallback return 0 after the loop—no found flag or break needed.

Core Concepts Part II · Exercise 3 Prompt

Interactive Daily Sales Entry and Safe Average Calculation

Extend the interactive entry script from Section 5.12 so that after entry ends, it also computes the average daily sales across reported days (-1 stops entry; other negatives prompt re-entry; non-negatives are appended).

If at least one valid sales figure was recorded, print the average daily sales formatted to 2 decimal places;
If the user enters -1 immediately without recording any valid data, do not divide; print No valid records; cannot calculate average.

Keyboard Input Sequence	Reported Days	Total Sales	Expected Average or Notice
`120, -2, 0, 80, -1`	3 days	200.00 yuan	`66.67 yuan`
`0, -1`	1 day	0.00 yuan	`0.00 yuan`
`-1`	0 days	0.00 yuan	`No valid records; cannot calculate average`

Core Concepts Part II · Exercise 3 Solution

Interactive Entry, Traversal Summary, and Division Guard

PYTHON

sales_records = []
while True:
    amount = float(input("Enter daily sales (-1 to stop): "))
    if amount == -1.0:
        break
    if amount < 0.0:
        print("Amount cannot be negative; please re-enter")
        continue
    sales_records.append(amount)
total_sales = 0.0
for amount in sales_records:
    total_sales += amount
record_count = len(sales_records)
print(f"Reported days: {record_count}")
print(f"Total reported sales: {total_sales:.2f} yuan")
if record_count > 0:
    average_sales = total_sales / record_count
    print(f"Average reported daily sales: {average_sales:.2f} yuan")
else:
    print("No valid records; cannot calculate average")

Chapter Review (Part 1)

Three-Stage Loop Execution and Syntax Reference (Part 1)

Three-Stage Rhythm: (1) Initialize state variables before the loop → (2) Update state on each pass inside the loop → (3) Output or return the result after the loop

Business Scenario	Recommended Pattern	Key Principle and Error Prevention
Create empty list & append	`items = []` then `items.append(x)`	`.append()` mutates in place; never write `items = items.append(x)`
Read list element by position	`items[0]`, `items[1]`	Index measures offset from start; zero-based; guard against out-of-range
Traverse all items in a list	`for item in items:`	Loop variable receives each element directly without manual indexing
Repeat across integer range	`for i in range(start, stop, step):`	Half-open `[start, stop)`; to include integer `n`, set stop to `n + 1`
Repeat until condition met	`while condition_expression:`	Loop body must update state variables toward termination
Compute sum or count items	Initialize to `0` before; update inside	Never initialize inside the loop body, or state resets to 0 every pass

Chapter Review (Part 2)

Syntax Reference (Part 2) and Five Boundary Cases to Check

Business Scenario	Recommended Pattern	Key Principle and Error Prevention
Process only matching items	Nest `if` inside the loop body	Check indentation: only statements indented inside `if` are filtered
Skip special records	Use `continue` inside the loop body	Skips rest of current pass; in `while`, never skip the state increment
Exit loop on first match	Use `break` inside the loop body	Exits innermost enclosing loop immediately; outer loops keep running
Return match from function	Use `return` inside function loop	Exits entire function at once; place `return` after loop for totals
Get both number and item	`for no, item in enumerate(items, start=1):`	Unpacks `(number, item)` pairs without maintaining a manual counter
Evaluate price × quantity grid	Two-level nested loops	Inner loop runs a full cycle per outer step; total runs equal product

Five Boundary Cases to Test: (1) Empty inputs ([], month_count = 0, immediate -1); (2) Single-item inputs (n = 1); (3) Exact threshold values (exactly 99 yuan or target profit, checking < vs. <=); (4) Zero matches (verifying found or fallback return); (5) Already-satisfied start (while returning 0 immediately).

Supplementary Notes (Tips)

Loop Scope, Float Precision, and Explicit Loops vs. `sum()`

Tip 1: Loop Variables, Scope, and Read-Only Traversal

• Do not reassign the for variable inside the body: the next pass overwrites it; use step instead.

• No block scope: initialize post-loop variables before the loop.

• Do not delete list items while traversing: shifting elements skips adjacent items.

Tip 2: Floating-Point Precision in Financial Checks

• In binary floating point, 0.1 + 0.2 == 0.30000000000000004.

• Rule: Never use float == or != as a while stopping condition; use integer cents or Decimal.

• :.2f rounds only the displayed text, not the stored value.

Tip 3: Built-in sum() for Unconditional Totals (Outputs 4000.00 yuan)

daily_sales = [1200.0, 1500.0, 1300.0]
total_sales = sum(daily_sales)
print(f"Total sales: {total_sales:.2f} yuan")

When to Call sum() vs. Write an Explicit Loop?

Call sum() when adding a clean sequence unconditionally. Write an explicit loop whenever you need to skip -1.0 markers (5.8.2), apply per-order shipping rules before summing (5.8.3), or stop early with break on a budget cap (Exercise 3).

Action	Shortcut
Next slide	`→` `↓` `Space` `Page Down`
Previous slide	`←` `↑` `Page Up` `Shift + Space`
First / Last slide	`Home` / `End`
Contents / Fullscreen	`M` / `F`
Shortcuts / Close dialog	`?` / `Esc`

Loop Structures: for and while

Two Kinds of Repetitive Tasks

Two Limits of Sequential Code

Analyzing the Task

Two Benefits of Half-Open [start, stop)

Pattern Analysis

Why Do We Need an Accumulator?

Accounting Ledger Analogy

Task Breakdown and the Counter

Requirements and Formula

Why Is range() Unsuitable Here?

Selection Rule of Thumb

CVP Formula and Early Exit

Requirements and Skipping Logic

How continue Differs in for vs. while

Correct: Return After the Loop Completes

Buggy: Indenting return Inside the Loop Body

Key Note: In-Place Mutation

Data Conventions

Modular Function Design

Two-Dimensional Grid Evaluation

Requirements and Inner Early Exit

Audit Rules

Interactive Store Revenue Entry Rules

Requirements

Loop Structures: `for` and `while`

Two Benefits of Half-Open `[start, stop)`

Why Is `range()` Unsuitable Here?

How `continue` Differs in `for` vs. `while`