Nested Loops and Complex Iterations

A Character at a Time

A for loop can visit every character in a string without requiring you to manage index numbers yourself. During each iteration, Python assigns the next character to the loop variable, runs the loop body, and then continues to the next character. The loop stops after all characters have been visited.

Mapping Positions to Characters

Consider the string banana. It contains six characters. A string index identifies a position, while a for loop assigns the character at that position to the loop variable. The loop does not display the index; it exposes the character itself. The repeated a and n characters are visited because they occur at separate positions in the string.

The diagram shows the relationship between positions and loop values. At the first position, char receives b. At the next position, it is reassigned to a, and this continues in order until the final a. The variable is reused, but its value changes at every iteration.

Tracing Every Iteration

A useful trace records two things for every iteration: the current value of the loop variable and the action performed by the loop body. After the body runs for b, control returns to the loop so the variable can receive a. The same process repeats for n, a, n, and a. Once the final character has been processed, there is no next character, so the loop stops automatically.

Writing the Loop

In a string-traversal loop, the variable after for holds the current character, the value after in is the string being traversed, and the indented body contains the processing performed for each character. The keyword in tells Python to iterate through the string's elements.

fruit = "banana"
for char in fruit:
    print(char)

b
a
n
a
n
a

Following Control Flow

The loop body is not the whole loop. After the body processes the current character, control returns to the iteration mechanism. Python assigns the next character to the loop variable and runs the body again. This automatic progression is why you do not need to increment an index or manually test whether the end of the string has been reached.

Diagnosing Unexpected Traversal

When the output is not what you expected, trace the loop one iteration at a time. Write down the character assigned to the loop variable and the action performed by the body. Compare that trace with the characters in the original string in order. The first difference identifies where the loop's observed behavior diverges from your expectation.

• Expecting the loop variable to contain an index number.

  A for loop over a string assigns each character directly to the loop variable.

  Fix: Trace the character value held by the variable at each iteration.

• Assuming repeated characters were skipped.

  The loop visits positions in order, so repeated characters at different positions are visited separately.

  Fix: Record each iteration in sequence, even when the character value is the same as one seen earlier.

• Adding manual stopping or index management to a simple traversal.

  The for loop automatically continues until all characters have been visited.

  Fix: Let the for loop handle progression and termination when your task is to process every character.

• Looking only at the loop header and ignoring the indented body.

  The body runs once for every character and determines the processing performed at each step.

  Fix: Record both the current character and the body's action during every iteration.

Choosing the Clearer Approach

A while loop with manual index tracking can also traverse a string, but a for loop is simpler and less error-prone for this purpose. It avoids manual index increments and end checks. It also communicates the intent clearly: visit each character and run the body once for each one.

Practice the Trace

Key Takeaways

1. A for loop over a string assigns one character to its loop variable per iteration.
2. The loop visits characters in their string order and continues until all characters have been visited.
3. The loop variable contains the character, not the index number, although each iteration corresponds to an index position.
4. Tracing the variable and loop body step by step helps predict output and locate unexpected behavior.
5. For loops are usually clearer and less error-prone than manual index-based traversal when processing every character.