当 l 是生成器时无法测试“x in l”

Question

Question

I am trying to understand the difference between a list comprehension and a generator expression:

x = 25

if x in [i**2 for i in range(100)]:
    print('list version: {} is a square!'.format(x))
# list version: 25 is a square!

if x in (i**2 for i in range(100)):
    print('generator version: {} is a square!'.format(x))
# generator version: 25 is a square!

When called once, they both appear to do the same thing. So there isn't a difference?

But then I try them in a loop:

l = [i**2 for i in range(100)]
g = (i**2 for i in range(100))

print('list version')
for x in range(20, 51):
    if x in l:
        print('{} is a square!'.format(x))
# list version
# 25 is a square!
# 36 is a square!
# 49 is a square!

print('generator version')
for x in range(20, 51):
    if x in g:
        print('{} is a square!'.format(x))
# generator version
# 

In the generator version, no square is found. Why? What's different between a generator and a list?

Context

I am trying to solve the following problem: Given a number n (n > 0) I must produce the smallest square number N (N > 0) such that n + N is also a perfect square. If no response is received, return -1.

I have the following code:

def solve(n):
    # l = [i**2 for i in range(10**2)]
    l = (i**2 for i in range(10*4))
    r = -1
    for i in l:
        if n + i in l:
            return i
        else:
            r = -1
    return r

It works when I use list comprehension l = [i**2 for i in range(10**2)] , but not when I use generator l = (i**2 for i in range(10*4) .

I verified this code in Python visualizer and it does not enter the loop if I use the generating algorithm.

Could you please assist me?

Answer 1

Understanding generators

A list is a data structure: the elements in a list are stored in memory and can be looked at, modified, added or deleted at will.

By contrast, a generator is a lazy structure. The elements in a generator are generated and consumed when they are looked at. They are not generated sooner, and will not be regenerated later. Let's look at an example:

# lists
>>> l = [i**2 for i in range(5)]
>>> l
[0, 1, 4, 9, 16]
>>> l
[0, 1, 4, 9, 16]
>>> l
[0, 1, 4, 9, 16]

# generators
>>> g = (i**2 for i in range(5))
>>> g
<generator object <genexpr> at 0x7fbec28e5970>
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> list(g)
[9, 16]
>>> list(g)
[]
>>> list(g)
[]

Initially, g is ready to generate all elements 0,1,4,9,16 . But every element will only be generated once. Once we've seen the 0, and the 1, and the 4, we won't see them again. When we call list(g) after having already seen the first three elements, we get a list of only the last two elements. And if we try to call list(g) again after that, we get an empty list, because there are no elements left to generate.

In your code, you use the operator in to test whether an element is in a generator. Let's play with in :

>>> g = (i**2 for i in range(5))
>>> 4 in g
True
>>> 9 in g
True
>>> 1 in g
False
>>> 16 in g
False
>>> 4 in g
False

What happened? First, g was ready to generate 0,1,4,9,16 . Then we asked whether 4 in g ? So the first three elements were generated, and 4 was found: we got the answer True and now g has only two elements left to generate. Then we ask: 9 in g ? One more element is generated, 9 is found, we get the answer True and now g only has one more element left to generate. Then we ask 1 in g ? Since there is no 1 left to generate, all elements remaining are generated, and 1 is not found. We get the answer False and now g is exhausted. Now, any question we ask will get the answer False : there is nothing left in g .

Relevant documentation

I suggest reading the python tutorial, and its section on iterators and generators .