for statement in python

Python is a late-binding dynamic language. While Python programmers and the Python documentation frequently use the terms "variable" and "assignment" the more precise terms are "name" and "binding."

In your example x is a name of an object. At each iteration over the loop it's bound to the next object from your list. Python lists, and most other Python containers as well as many other Python object classes, feature iteration functions. That is to say that they define functions following a protocol which allows them to be used in for loops.

As you've noted a Python name (analogous to a "variable" in other languages) can be bound to any object of any type. A list can contain any mixture of object references. Thus, when you iterate over a list your "variable" (or loop name(s)) can be bound to objects of different types, potentially different types on each pass through the loop.

You can also have multiple names bound through "tuple unpacking" at each step through the iteration. For example the following snippet of code is a commonly used way to deal with dictionaries:

for key, value in some_dictionary.items():
   # do something with each key and its associated value

This form isn't specific to dictionaries. The .items() method of dictionaries returns a sequence of two item tuples and this form of for loop could be used with any list or sequence which returned two-item tuples (or even two-item lists). Similarly you could see tuple unpacking used on sequence consisting of items which contain a uniform number of items:

for category, item, quantity, price in some_invoice_query():
    # do something with these items, etc.

Conceptually a "variable" in most programming languages is a placeholder for data of a certain type (as well as a name by which that placeholder is referred throughout a program's source code). However, in Python (and other late-binding dynamic languages) a name is a reference to an object and conveys no constraint regarding the type or class of object to which the reference is made.

You can, rather crudely, think of Python names as if they were all void pointers in C.

x is a name in your current namespace, and the objects in grocery_list are assigned to this name one after another.

I think it is okay for you to treat x as a variable that is being defined within the for statement. Anything else is okay too. Python does not require a seperated "define" process, any variable is "defined" the first time it has been given a value.

The variable will be assigned behind the scenes each of the values of the list, in order. If the list holds references, then the reference will be assigned to the loop variable, of course.

It's almost equivalent to:

for i in xrange(len(grocery_list)):
  x = grocery_list[i]
  # rest of code here

But much much cleaner and (potentially) faster. The name (x) is not signicifant, it can be whatever you please.

After the loop has executed, the variable remains in scope, with the value of the last iteration that ran. So if you use a break to get out of the loop, that will show:

>>> for i in xrange(100):
...   if i == 10: break
...
>>> i
10

x is a temporary variable that steps through a sequence. In lists, x will step through each item in the list.

>>> grocery_list = ['apples', 'bananas', 'oranges', 'milk']
>>> for x in grocery_list:
...     print(x, len(x))
...
apples 6
bananas 7
oranges 7
milk 4
>>> print(x)
milk

EDIT: Apparently x remains defined even after the for loop exits.

A few more examples should clear things up:

>>> for x in 'some string': # x is bound to each character in the string
...     print(x)
...
s
o
m
e

s
t
r
i
n
g
>>> for x in (0, 1, 2, 3): # x is bound to each number in the tuple
...     print(x)
...
0
1
2
3
>>> for x in [(0,0), (1,1), (2,2)]: # x is bound to each tuple in the list
...     print(x)
... 
(0, 0)
(1, 1)
(2, 2)

In your example, x is the user-defined variable to which each value in grocery_list will be assigned in turn.

One must remember what a Python variable stores. It stores a location in memory where the object is pointing at is present. In other words, Python variables are basically pointers (void*s). They "know how to find their objects."

If you have x = 5 y = 3

the assignment y = x actually hands a copy of the memory address where 5 is stored to y. Now x and y point at the copy of 3 in memory. Suppose you attempt this

x = [1,2,3] for k in x: k = 0 What happens? You hand k a copy of the memory address where each item is stored. You then assign k to point a 0. The items in x are left undisturbed.

Now do this

x = [[1,2,3], [4,5,6], [7,8,9]] for k in x: k[0] = 0

Then x holds the list

[[0, 2, 3], [0, 5, 6], [0, 8, 9]]

You can change state of a mutable object via its memory address.

The moral: Python variables know WHERE to find their objects because they know where they are located in memory. When you assign one variable to another, you hand the recipient variable a copy of the donor variable's address. The loop variable in a for loop is just another variable.