How to Split a List Into Equal-Sized Chunks in Python

By the end of this page, you will understand how list chunking works in Python, why slicing is the most common solution, how to handle uneven final chunks, and how this pattern is used in real programs such as batching API requests, pagination, and data processing.

In Python, chunking a list means breaking one list into smaller lists of a fixed size.

For example:

numbers = [1, 2, 3, 4, 5, 6, 7]

If the chunk size is 3, the result should be:

[[1, 2, 3], [4, 5, 6], [7]]

The last chunk contains the remaining items because the list length is not always a perfect multiple of the chunk size.

This matters because real programs often need to process data in batches instead of all at once. Common reasons include:

• sending API requests in groups
• paginating results
• processing large datasets safely
• reducing memory usage in some workflows
• grouping items for display in a user interface

The most common Python solution uses list slicing inside a loop or list comprehension. Slicing lets you take a portion of a list from one index to another.

A chunking solution usually follows this idea:

1. start at index 0
2. move forward by chunk_size each time
3. slice from the current index to current index + chunk_size
4. stop when you reach the end of the list

This is simple, readable, and works well for beginners and production code.

Think of a list like a long loaf of bread.

• The full loaf is your original list.
• The knife cuts it every n items.
• Each slice becomes one chunk.
• If the loaf does not divide evenly, the last piece is smaller.

So if your loaf has 10 items and you cut every 4 items, you get:

• first slice: 4 items
• second slice: 4 items
• last slice: 2 items

Python slicing is the knife that makes those cuts.

The most common Python pattern is:

chunks = [my_list[i:i + size] for i in range(0, len(my_list), size)]

Example

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
size = 4

chunks = [numbers[i:i + size] for i in range(0, len(numbers), size)]
print(chunks)

Output:

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

How it works

• range(0, len(numbers), size) generates starting indexes: 0, 4, 8
• numbers[i:i + size] takes a slice from each starting index

Consider this code:

items = [10, 20, 30, 40, 50, 60, 70]
size = 3

chunks = [items[i:i + size] for i in range(0, len(items), size)]
print(chunks)

Step 1: Calculate the range

range(0, len(items), size)

Since len(items) is 7 and size is 3, this becomes:

range(0, 7, 3)

This produces the indexes:

0, 3, 6

Step 2: Slice at each index

Chunking lists appears in many practical tasks.

Batch API requests

Some APIs limit how many items you can send at once.

user_ids = [1, 2, 3, 4, 5, 6, 7]
for batch in [user_ids[i:i + 3] for i in range(0, len(user_ids), 3)]:
    print("Send batch:", batch)

Pagination

A web app may display records 20 at a time.

products = list(range(1, 51))
pages = [products[i:i + 20] for i in range(0, len(products), 20)]

Processing files in groups

If you need to process thousands of filenames, chunking can make the work easier to manage.

files = [, , , ]
chunks = [files[i:i + ]  i  (, (files), )]

In real codebases, developers usually wrap chunking logic in a function so it can be reused and validated.

Common helper function

def chunk_list(items, size):
    if size <= 0:
        raise ValueError("size must be greater than 0")
    return [items[i:i + size] for i in range(0, len(items), size)]

This adds a guard clause to reject invalid input early.

Validation pattern

Developers often validate arguments before processing:

def send_batches(items, batch_size):
    if batch_size <= 0:
        raise ValueError("batch_size must be positive")

    for i in range(0, len(items), batch_size):
        batch = items[i:i + batch_size]
        print("Processing", batch)

Streaming vs building a full list

In some projects, developers prefer a generator when the input is large:

Using a chunk size of 0

Broken code:

items = [1, 2, 3]
size = 0
chunks = [items[i:i + size] for i in range(0, len(items), size)]

This raises an error because range() cannot use a step of 0.

Avoid it by validating the size:

if size <= 0:
    raise ValueError("size must be greater than 0")

Forgetting that the last chunk may be smaller

Broken assumption:

items = [1, 2, 3, 4, 5]
size = 2
chunks = [items[i:i + size] for i in range(0, len(items), size)]

for chunk in chunks:
    print(chunk[1])

List comprehension vs loop

# List comprehension
chunks = [items[i:i + size] for i in (, (items), size)]

Basic chunking

chunks = [items[i:i + size] for i in range(0, len(items), size)]

Reusable function

def chunk_list(items, size):
    if size <= 0:
        raise ValueError("size must be greater than 0")
    return [items[i:i + size] for i in range(0, len(items), size)]

Generator version

def chunk_generator(items, size):
    if size <= 0:
        raise ValueError("size must be greater than 0")
    for i in range(0, len(items), size):
        yield items[i:i + size]

Key rules

• size must be greater than

How do I split a Python list into chunks of size n?

Use slicing with a step in range():

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

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

The final chunk will contain the remaining items and may be smaller than the others.

Can I chunk a list without using a list comprehension?

Yes. You can use a regular for loop and append each slice to a result list.

Why does Python slicing work even when the end index is too large?

Python slices stop safely at the end of the list instead of raising an error.

Should I use a generator instead of returning a list?

Use a generator when you want to process chunks one at a time or reduce memory usage for large inputs.

Can I use the same idea for strings?

Yes. Strings also support slicing, so the same pattern works, but the result will be chunks of strings instead of lists.

What error happens if the chunk size is 0?

You will get an error from range() because its step cannot be zero.

• List slicing — Chunking depends on taking sections of a list with items[start:end].
• List comprehensions — A compact way to build the list of chunks.
• for loops — Useful for writing chunking logic in a more explicit way.
• range() — Provides the sequence of starting indexes for each chunk.
• Generators — Helpful when yielding chunks one at a time.
• Iterators — Related because chunking is often part of sequential data processing.
• Pagination — A common real-world use of chunking.
• Input validation — Important for checking that chunk size is valid.