How to split a list in half Python

how to split a list in half python

The list is one of the important data structures in Python. A developer comes across a list on daily basis which makes it an essential data structure. The list has features like 

  • Can store different data types.
  • It is mutable
  • Ordered collection
  • Can be of dynamic size

There are multiple ways of splitting a list in half using Python. You can choose any splitting method based on the complexity, time, and memory requirement.

Using Slicing to split a list in half

Using the length function, we can find the number of elements in the list and then perform integer division to get the middle point. Now, let’s understand it with code. 
def split_list_into_halves(lst):
    mid = len(lst) // 2
    return lst[:mid], lst[mid:]

my_list = [1, 2, 3, 4, 5, 6, 7, 8]
left_half, right_half = split_list_into_halves(my_list)
print("Left half:", left_half)
print("Right half:", right_half)
output 
Left half: [1, 2, 3, 4]
Right half: [5, 6, 7, 8]
‘lst[:mid]’ gives us the first half of the list and ‘lst[mid:]’ provides other half of the list.

Using loop for splitting the list in half

In this approach, we can split a list into multiple parts of equal size using a for loop. You can mention the parts variable value as 2 to split the list in half. However, you can apply any feasible value in the parts variable to split the list. This approach uses  math module and list comprehension.

from math import ceil

def split_list_into_parts(lst, parts=2):
    length = len(lst)
    part_size = ceil(length / parts)
    return [lst[i * part_size:(i + 1) * part_size] for i in range(parts)]

# Example usage:
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
parts = split_list_into_parts(my_list, parts=2)
print("Parts:", parts)

output

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

Let’s grasp throught the code.

  • Parts variable stores value for a number of parts you want to split the list into.
  • Part_size calculates the size of each part
  • We have used list comprehension “[lst[i * part_size:(i + 1) * part_size] for i in range(parts)]” . In this code line we iterate through the range of parts and slice the list accordingly. In the first go the code might seem little bit difficult to understand but list comprehension makes the code fast and readable.

Splitting the list into half using numpy

If you have the option of only using NumPy to split a list. You need to first install NumPy by executing following command “pip install numpy”  in command prompt and then import the NumPy module in code.

import numpy as np
def split_list_into_halves_np(lst):
    arr = np.array(lst)
    split_point = len(arr) // 2
    return arr[:split_point].tolist(), arr[split_point:].tolist()


my_list = [1, 2, 3, 4, 5, 6, 7, 8]
left_half_np, right_half_np = split_list_into_halves_np(my_list)
print("Left half (numpy):", left_half_np)
print("Right half (numpy):", right_half_np)
print("Parts:", parts)

output

Left half (numpy): [1, 2, 3, 4]
Right half (numpy): [5, 6, 7, 8]

In the above code, we use np.array(lst) to convert the list into a numpy array. “Arr[split_point:]” and “arr[:split_point]” slice the numpy array to get the left and right halves.

We need to always choose the method that best fits our needs based on whether we prefer simplicity, efficiency or compatibility with other libraries we might be using.

Using itertools.islice for splitting a list into half.

If you don’t want to use numpy then we can follow itertool approach for splitting the list.

from itertools import islice

def split_list_into_parts(lst, parts=2):
  length = len(lst)
  div, mod = divmod(length, parts)

  for i in range(parts):
    start = i * div + min(i, mod)
    end = (i + 1) * div + min(i + 1, mod)
    yield islice(lst, start, end)

# Example usage:
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
parts_iter = split_list_into_parts(my_list, parts=2)

for part in parts_iter:
  print(list(part))

output

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

In this approach:

  • div variable calculates the size of each part. Mod variable handles the remainder when the list length is not perfectly divisible by parts.
  • for i in range(parts): – Moves over the specified number of parts.
  • start = i * div + min(i, mod) – Calculates the starting index for slicing the list. min(i, mod) ensures that the first mod parts get an extra element.
  • end = (i + 1) * div + min(i + 1, mod) – Calculates the ending index for slicing the list.
  • yield islice(lst, start, end) – Uses islice to slice the list lst from start to end and yields the resulting slice as a generator object.
  • for part in parts_iter:
    print(list(part))
  • To print values in parts_iter variable. We loop over parts_iter and convert the part (generatot object) to list and print it

Using numpy.array_split to split the list into half

We have NumPy inbuilt function which helps to split the list into half. You have to first install NumPy by running the following command “pip install numpy” in the command prompt. Now let’s explore the code.

import numpy as np

def split_list_into_approx_equal_parts(lst, parts=2):
    return np.array_split(lst, parts)


my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
parts_np = split_list_into_approx_equal_parts(my_list, parts=2)
print("Parts (numpy array_split):", parts_np)

output

Parts (numpy array_split): 
[array([1, 2, 3, 4, 5]),
 array([ 6,  7,  8,  9, 10])]

The above numpy function np.array_split(lst,parts) takes two parameter i.e. a list which needs to be splitted and number of parts the list has to be splitted.

In the blog,  we  have seen 5 ways of how to spit a list in half python in a simple and efficient manner. 

Related Posts

Subscribe
Subscribe