Array Indexing and Index Expressions

Imagine an array holding five stored values, and a loop whose counter starts at zero. The loop body runs once for each counter value and stops as soon as the counter reaches five. On each pass the body prints the element whose position matches the current counter value. Before you read further, try to predict what this program prints, and in what order. Making that prediction first will show you which parts of the mechanism you already understand and which parts need closer attention.

The rest of this article explains the mechanism behind that prediction. The central idea is that an array index does not have to be a fixed number written into the code. It can be held in an integer variable, or it can be any expression whose value is an integer. Because the variable can change while the written code stays the same, one line of code can reach different elements at different moments. That flexibility is one of the main reasons arrays are so useful.

Think of the index variable as a pointer that moves through the positions of the array. Suppose the array holds the values 10, 20, 30, 40, and 50 at positions zero through four. If the variable i holds zero, the expression list[i] names the first position, which holds 10. If i then holds one, the same written text list[i] names the second position, which holds 20. The text list[i] never changes. Only the value of i changes, and that changed value redirects the access.

The diagram uses invented values for illustration. The point to notice is that each index names exactly one stored value. When i holds zero, the expression selects the element at position zero. When i holds two, the same expression selects the element at position two. The expression is evaluated fresh each time it is used, so its result follows whatever the variable holds at that moment.

An index is not limited to a bare variable. It can be any expression whose value is an integer. Python evaluates the expression inside the square brackets first, and the result of that evaluation decides which element is accessed. An expression such as i plus one simply produces the position one greater than i. Because the expression is computed before the element is read, it can combine the loop counter with other integers to reach a position that is offset from the current one.

A for loop is the natural tool for visiting every element of an array, because its counter can serve as the array index itself. The loop variable starts at zero, the body runs once per value, and the variable increases after each pass. The continuation condition compares the variable with the array's length, and the loop continues only while that comparison holds. For printing every element of an array named values, the loop has this shape:

On the first pass the counter holds zero, so the body reads the value at position zero. On the second pass the counter holds one, and the body reads the value at position one. The pattern continues until the counter equals five. At that point the continuation condition is false and the loop stops. The body never runs with the counter at five, which is why the last printed element is the one at position four. The loop visits the indices in order, so the printed output follows the order of the positions in the array.

Processing an array often means combining its elements rather than printing them. Suppose you have an array of double values and want its average. The plan has two stages. First, a loop adds every element into a running total that starts at zero. Second, the total is divided by the number of items in the array to produce the average. The division happens once, after the loop has finished.