String Iteration and Indexing

A Count That Changes Selectively

Suppose you want to find how many times the letter a appears in banana. The important idea is not simply to increase a number repeatedly. Instead, the number increases only when the character currently being examined satisfies a condition. This selective updating is the counter pattern.

Mapping Positions to Characters

When a loop examines banana, it visits each character in sequence: b, a, n, a, n, a. At every step, the program has a current character and can compare it with the target character a. The loop does not increment the counter merely because it moved to the next character; it increments only when the current character matches the target.

The position map shows why the loop must inspect every character. The target appears three times, but those matches are separated by nonmatching characters. A correct counter must preserve its current value during the nonmatching iterations and then increase when the next a is encountered.

Tracing the Counter

The trace has two kinds of steps. When the current character is b or n, the comparison is false and count keeps its previous value. When the current character is a, the comparison is true and count increases by exactly 1. After all six characters have been examined, count is 3.

The Counting Process

A character-counting loop follows four actions in order: create the counter with value 0, read each character, test whether it equals the target, and increment the counter only after a successful comparison. The condition controls the state change. Without the condition, every character would be counted rather than only matching characters.

count = 0
for letter in "banana":
    if letter == "a":
        count = count + 1

print(count)

3

The increment is indented inside the condition, so it runs only for a matching character. In this example, the three a characters trigger the increment, producing the final count 3.

Reusable Character Counting

Once the loop works, the same counter pattern can be placed inside a function. The function accepts the string to search and the character to count as parameters. This separates the counting process from one particular string or target, so the same logic can be reused with different inputs.

def count(text, letter):
    total = 0
    for character in text:
        if character == letter:
            total = total + 1
    return total

print(count("banana", "a"))
print(count("cocoa", "o"))

3
2

The function keeps the same four-part process: initialize, iterate, test, and increment. The parameters determine which string is searched and which character is treated as a match. The return statement makes the accumulated count available to the caller.

Mistakes That Break the Count

• Initializing the counter inside the loop

  The counter is reset during the iteration instead of accumulating across the characters.

  Fix: Initialize the counter before the loop begins.

• Forgetting to increment the counter

  A matching character is recognized, but the accumulated total never changes.

  Fix: Increment the counter inside the true branch of the condition.

• Using assignment instead of comparison

  The condition needs to compare the current character with the target character.

  Fix: Use the comparison operator == for the match test.

• Placing the increment outside the condition

  The counter increases for every loop iteration, including characters that do not match.

  Fix: Place the increment in the conditional block so only matches increase the total.

Practice the Trace

Pattern Summary

1. The counter pattern starts at 0, examines each item, checks a condition, and increments only when the condition is true.
2. String character counting uses iteration to visit each character and comparison to identify matches.
3. The counter remains unchanged during nonmatching iterations and accumulates the total number of matches.
4. A function with string and target-character parameters turns one counting loop into a reusable tool.
5. The same pattern can support other tasks that accumulate results based on a condition.