Is there a more syntactically concise way of writing the following?
gen = (i for i in xrange(10))
index = 5
for i, v in enumerate(gen):
if i is index:
return v
It seems almost natural that a generator should have a gen[index] expression, that acts as a list, but is functionally identical to the above code.
one method would be to use itertools.islice
>>> gen = (x for x in range(10))
>>> index = 5
>>> next(itertools.islice(gen, index, None))
5
You could do this, using count as an example generator:
from itertools import islice, count
next(islice(count(), n, n+1))
I think the best way is :
next(x for i,x in enumerate(it) if i==n)
(where it is your iterator and n is the index)
It doesn't require you to add an import (like the solutions using itertools) nor to load all the elements of the iterator in memory at once (like the solutions using list).
Note 1: this version throws a StopIteration error if your iterator has less than n items. If you want to get None instead, you can use :
next((x for i,x in enumerate(it) if i==n), None)
Note 2: There are no brackets inside the call to next. This is not a list comprehension, but a generator comprehension, that does not consume the original iterator further than its nth element.
I'd argue against the temptation to treat generators like lists. The simple but naive approach is the simple one-liner:
gen = (i for i in range(10))
list(gen)[3]
But remember, generators aren't like lists. They don't store their intermediate results anywhere, so you can't go backwards. I'll demonstrate the problem with a simple example in the python repl:
>>> gen = (i for i in range(10))
>>> list(gen)[3]
3
>>> list(gen)[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
Once you start going through a generator to get the nth value in the sequence, the generator is now in a different state, and attempting to get the nth value again will return you a different result, which is likely to result in a bug in your code.
Let's take a look at another example, based on the code from the question.
One would initially expect the following to print 4 twice.
gen = (i for i in range(10))
index = 4
for i, v in enumerate(gen):
if i == index:
answer = v
break
print(answer)
for i, v in enumerate(gen):
if i == index:
answer = v
break
print(answer)
but type this into the repl and you get:
>>> gen = (i for i in range(10))
>>> index = 4
>>> for i, v in enumerate(gen):
... if i == index:
... answer = v
... break
...
>>> print(answer)
4
>>> for i, v in enumerate(gen):
... if i == index:
... answer = v
... break
...
>>> print(answer)
9
Good luck tracing that bug down.
EDIT:
As pointed out, if the generator is infinitely long, you can't even convert it to a list. The expression list(gen) will never finish.
There is a way you could put a lazily evaluated caching wrapper around an infinite generator to make it look like an infinitely long list you could index into at will, but that deserves its own question and answer, and would have major performance implications.
The first thing that came to my mind was:
gen = (i for i in xrange(10))
index = 5
for i, v in zip(range(index), gen): pass
return v
If n is known at authoring-time, you can use destructuring. e.g. to get the 3rd item:
>>> [_, _, third, *rest] = range(10)
>>> third
2
>>> rest
[3, 4, 5, 6, 7, 8, 9]
Perhaps you should elaborate more on a actual use case.
>>> gen = xrange(10)
>>> ind=5
>>> gen[ind]
5
Best to use is : example :
a = gen values ('a','c','d','e')
so the answer will be :
a = list(a) -> this will convert the generator to a list (it will store in memory)
then when you want to go specific index you will :
a[INDEX] -> and you will able to get the value its holds
if you want to know only the count or to do operations that not required store in memory best practice will be :
a = sum(1 in i in a) -> this will count the number of objects you have
hope i made it more simple.
