Python Split list into chunks
Tags: python, programming, codenewbie, tutorial
Published: 2021-12-08 14:12:31

---
title: Python Split list into chunks
published: true
date: 2021-12-05 21:33:30 UTC
tags: #python #programming #codenewbie #tutorial
canonical_url: https://itsmycode.com/python-split-list-into-chunks/
---

ItsMyCode |

In this tutorial, you will learn how to split a list into chunks in Python using different ways with examples.

## Python Split list into chunks

Lists are mutable and heterogenous, meaning they can be changed and contain different data types. We can access the [elements of the list](https://itsmycode.com/how-to-filter-list-elements-in-python/) using their index position.

There are five various ways to split a list into chunks.

1. **Using a For-Loop**
2. **Using the List Comprehension Method**
3. **Using the itertools Method**
4. **Using the NumPy Method**
5. **Using the lambda Function**

## Method 1: Using a For-Loop

The naive way to split a list is using the for loop with help of **`range()`** function. 

The range function would read `range(0, 10, 2)`, meaning we would loop over the items `0,2,4,6,8`.

We then index our list from `i:i+chunk_size`, meaning the first loop would be `0:2`, then `2:4`, and so on.

```python 
# Split a Python List into Chunks using For Loops

sample_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
chunked_list = list()
chunk_size = 2
for i in range(0, len(sample_list), chunk_size):
    chunked_list.append(sample_list[i:i+chunk_size])
print(chunked_list)

```

**Output**

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

## Method 2: Using the List Comprehension Method

The list comprehension is an effective way to split a list into chunks when compared to for loop, and it’s more readable.

We have a` sample_list` and contain ten elements in it. We will split the list into equal parts with a `chunk_size` of 2.

```python 
# Split a Python List into Chunks using list comprehensions
sample_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
chunk_size=2
result=[sample_list[i:i + chunk_size] for i in range(0, len(sample_list), chunk_size)]
print(result)

```

**Output**

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

`sample_list[i:i + chunk_size]` give us each chunk. For example, if i=0, the items included in the chunk are `i to i+chunk_size`, which is from `0:2` index. In the next iteration, the items included would be `2:4` index and so on.

## Method 3: Using the itertools Method

We can leverage the **`itertools `** module to split a list into chunks. The **`zip_longest()`** function returns a generator that must be iterated using for loop. It’s a straightforward implementation and returns a [list of _tuples_](https://itsmycode.com/typeerror-list-indices-must-be-integers-or-slices-not-tuple/), as shown below.

```python 
# Split a Python List into Chunks using itertools

from itertools import zip_longest

sample_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
chunk_size=2
result=list(zip_longest(*[iter(sample_list)]*chunk_size, fillvalue=''))
print(result)

chunked_list = [list(item) for item in list(zip_longest(*[iter(sample_list)]*chunk_size, fillvalue=''))]
print(chunked_list)
```

**Output**

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

```

## Method 4: Using the NumPy Method

We can use the **`NumPy `** library to divide the list into n-sized chunks. The **`array_split()`** function splits the list into sublists of specific size defined as n.

```python 
# Split a Python List into Chunks using numpy

import numpy as np

# define array and chunk_szie
sample_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
our_array = np.array(sample_list)
chunk_size = 2

# split the array into chunks
chunked_arrays = np.array_split(our_array, len(sample_list) / chunk_size)
print(chunked_arrays)

# Covert chunked array into list
chunked_list = [list(array) for array in chunked_arrays]
print(chunked_list)
```

**Output**

```python 
[array([1, 2]), array([3, 4]), array([5, 6]), array([7, 8]), array([9, 10])]
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
```

## Method 5: Using the lambda Method

We can use the lambda function to divide the list into chunks. The lambda function will iterate over the [elements in the list](https://itsmycode.com/how-to-get-the-last-element-of-a-list-in-python/) and divide them into N-Sized chunks, as shown below.

```python 
# Split a Python List into Chunks using lambda function

sample_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
chunk_size = 2

lst= lambda sample_list, chunk_size: [sample_list[i:i+chunk_size] for i in range(0, len(sample_list), chunk_size)]
result=lst(sample_list, chunk_size)
print(result)

```

**Output**

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

The post [Python Split list into chunks](https://itsmycode.com/python-split-list-into-chunks/) appeared first on [ItsMyCode](https://itsmycode.com).