Understanding for Loops and Iteration

Why State Matters

A for loop processes a list one item at a time. That is enough when each item can be handled independently, but many tasks require information from earlier iterations. You may need to know how many items have been seen or what total has been built so far. An accumulator is the variable that preserves this information: it starts before the loop, changes during each iteration, and contains the final result when the loop ends.

A Loop Visits Each Item

When a for loop runs over a list, one iteration processes one item and then the loop moves to the next item. The loop's iteration variable identifies the current item. The loop continues until every item in the list has been processed. An accumulator gives the loop a way to remember a result across those separate passes.

Counting Processed Items

A counting loop answers how many items have been processed. Set a counter to zero before the loop. During every iteration, increase the counter by one. The current item's value does not matter, because every item contributes exactly one to the count. After the loop finishes, the counter represents the total number of items seen.

items = ["red", "blue", "green", "yellow"]
count = 0

for item in items:
    count += 1

print(count)

4

The iteration variable item is present in the example because the loop needs a name for the current list item. The counting operation itself does not use item. Each pass contributes one item to the count, so the counter changes from zero to one, then two, then three, and finally four.

Summing a Running Total

A summing loop uses the current item's actual value. Set the total to zero before the loop, then add the current item to total during every iteration. Unlike a counting loop, which always adds one, a summing loop may add a different amount on each pass. The accumulator therefore represents the sum of all items seen so far.

values = [3, 41, 12, 28, 50, 20]
total = 0

for value in values:
    total += value

print(total)

154

Tracing the Accumulator

Tracing means recording the accumulator after every update. Begin with total equal to zero. The first value is 3, so total becomes 3. The next value is 41, so total becomes 44. Continuing this process gives 56 after adding 12, 84 after adding 28, 134 after adding 50, and 154 after adding 20. Because each new value uses the previous total, the accumulator never resets during the loop.

Keeping the Update Correct

• Initializing the accumulator inside the loop

  The variable is reset on every iteration, so earlier values are discarded instead of being retained.

  Fix: Set total to zero before the loop and update it inside the loop.

• Adding one when the task is to compute a sum

  Adding one counts items, but it does not add their actual numeric values.

  Fix: Use total += value for a summing loop.

• Adding the current value when the task is to count

  A counting loop should give every item the same contribution of one, regardless of the item's value.

  Fix: Use count += 1 for each processed item.

Choosing Built-In Functions

Manual loops are valuable because they reveal the counting and accumulation patterns. However, Python provides built-in functions for these two basic tasks. len() returns the number of items in a list, and sum() returns the total of numeric items. For ordinary counting and summing, these functions are clearer, shorter, and more efficient than writing a manual loop.

items = ["red", "blue", "green", "yellow"]
values = [3, 41, 12, 28, 50, 20]

item_count = len(items)
value_total = sum(values)

print(item_count)
print(value_total)

4
154

Practice the Trace

Key Takeaways

1. An accumulator starts before a loop, changes during each iteration, and holds the final result afterward.
2. A counting loop adds one for every item, so its counter represents the number of items processed.
3. A summing loop adds the current item's value, so its accumulator represents the running sum.
4. Tracing the accumulator after every iteration helps verify that the update is correct and that the value never resets unexpectedly.
5. Use len() for basic list counts and sum() for totals of numeric items; use manual loops to learn the pattern and for tasks without a direct built-in function.