This article is a look at Python lists and how to split them – starting with the different implementations in the standard Python and then looking at list comprehension of Python.

The solutions described in this article will work for lists of ints, strings, lists and other objects.

Short summary of the articles examples:

## Solution 1: Python split list with itertools

We'll begin with the `itertools` and show how to split a list with `zip_longest`.

We will declare a range in Python of 21 elements and split it into groups of 4 elements. We will convert the range to a list.

As you can see from the example below in case of a smaller group - the result list will be filled with `None`.

``````import itertools as it

my_list = list(range(21))
n = 4

list(it.zip_longest(*[iter(my_list)] * n))
``````

result:

``````[(0, 1, 2, 3),
(4, 5, 6, 7),
(8, 9, 10, 11),
(12, 13, 14, 15),
(16, 17, 18, 19),
(20, None, None, None)]
``````

## Solution 2: Python split list with list comprehension

Another alternative to split lists into equal chunks is to use Python list comprehensions.

In this case we are going to split a list of 21 elements into lists of 5 elements each.

``````my_list = list(range(21))
n = 5

[my_list[i:i+n] for i in range(0, len(my_list), n)]
``````

result:

``````[[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19],
[20]]
``````

The difference to the previous solutions is that the last list will have only elements from the initial list.

## Solution 3: Python split list with numpy

My favourite solution is coming from `numpy`. There are two methods which can split array or list:

• `np.split`
• `np.array_split`

They can split list in a different way:

`np.array_split` defines the total number of chunks, not the number of elements per chunk.

So if we like to split 23 elements into 5 groups:

``````import numpy as np

my_list = list(range(23))
np.array_split(my_list, 5)
``````

we will get 3 lists of 5 elements and 2 of 4 elements:

``````[array([0, 1, 2, 3, 4]),
array([5, 6, 7, 8, 9]),
array([10, 11, 12, 13, 14]),
array([15, 16, 17, 18]),
array([19, 20, 21, 22])]
``````

`np.split` gets `indices_or_sections`. So in order to split the same list of 23 items into 5 lists we can use:

``````n = 5
np.split(my_list, range(n, n*n, n))
``````

which results into:

``````[array([0, 1, 2, 3, 4]),
array([5, 6, 7, 8, 9]),
array([10, 11, 12, 13, 14]),
array([15, 16, 17, 18, 19]),
array([20, 21, 22])]
``````

How does it work? We are giving the list and the indices where we would like to break the list.

So if we like to get chunks of 5 items per sublist we are going to generate indices as follow:

``````range(5, 25, 5)
``````

output:

`[5, 10, 15, 20]`

## Solution 4: Python split list with zip

One more option is to split lists in Python with `zip`. The solution seems to be a simple one as:

``````my_list = list(range(15))
n = 3

list(zip(*[iter(my_list)]*n))
``````

which will produce:

`[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, 14)]`

but in case of not evenly spread elements will produce unexpected results as:

``````my_list = list(range(17))
n = 3

list(zip(*[iter(my_list)]*n))
``````

result:

`[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, 14)]`

## Related Articles

better programmer

Python

Python

Selenium

PyCharm

Python

## JIRA how to format code python, SQL, Java

You've successfully subscribed to SoftHints - Python, Data Science and Linux Tutorials
Great! Next, complete checkout for full access to SoftHints - Python, Data Science and Linux Tutorials
Welcome back! You've successfully signed in
Success! Your account is fully activated, you now have access to all content.