With linq I would

var top5 = array.Take(5);

How to do this with Python?

Skip to content
# python – How to take the first N items from a generator or list?

## The Question :

*342 people think this question is useful*
*The Question Comments :*
## The Answer 1

*557 people think this answer is useful*
# Slicing a list

# Slicing a generator

## The Answer 2

*123 people think this answer is useful*
## The Answer 3

*40 people think this answer is useful*
## The Answer 4

*37 people think this answer is useful*

## The Answer 5

*14 people think this answer is useful*
## The Answer 6

*7 people think this answer is useful*
## The Answer 7

*3 people think this answer is useful*
## The Answer 8

*-5 people think this answer is useful*
### Related Posts

#### dom events – Stop setInterval call in JavaScript

#### How to use R’s ellipsis feature when writing your own function?

#### How do I access .local domains from ipad and iphone

#### About Author

##### moting1a

2021-01-17

- It is confusing that this question was asked for both lists and generators, these should have been separate questions

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]`

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)`

import itertools top5 = itertools.islice(array, 5)

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)

@Shaikovsky’s answer is excellent (*â€¦and heavily edited since I posted this answer*), 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))`

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()`

.

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)

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 (`N`

). 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_element=[generator.next() for i in range(N)]

Otherwise:

first_N_element=list(generator)[:N]

Where `N`

is the number of elements you want to take (e.g. N=5 for the first five elements).

This should work

top5 = array[:5]