Concepts / Using range() and enumerate() for Index-Based Loops

Using range() and enumerate() for Index-Based Loops

A basic for loop over a list gives the loop variable the actual element value. In the example, the variable contains red, then blue, then green. It does not automatically contain 0, 1, and 2, which would be the positions of those elements.

  • Programming

From the List to the Loop

When a list contains several items, a common task is to do something with each item in turn. Python's for loop provides a natural way to visit the elements one by one. The syntax is similar to the syntax used when iterating through a string: the loop variable receives one element, the loop body runs, and then the loop moves to the next element.

items["red", "blue", "green"]redloop variableblueloop variablegreenloop variablefirst iterationsecond iterationthird iteration
What happens to the loop variable as a list is traversed from left to right?

Tracing Each Element

Code walkthrough
items = ["red", "blue", "green"]
for item in items:
    print(item)
  1. 1
    On the first iteration, item contains red, so red is printed.
  2. 2
    On the second iteration, item contains blue, so blue is printed.
  3. 3
    On the third iteration, item contains green, so green is printed.
  • The list contains three elements.
  • The loop variable item receives the first element, then the second, then the third.
  • The print operation runs once for each element.
Output
red
blue
green

What do you think happens?

Before reading the result, predict the output produced by this loop: values = [4, 8, 12]; for value in values: print(value)

  • 4, then 8, then 12

  • 0, then 1, then 2

  • The list itself is printed once

  • Nothing is printed

Reveal answer
Answer:

4, then 8, then 12

The loop variable contains the actual element value on each iteration. It does not contain the element's index.

Key point

A basic for loop over a list gives the loop variable the actual element value. In the example, the variable contains red, then blue, then green. It does not automatically contain 0, 1, and 2, which would be the positions of those elements.

When the Position Matters

Sometimes the element value is enough. In other situations, the position is also needed. The supplied material identifies range(len(list)) as the approach to use when the index is required. The length determines how many positions are available, and range supplies the position values for the loop. The element can then be accessed using that position.

0items[0]redelement1items[1]blueelement2items[2]greenelementaccessesaccessesaccesses
How do positions from range(len(items)) connect to the elements accessed in the list?
python
Output (expected)
0 red
1 blue
2 green

Lists Inside Lists

A nested list is still one element of the outer list. If an outer list contains a smaller list, one iteration visits that inner list as a whole. The loop does not automatically visit every value inside the nested list as separate outer-loop iterations.

outer list["A", ["B", "C"]]Afirst elementAfirst iteration["B", "C"]second element["B", "C"]second iterationcontainscontainsthen
When a list contains another list, what does the outer loop variable contain on each iteration?
python
Output (expected)
A
['B', 'C']
Key point

The outer loop has two iterations in this example: one for A and one for the nested list. The values B and C are not separate iterations of the outer loop.

Empty Lists

An empty list contains no elements to visit. Therefore, a for loop over an empty list does not enter its body even once. This is normal behavior, not an error. Any operation placed inside the loop is skipped because there is no loop value to process.

empty list[]element available?noloop bodynot executedno outputbeginnoskip
What happens to the loop body and output when the list has zero elements?
python
Output (expected)
finished

Mistakes in Prediction

first elementiteration 1printed outputsame visit ordersecond elementiteration 2third elementiteration 3thenthenproducesproducesproduces
In what order are elements visited, and what value is available after each iteration?
  • Common mistake

    Assuming the loop variable contains the index

    What it looks like

    For a list containing red, blue, and green, expecting item to contain 0, then 1, then 2

    Why it fails

    A normal for loop over a list assigns the actual element value to the loop variable.

    Do this instead

    Use the element directly when the value is needed. Use range(len(items)) when the position is needed.

  • Common mistake

    Expecting a nested list to be flattened automatically

    What it looks like

    Expecting an outer loop over ["A", ["B", "C"]] to visit A, B, and C separately

    Why it fails

    The nested list is one element of the outer list.

    Do this instead

    Treat the nested list as the value received during one outer-loop iteration.

  • Common mistake

    Treating an empty-list loop as an error

    What it looks like

    Expecting the loop body to run once even when the list is []

    Why it fails

    There are no elements available, so there are no iterations.

    Do this instead

    Expect the loop body to run zero times and produce no output from operations inside that body.

EASY

Predict the output before running this loop: values = ["north", ["east", "west"]]. The loop prints each value it receives. State how many iterations occur and what the loop variable contains during each iteration.

Hints
  • Count the elements of the outer list.
  • The inner list is one element of the outer list.
  • The loop variable receives the actual element value.

A Reliable Tracing Method

  1. 1
    Write down the elements of the list in their existing order.
  2. 2
    For each element, record the value assigned to the loop variable.
  3. 3
    Run the loop body once for each recorded element.
  4. 4
    If the list is empty, record zero iterations and skip the body.
  5. 5
    If an element is itself a list, keep that inner list together as one outer-loop value.
  6. 6
    If the position is required, identify the index-based form using range(len(list)).
Worked example

Predicting a Mixed List

Determine the output and number of iterations for a loop over ["start", ["middle", "inside"], "end"].

  1. 1
    Identify the outer elements

    The outer list has three elements: the string start, the nested list ["middle", "inside"], and the string end.

  2. 2
    Trace iteration one

    The loop variable contains start.

  3. 3
    Trace iteration two

    The loop variable contains the complete nested list ["middle", "inside"].

  4. 4
    Trace iteration three

    The loop variable contains end.

Result

There are three outer-loop iterations. The nested list is processed as one element during the second iteration.

Key Takeaways

  1. 1
    A for loop is a natural way to visit every element in a list.
  2. 2
    The loop variable contains the actual element value, not its index.
  3. 3
    Use range(len(list)) when index-based access is needed.
  4. 4
    An empty list causes zero loop-body executions and is not an error.
  5. 5
    A nested list counts as one element of the outer list during iteration.

At a glance

  • A list for loop visits elements in order, assigning one actual element value to the loop variable at a time.
  • The loop variable is not an index in a basic list iteration.
  • Use range(len(list)) when the element position is needed.
  • Nested lists are single elements of the outer list, and empty lists produce zero iterations.

Related Topics

Related concepts

More concepts starting with U