# Break a list into chunks of size N in Python

• Difficulty Level : Medium
• Last Updated : 19 Jan, 2023

In this article, we will cover how we split a list into evenly sized chunks in Python.

Below are the methods that we will cover:

### Method 1: Break a list into chunks of size N in Python using yield keyword

The yield keyword enables a function to come back where it left off when it is called again. This is the critical difference from a regular function. A regular function cannot comes back where it left off. The yield keyword helps a function to remember its state. The yield enables a function to suspend and resume while it turns in a value at the time of the suspension of the execution.

## Python3

 `my_list ``=` `[``'geeks'``, ``'for'``, ``'geeks'``, ``'like'``,``           ``'geeky'``,``'nerdy'``, ``'geek'``, ``'love'``,``               ``'questions'``,``'words'``, ``'life'``]` `# Yield successive n-sized``# chunks from l.``def` `divide_chunks(l, n):``    ` `    ``# looping till length l``    ``for` `i ``in` `range``(``0``, ``len``(l), n):``        ``yield` `l[i:i ``+` `n]` `# How many elements each``# list should have``n ``=` `5` `x ``=` `list``(divide_chunks(my_list, n))``print` `(x)`

Output:

```[['geeks', 'for', 'geeks', 'like', 'geeky'],
['nerdy', 'geek', 'love', 'questions', 'words'],
['life']]```

### Method 2: Break a list into chunks of size N in Python using a loop

In this example, we are using a loop in python and list slicing that will help us to break a list into chunks.

## Python3

 `my_list ``=` `[``1``, ``2``, ``3``, ``4``, ``5``,``           ``6``, ``7``, ``8``, ``9``]``start ``=` `0``end ``=` `len``(my_list)``step ``=` `3``for` `i ``in` `range``(start, end, step):``    ``x ``=` `i``    ``print``(my_list[x:x``+``step])`

Output:

```[1, 2, 3]
[4, 5, 6]
[7, 8, 9]```

### Method 3: Break a list into chunks of size N in Python usingList comprehension

It is an elegant way to break a list into one line of code to split a list into multiple lists in Python.

## Python3

 `my_list ``=` `[``1``, ``2``, ``3``, ``4``, ``5``,``              ``6``, ``7``, ``8``, ``9``]` `# How many elements each``# list should have``n ``=` `4` `# using list comprehension``final ``=` `[my_list[i ``*` `n:(i ``+` `1``) ``*` `n] ``for` `i ``in` `range``((``len``(my_list) ``+` `n ``-` `1``) ``/``/` `n )]``print` `(final)`

Output:

```[[1, 2, 3, 4], [5, 6, 7, 8], [9]]
Auxiliary Space: O(1)```

Alternate Implementation :

## Python3

 `l ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``9``]`` ` `# How many elements each``# list should have``n ``=` `4`` ` `# using list comprehension``x ``=` `[l[i:i ``+` `n] ``for` `i ``in` `range``(``0``, ``len``(l), n)]``print``(x)`

Output:

`[[1, 2, 3, 4], [5, 6, 7, 8], [9]]`

### Method 4: Break a list into chunks of size N in Python using Numpy

Here, we are using a Numpy.array_split, which splits the array into n chunks of equal size.

## Python3

 `import` `numpy as np` `arr ``=` `range``(``30``)``np.array_split(arr, ``6``)`

Output:

```[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, 23, 24]),
array([25, 26, 27, 28, 29])]```

### Method 5: Break a list into chunks of size N in Python using itertool

In this example, we will use itertool to slice each array in equal size. we are passing a parameter in the range of 30 and split size of 5.

## Python3

 `from` `itertools ``import` `islice`  `def` `chunk(arr_range, arr_size):``    ``arr_range ``=` `iter``(arr_range)``    ``return` `iter``(``lambda``: ``tuple``(islice(arr_range, arr_size)), ())`  `list``(chunk(``range``(``30``), ``5``))`

Output:

```[(0, 1, 2, 3, 4),
(5, 6, 7, 8, 9),
(10, 11, 12, 13, 14),
(15, 16, 17, 18, 19),
(20, 21, 22, 23, 24),
(25, 26, 27, 28, 29)]```

### Method 6: Collections

One approach to splitting a list into chunks of size N without using a loop is to use the collections module. The collections module has a deque class that allows you to easily split a list into chunks of a specific size.

Here’s an example of how you can use the deque class to split a list into chunks of size N:

## Python3

 `from` `collections ``import` `deque` `def` `split_list(input_list, chunk_size):``  ``# Create a deque object from the input list``  ``deque_obj ``=` `deque(input_list)``  ``# While the deque object is not empty``  ``while` `deque_obj:``      ``# Pop chunk_size elements from the left side of the deque object``      ``# and append them to the chunk list``      ``chunk ``=` `[]``      ``for` `_ ``in` `range``(chunk_size):``        ``if` `deque_obj:``          ``chunk.append(deque_obj.popleft())``        ` `      ``# Yield the chunk``      ``yield` `chunk``input_list ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``9``, ``10``]``chunk_size ``=` `3``chunks ``=` `list``(split_list(input_list, chunk_size))``print``(chunks) ``# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]`

Output

`[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]`

The deque class allows you to easily remove elements from the left or right side of the list, making it easy to split the list into chunks of a specific size. The code uses a while loop and a generator function to iterate over the list and yield the chunks one at a time. The loop breaks when the deque is empty, which indicates that all elements have been processed.

This approach has a time complexity of O(n) and a space complexity of O(n), where n is the size of the input list.

### Method 7: Partial assignment

Here’s an example of how you can easily process list by chunks of size N:

## Python3

 `my_list ``=` `list``(``range``(``10``))``chunk_size ``=` `3``while` `my_list:``    ``chunk, my_list ``=` `my_list[:chunk_size], my_list[chunk_size:]``    ``print``(chunk)`

Output

```[0, 1, 2]
[3, 4, 5]
[6, 7, 8]
[9]
```

My Personal Notes arrow_drop_up