Etydhv

I have the following code:

a = [0,1,2,3]

for a[-1] in a:
 print(a[-1])

The output is:

0
1
2
2

I'm confused about why a list index can be used as an indexing variable in a for a loop?

To bring a language-lawyer aspect to the question, let's look at documentation:

for_stmt ::= "for" target_list "in" expression_list ":" suite

The expression list is evaluated once; it should yield an iterable object. An iterator is created for the result of the expression_list. The suite is then executed once for each item provided by the iterator, in the order returned by the iterator. Each item in turn is assigned to the target list using the standard rules for assignments (see Assignment statements), and then the suite is executed.

^{(emphasis not originally in docs)
The suite refers to the statements under the for-block, print(a[-1]) in our particular case.}

Simply, on each iteration, the loop variable (target_list) gets assigned to the next item in the iterable (expression_list).

Let's extend the print statement:

a = [0, 1, 2, 3]
for a[-1] in a:
 print(a, a[-1])

This gives the following output:

[0, 1, 2, 0] 0 # a[-1] assigned 0
[0, 1, 2, 1] 1 # a[-1] assigned 1
[0, 1, 2, 2] 2 # a[-1] assigned 2
[0, 1, 2, 2] 2 # a[-1] assigned itself (2)

As a[-1] is a valid form left-hand side, assignments to a[-1] will mutate a, modifying the list during iteration. In this particular example, a[-1] retains -2 from the previous evaluation. If we trace the assignment on each iteration, we have

a[-1] = 0 # a[0] # a[3] is 0 now
a[-1] = 1 # a[1] # a[3] is 1 now
a[-1] = 2 # a[2] # a[3] is 2 now
a[-1] = 2 # a[3] # a[3] is itself (2)

(this is more of a long comment than an answer - there are a couple of good ones already, especially @TrebledJ's. But I had to think of it explicitly in terms of overwriting variables that already have values before it clicked for me.)

If you had

x = 0
l = [1, 2, 3]
for x in l:
 print(x)

you wouldn't be surprised that x is overriden each time through the loop. Even though x existed before, its value isn't used (i.e. for 0 in l:, which would throw an error). Rather, we assign the values from l to x.

When we do

a = [0, 1, 2, 3]

for a[-1] in a:
 print(a[-1])

even though a[-1] already exists and has a value, we don't put that value in but rather assign to a[-1] each time through the loop.

it is an interesting question, you can understand it by that:

for v in a:
 a[-1] = v
 print(a[-1])

print(a)

actually a becomes: [0, 1, 2, 2] after loop

output:

0
1
2
2
[0, 1, 2, 2]

Hope that helps you, and comment if you have further questions. : )

The left expression of a for loop statement gets assigned with each item in the iterable on the right in each iteration, so

for n in a:
 print(n)

is just a fancy way of doing:

for i in range(len(a)):
 n = a[i]
 print(n)

Likewise,

for a[-1] in a:
 print(a[-1])

is just a fancy way of doing:

for i in range(len(a)):
 a[-1] = a[i]
 print(a[-1])

where in each iteration, the last item of a gets assigned with the next item in a, so when the iteration finally comes to the last item, its value got last assigned with the second-last item, 2.

a[-1] refers to the last element of a, in this case a[3]. The for loop is a bit unusual in that it is using this element as the loop variable.
It's not evaluating that element upon loop entry, but rather it is assigning to it on each iteration through the loop.

So first a[-1] gets set to 0, then 1, then 2. Finally, on the last iteration, the for loop retrieves a[3] which at that point is 2, so the list ends up as [0, 1, 2, 2].

A more typical for loop uses a simple local variable name as the loop variable, e.g. for x .... In that case, x is set to the next value upon each iteration. This case is no different, except that a[-1] is set to the next value upon each iteration. You don't see this very often, but it's consistent.