How to Split a List in Half in 5 Ways

Problem Formulation and Solution Overview

In this article, you’ll learn how to split a Python List in half.

To make it more fun, we have the following running scenario:

Lisa is writing a report concerning Population growth for three (3) countries (the US, UK, and Germany) between 2021-2022. However, she saved it as one list and now needs to split this list into two (2) equal halves.

💬 Question: How would we write code to split a Python List in Half?

We can accomplish this task by one of the following options:

• Method 1: Use Slicing
• Method 2: Use List Comprehension
• Method 3: Use the Right Shift Operator
• Method 4: Use islice()
• Method 5: Use accumulate()

Method 1: Use Slicing

This issue can be solved using Python’s Slicing Slicing using two (2) lines of code.

populations = [336997624, 59597300, 38246108, 338289857, 68507026, 38411751]
pop_in_2021 = populations[:len(populations)//2]
pop_in_2022 = populations[len(populations)//2:]
print(pop_in_2021, pop_in_2022)

Above declares a list of six (6) populations. The first half represents the population of the US, UK and Canada for 2021. In the second half, the population of the US, UK and Canada for 2022. This list saves to populations.

To extract the population data for 2021, populations is sliced from the start position of zero (0) to halfway through the list (or three elements in) using popluation // 2. This slicing equates to the following:

To extract the population data for 2022, populations is sliced from the start position of three (3), which equates to populations // 2.
The end position is the remaining length of populations. This slicing equates to the following:

💡Note: Floor Division rounds down to the nearest integer value. In this case, three (3).

The output is sent to the terminal. The 2021 list is displayed on the left, and the 2022 list is on the right.

Method 2: Use List Comprehension

This method uses List Comprehension, slicing and range() to split a single list into a list with two (2) nested lists using one (1) line of code!

populations = [336997624, 59597300, 38246108, 338289857, 68507026, 38411751]
all_pops = [populations[x:x+3] for x in range(0,len(populations),3)]
print(all_pops)

Above declares a list of six (6) populations. The first half represents the population of the US, UK and Canada for 2021. In the second half, the population of the US, UK and Canada for 2022. This list saves to populations.

To split the list into two (2) nested lists, List Comprehension is used in conjunction with slicing and range() to loop through and determine where to split. In this case, every three (3) elements.

The output is sent to the terminal and displays the 2021 data as the first nested list and the 2022 data as the second nested list.

🌟A Finxter Favorite!

Method 3: Use a Function and Slicing

This method creates a function that accepts a list and uses the Right Shift Operator to split it into a Tuple, each containing its own list.

def split_half(pop):
    half = len(pop) >> 1
    return pop[:half], pop[half:]

populations = [336997624, 59597300, 38246108, 338289857, 68507026, 38411751]
print(split_half(populations))

Above defines a function with one (1) argument (split_half(pop)).

This function splits the list in half using the Right Shift Operator and returns the results as a Tuple with two (2) nested lists.

💡Note: The Right Shift Operator works the same as Floor Division.

Method 4: Use islice()

This method imports the itertools library to use the islice() function: an efficient way to iterate through a list.

from itertools import islice
populations = [336997624, 59597300, 38246108, 338289857, 68507026, 38411751]
len_split = [len(populations)//2]*2
results = [list(islice(iter(populations), elem)) for elem in len_split]
print(results)

Above imports the itertools library to call in and use the islice() function.

The following line declares a list of six (6) populations. The first half represents the population of the US, UK and Canada for 2021. In the second half, the population of the US, UK and Canada for 2022. This list saves to populations.

Next, where to split populations is determined based on the calculation ([len(popluations)//2]*2). This saves to len_split and equates to the following:

Finally, List Comprehension is used along with islice() to iterate through populations and split the list into two (2) based on len_split ([3, 3]).

The output is sent to the terminal and displays the 2021 data as the first nested list and the 2022 data as the second nested list.

💡Note: The islice() function allows the user to loop through an iterable with a start and stop and return, in this case, an object which is then converted to a list.

Method 5: Use accumulate()

This method imports the itertools library to use the accumulate() function.

from itertools import accumulate

populations = [336997624, 59597300, 38246108, 338289857, 68507026, 38411751]
len_split = [len(populations)//2]*2
results = [populations[x - y: x] for x, y in zip(accumulate(len_split), len_split)]
print(results)

Above imports the itertools library to call in and use the accumulate() function.

The following line declares a list of six (6) populations. The first half represents the population of the US, UK and Canada for 2021. In the second half, the population of the US, UK and Canada for 2022. This list saves to populations.

Next, where to split populations is determined based on the calculation ([len(popluations)//2]*2). This saves to len_split and equates to the following:

Finally, List Comprehension is used along with zip() and accumulate() to iterate through populations and split the list into two (2) based on len_split ([3, 3]).

The output is sent to the terminal and displays the 2021 data as the first nested list and the 2022 data as the second nested list.

Summary

These methods of spitting a list in half should give you enough information to select the best one for your coding requirements.

Good Luck & Happy Coding!

Programmer Humor

👱‍♀️ Programmer 1: We have a problem
🧔‍♂️ Programmer 2: Let’s use RegEx!
👱‍♀️ Programmer 1: Now we have two problems

… yet – you can easily reduce the two problems to zero as you polish your “RegEx Superpower in Python“. 🙂