Python generator making a referencce

Question

I was trying to use a generator to save on some memory and ran into a problem. I am a bit surprised at the result because my understanding was that integers were immutable, so can someone explain what's going on?

>>>> a = []
>>>> for i in range(10):
....     a.append((i for _ in [0]))
....     
>>>> list(a[0])
[9]

When I do it using list comprehension instead it does what I want:

>>>> a = []
>>>> for i in range(10):
....     a.append([i for _ in [0]])
....     
>>>> a
[[0], [1], [2], [3], [4], [5], [6], [7], [8], [9]]

I can sort of reason that what's going on is that the generator is somehow getting a "reference" to the value of i, which, after the last time through the loop is 9, but this seems anti-pythonic as python doesn't have references as such (at least as far as I understand).

Questions:

1. What is going on? How is this possible? A link to some python docs that can explain exactly what's going on would be appreciated.
2. How can I do what I want (use a generator with a variable that's going to change in the future but which I need the current value for something)?

Update:

Realistic use case:

def get_some_iter(a, b):
    iters = []
    for i in a:
        m = do_something(i, len(b))
        iters.append((SomeObj(j, m) for j in itertools.combinations(b, i))

    return itertools.chain(*iters)

Answer 1

Generators are lazily evaluated. Until you sent it to list(), that generator was not executing anything. When you did send it to list(), it then executed. What was i at that point? The last value it was assigned: 9.

list comprehensions are eagerly evaluated. Each time that expression is encountered, its contents are immediately evaluated. The first time through the loop, i is 0, and that value is immediately retrieved and stored. This produces a different value for each loop iteration.

Answer 2

Well yes the generator keeps the reference to i, because there is not really any other solution for it internally.

The best solution would be to have it all as a generator:

a = ((i for _ in [0]) for i in range(10))
for g in a:
    print(list(g))
[0]
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]

Of course it doesn't solve the problem if you need to access directly to the n+1 value without getting the first n. If you need to do so I think the most pythonic way would be to build your own iterator, something like this :

class ListIter(object):
    def __init__(self, i):
        self.i= i
        self.iter = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.iter > 0:
            raise StopIteration
        else:
            self.iter += 1
            return self.i

a = [ListIter(i) for i in range(10)]
list(a[0])
[0]