Variable Assignment and Operators

Four Questions for Every Collection

When a loop processes a collection, four questions appear repeatedly: How many elements are there? What is their total? Which element is largest? Which element is smallest? Counting, summing, and finding extremes are common loop tasks in data processing. Each pattern uses a variable initialized before the loop, updated while the loop runs, and read after the loop completes.

A Loop State Trace

A counter records how many elements have been processed. It starts at 0 because no elements have been processed before the loop begins. Each iteration increases it by 1. After six iterations, the counter is 6. The value of the current element is not needed for this task; only the fact that the loop ran once for each element matters.

Counting and Summing

Counting and summing have similar structures but update their variables differently. A counter increases by 1 for every element. A total increases by the current element's value. Thus, counting measures the number of loop iterations, while summing accumulates the data values encountered during those iterations.

count = 0
total = 0

for itervar in values:
    count = count + 1
    total = total + itervar

For the count variable, the current value of itervar is irrelevant. For total, the current value is essential because that value is added to the running result. In the source example, the total progresses through 0 + 3 = 3, 3 + 41 = 44, and 44 + 12 = 56 before continuing through the remaining elements. The final total is 154 for all six numbers.

Comparing Extremes

Maximum and minimum searches use a comparison variable. The variable begins as None, meaning that no element has been selected yet. On the first element, the comparison with None allows that element to become the current maximum or minimum. Later elements replace the stored value only when they satisfy the relevant comparison.

largest = None
smallest = None

for itervar in values:
    if largest is None or itervar > largest:
        largest = itervar

    if smallest is None or itervar < smallest:
        smallest = itervar

The greater-than operator controls the maximum search. When the current element is greater than the stored largest value, largest is updated. The less-than operator controls the minimum search. When the current element is less than the stored smallest value, smallest is updated.

In the source trace, largest becomes 3 on the first iteration, changes to 41 when 41 is compared with 3, remains 41 when 12 is processed, and later changes to 74 because 74 is greater than 41. The final maximum is 74. For the minimum search, smallest becomes 3 on the first iteration and never changes because no later value is less than 3. The final minimum is 3.

Tracing a Complete Update

count = 0 total = 0 for itervar in values: count = count + 1 total = total + itervar

Debugging by State

When a result is unexpected, write down the variable's value before the loop and after every iteration. For counting, record the counter. For summing, record the total before and after each addition. For maximum and minimum searches, record the current element, the comparison result, and whether the stored extreme changed.

Mistakes in Loop Updates

• Starting a counter or total with a value other than 0.

  The variable already claims that one element has been processed before the loop begins.

  Fix: Initialize the counter to 0. Initialize the sum total to 0.

• Adding the current element to the counter instead of increasing the counter by 1.

  Counting tracks how many elements were processed, not the values of those elements.

  Fix: Increase the counter by 1 on every iteration.

• Updating the maximum when the current value is smaller.

  A maximum must be replaced only by a larger value.

  Fix: Use the greater-than comparison for the maximum.

• Updating the minimum when the current value is larger.

  A minimum must be replaced only by a smaller value.

  Fix: Use the less-than comparison for the minimum.

• Skipping the state trace when the final result looks wrong.

  The final value does not show which iteration caused the logic to diverge.

  Fix: Record the accumulator or comparison variable before the loop and after each iteration.

Practice the Four Patterns

The Reusable Pattern

1. Counting starts a counter at 0 and increases it by 1 for each processed element.
2. Summing starts a total at 0 and adds each element's value to it.
3. Maximum searches start with None and replace the stored value when a greater element is found.
4. Minimum searches start with None and replace the stored value when a smaller element is found.
5. Tracing each variable before and after every iteration reveals where an unexpected result begins.