Split a List Into Evenly Sized Chunks in Python Using for Loop

In this example, You will learn a Python program to split a list into evenly sized chunks using for loop. This technique allows us to break down a list into smaller segments, making it easier to work with and perform operations on specific subsets of the data. We will dive into the code step by step, explaining the logic and operations involved in the chunking process.

In many programming tasks, we often encounter scenarios where we need to split a large list into smaller, equally sized chunks for easier processing or analysis. Whether you’re working with data manipulation, parallel processing, or any other task that benefits from dividing data into manageable portions, having a convenient method to split lists can be highly valuable.

So let’s get started and split a list into evenly sized chunks in Python using for loop.

Python Program to Split a List Into Evenly Sized Chunks Using for Loop

# Python Program to Split a List Into Evenly Sized Chunks Using for Loop

my_list = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
start = 0
end = len(my_list)
step = 3
for i in range(start, end, step):
	x = i

Code Explanation

Defining the List

We start by defining a list my_list containing a sequence of numbers from 1 to 15.

Defining Variables

Next, we define three variables: start, end, and step.

  • start represents the starting index of the list, which is initialized to 0.
  • end represents the ending index of the list, which is set to the length of the list using the len() function.
  • step represents the chunk size, indicating how many elements will be included in each chunk.

Iterating using a For Loop

We use a for loop to iterate over the list in chunks of the specified size. The loop starts at the start index and continues until it reaches the end index, incrementing by the step value in each iteration. Inside the loop, the current index value is assigned to the variable x for referencing.

Printing the Chunks

Within the loop, we print the sublist or chunk of the list using slicing notation. my_list[x:x+step] selects a subsequence from the list starting at index x and ending at index x+step. This prints each chunk of the list in separate lines.

Repeating Until the Loop Ends

The loop continues iterating until the end of the list is reached, with each iteration printing a new chunk of the list.


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

The program splits the original list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] into evenly sized chunks of size 3. Each chunk is printed on a separate line. The output shows the five chunks of the list, where each chunk contains three elements.

Comparison with another method:

In addition to using a for loop, there are a few other approaches to splitting a list into evenly sized chunks, such as:

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 List Comprehension:

List comprehension offers a concise way to split a list into chunks using slicing notation. It creates a new list by iterating over the original list and extracting chunks of the desired size. This method is compact and readable, suitable for situations where code brevity is preferred.

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.

Each of these methods provides a different approach to achieve the desired outcome. However, it follows a straightforward iterative process, making the code more readable and maintainable. The for loop method does not require any external libraries or dependencies. It relies solely on the built-in features of Python, making it highly accessible and portable. It provides flexibility in handling various list sizes and chunk sizes.


In this tutorial, the Python code provided allows us to split a list into evenly sized chunks using a for loop. By specifying the starting index, ending index, and the desired chunk size, we can easily divide the list into smaller segments for further processing or analysis.

The code demonstrates the power and flexibility of Python’s built-in for loop, which allows us to iterate over a sequence of elements and perform operations on them. By utilizing slicing notation, we can extract specific portions of the list and work with them individually.

Splitting a list into evenly sized chunks using a for loop opens up possibilities for efficient data processing and analysis, allowing you to handle large datasets effectively and break down complex tasks into more manageable steps.

Frequently Asked Questions

Can I use this code with any list?

Yes, you can use this code with any list. Simply assign your desired list to the my_list variable before executing the code.

What happens if the list length is not divisible by the chunk size?

If the list length is not divisible by the chunk size, the last chunk may be smaller than the specified size. The code will still split the list into chunks as evenly as possible, with the last chunk containing the remaining elements.

How can I access and use the chunks for further processing?

Inside the for loop, the current chunk is printed. Instead of printing, you can store each chunk in a separate list or perform any desired operations on the chunk directly within the loop.

Can I modify the code to perform operations on each chunk separately?

Yes, you can include additional code within the loop to perform operations on each chunk separately. For example, you can apply specific calculations, transformations, or analyses to each chunk before moving on to the next iteration.

How can I change the size of the chunks?

You can modify the value of the step variable to change the size of the chunks. Increasing the value will result in smaller chunks, while decreasing the value will create larger chunks.

About The Author

Leave a Reply