# How to take the first N items from a generator or list?

## Question:

With I would

``````var top5 = array.Take(5);
``````

How to do this with Python?

``````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 min-heap (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 syntax `itertools.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))`

Categories: questions Tags: , ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.