How to take the first N items from a generator or list?
Question:
Answers:
import itertools
top5 = itertools.islice(array, 5)
This should work
top5 = array[:5]
Do you mean the first N items, or the N largest items?
If you want the first:
top5 = sequence[:5]
This also works for the largest N items, assuming that your sequence is sorted in descending order. (Your LINQ example seems to assume this as well.)
If you want the largest, and it isn’t sorted, the most obvious solution is to sort it first:
l = list(sequence)
l.sort(reverse=True)
top5 = l[:5]
For a more performant solution, use a minheap (thanks Thijs):
import heapq
top5 = heapq.nlargest(5, sequence)
Slicing a list
top5 = array[:5]
 To slice a list, there’s a simple syntax:
array[start:stop:step]
 You can omit any parameter. These are all valid:
array[start:]
,array[:stop]
,array[::step]
Slicing a generator
import itertools
top5 = itertools.islice(my_list, 5) # grab the first five elements

You can’t slice a generator directly in Python.
itertools.islice()
will wrap an object in a new slicing generator using the syntaxitertools.islice(generator, start, stop, step)

Remember, slicing a generator will exhaust it partially. If you want to keep the entire generator intact, perhaps turn it into a tuple or list first, like:
result = tuple(generator)
In my taste, it’s also very concise to combine zip()
with xrange(n)
(or range(n)
in Python3), which works nice on generators as well and seems to be more flexible for changes in general.
# Option #1: taking the first n elements as a list
[x for _, x in zip(xrange(n), generator)]
# Option #2, using 'next()' and taking care for 'StopIteration'
[next(generator) for _ in xrange(n)]
# Option #3: taking the first n elements as a new generator
(x for _, x in zip(xrange(n), generator))
# Option #4: yielding them by simply preparing a function
# (but take care for 'StopIteration')
def top_n(n, generator):
for _ in xrange(n):
yield next(generator)
With itertools
you will obtain another generator object so in most of the cases you will need another step the take the first n
elements. There are at least two simpler solutions (a little bit less efficient in terms of performance but very handy) to get the elements ready to use from a generator
:
Using list comprehension:
first_n_elements = [generator.next() for i in range(n)]
Otherwise:
first_n_elements = list(generator)[:n]
Where n
is the number of elements you want to take (e.g. n=5 for the first five elements).
The answer for how to do this can be found here
>>> generator = (i for i in xrange(10))
>>> list(next(generator) for _ in range(4))
[0, 1, 2, 3]
>>> list(next(generator) for _ in range(4))
[4, 5, 6, 7]
>>> list(next(generator) for _ in range(4))
[8, 9]
Notice that the last call asks for the next 4 when only 2 are remaining. The use of the list()
instead of []
is what gets the comprehension to terminate on the StopIteration
exception that is thrown by next()
.
@Shaikovsky’s answer is excellent, but I wanted to clarify a couple of points.
[next(generator) for _ in range(n)]
This is the most simple approach, but throws StopIteration
if the generator is prematurely exhausted.
On the other hand, the following approaches return up to n
items which is preferable in many circumstances:
List:
[x for _, x in zip(range(n), records)]
Generator:
(x for _, x in zip(range(n), records))