Split a List Into Evenly Sized Chunks in Python Using List Comprehension

As a Python developer, you often encounter situations where you need to split a list into evenly sized chunks. This can be especially useful when dealing with large datasets or when you want to streamline your code. In this tutorial, we will explore how to split a list into evenly sized chunks in Python using list comprehension.

By the end of this blog, you will have a solid grasp of how to leverage list comprehension to split lists into smaller, more manageable chunks, opening up possibilities for efficient data processing and manipulation.

Splitting a list into smaller evenly sized chunks can be useful for tasks such as parallel processing, data manipulation, or organizing data for analysis. Python provides a powerful feature called list comprehension, which allows us to create new lists based on existing ones in a concise and efficient manner.

Let’s get started and write a Python program to split a list into evenly sized chunks using list comprehension.

Python Program to Split a List Into Evenly Sized Chunks Using List Comprehension

# Split a List Into Evenly Sized Chunks in Python Using List comprehension

my_list =  [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
# 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) 

Code Logic Explanation

Defining the input list

We start by defining our input list, my_list, which contains elements from 1 to 16.

Determining the chunk size

We specify the size of each chunk that we want to create. In this case, n is set to 4, indicating that we want to split the list into chunks of 4 elements each.

Perform the list comprehension

Using list comprehension, we split the list into evenly sized chunks. Next, we iterate over a range of indices, from 0 to the calculated number of chunks. Within the list comprehension, we use slicing to extract a portion of the list for each iteration. The starting index is i * n, and the ending index is (i + 1) * n. This creates a chunk of n elements from the original list.

Printing the final result

After the list comprehension completes, we print the final list, which contains the desired result—the original list split into evenly sized chunks.


[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

The program takes the list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] and splits it into chunks of size 4. The resulting output is a list of lists, where each inner list represents a chunk of 4 elements from the original list.

In the output, the first inner list [1, 2, 3, 4] contains the first four elements of the original list. The second inner list [5, 6, 7, 8] contains the next four elements, and so on. This process continues until all the elements in the original list are split into equally sized chunks. The final output displays all the chunks as separate lists within a larger list.

Let’s explore a few alternative methods:

Using Yield:

This approach uses a generator function with the yield keyword to produce chunks one at a time. It is memory-efficient because it generates chunks on-the-fly without storing the entire result in memory. This method is useful when dealing with large lists or when memory usage is a concern.

Using for Loop:

With a for loop and slicing, we can iterate over the list and extract chunks of the desired size. This method is simple and intuitive to understand. It works well for small to medium-sized lists.

Using NumPy:

NumPy, a powerful library for numerical computations, provides the array_split function to split arrays into evenly sized chunks. It is efficient for handling large datasets and performing complex numerical operations. This method is advantageous when dealing with numerical data and performing subsequent calculations.

Using itertools:

The islice function from the itertools module can be used to split a list into chunks. It offers various iteration tools for efficient and memory-friendly operations. This method is beneficial when working with iterators or when more advanced iteration functionalities are required.

Using Collections:

The deque class from the collections module can be utilized to split a list into chunks efficiently. Deque provides efficient operations for adding and removing elements from both ends. This method is useful when frequent appending or popping of elements is required during the splitting process.

List comprehension, used in this tutorial, is a concise and elegant approach for splitting a list into evenly sized chunks in Python. It combines the iteration, slicing, and construction of the new list into a single line of code. List comprehension is known for its efficiency and speed. It leverages the optimized internals of Python and can provide good performance for most scenarios.


The above code exemplifies an efficient and concise approach to splitting a list into evenly sized chunks using list comprehension in Python. By applying list comprehension, we can easily split a list into chunks of a specified size, which can be useful in various scenarios. Whether it’s processing large datasets, implementing algorithms, or manipulating data, this technique proves to be valuable in Python programming.

Overall, the ability to split lists into evenly sized chunks using list comprehension enhances our productivity and provides a convenient way to work with data in a structured manner. It is a versatile tool that empowers Python developers to tackle complex tasks efficiently and produce cleaner code.

Frequently Asked Questions

How is the number of chunks calculated in the code?

The number of chunks is calculated using the formula (len(my_list) + n – 1) // n, where len(my_list) represents the length of the original list, and n is the desired chunk size.

What happens if the original list is not divisible into equal-sized chunks?

The code handles this scenario by using integer division (//) to round down the number of chunks. The last chunk may have fewer elements if the original list size is not evenly divisible by the desired chunk size.

Can I change the chunk size to a different value?

Yes, you can modify the n variable to specify a different chunk size according to your requirements. Simply assign a different value to n in the code.

Is there a limit to the size of the input list?

There is no inherent limit to the size of the input list. The code will work with lists of any length, as long as the system has enough memory to handle the resulting list of chunks.

How can I access individual chunks from the final list?

Each chunk is stored as a separate sublist within the final list. You can access individual chunks by using their respective indices. For example, final[0] gives you the first chunk, final[1] gives the second chunk, and so on.

Can I use this code to split a list into unevenly sized chunks?

The provided code splits the list into evenly sized chunks. If you want to split the list into unevenly sized chunks, you would need to modify the code by specifying the desired sizes for each chunk individually.

About The Author

Leave a Reply