Split list into lists by value - Python

The goal here is to split a list into sublists based on a specific value in Python. For example, given a list [1, 4, 5, 6, 4, 7, 4, 8] and a chosen value 4, we want to split the list into segments that do not contain the value 4, such as [[1], [5, 6], [7], [8]]. Let’s explore different approaches to split the list by a specified value.

Using itertools.groupby

groupby function from itertools groups consecutive elements of a list based on a specific condition. This method loops through the grouped elements and processes only the parts of the list that don't match the condition, effectively splitting the list based on where the condition changes.

from itertools import groupby

a = [1, 4, 5, 6, 4, 5, 6, 5, 4]
b = 4

res = []
for k, g in groupby(a, lambda x: x == b):
    if not k:
        res.append(list(g))

print(res)

[[1], [5, 6], [5, 6, 5]]

Explanation: lambda x: x == b creates groups of True (when equal to b) or False (when not equal). It then checks for False groups and appends them to the result list, effectively splitting the list at occurrences of b and keeping only the segments without b.

Using for loop with manual split

This method involves manually looping through the list and splitting it into sublists whenever a specific element is encountered. It tracks the positions where the list should be split and collects the segments accordingly.

a = [1, 4, 5, 6, 4, 5, 6, 5, 4]
b = 4

res = []
start = 0
for i, v in enumerate(a):
    if v == b:
        res.append(a[start:i])
        start = i + 1
if start < len(a):
    res.append(a[start:])

print(res)

[[1], [5, 6], [5, 6, 5]]

Explanation: Loops through the list a, splitting it into sublists at occurrences of b and appending segments without b to the result. It tracks the start of each segment and adds any remaining elements after the last occurrence of b.

Using filter

Here, the filter function is used to remove elements that match a certain condition from parts of the list. The list is split into segments and filter is applied to each segment to eliminate unwanted elements, leaving only the desired parts of the list.

a = [1, 4, 5, 6, 4, 5, 6, 5, 4]
b = 4

res = []
start = 0
for i, v in enumerate(a):
    if v == b:
        res.append(list(filter(lambda x: x != b, a[start:i])))
        start = i + 1
if start < len(a):
    res.append(a[start:])

print(res)

[[1], [5, 6], [5, 6, 5]]

Explanation: This code loops through a, using filter to remove occurrences of b from each segment and appends the filtered segments to the result. It adds any remaining elements after the last b, splitting the list at b and keeping only non-b elements.

Using reduce

reduce function from functools accumulates results as it processes each element in the list. It builds sublists by appending elements unless a certain condition is met, in which case a new sublist is started. After processing the entire list, empty sublists are removed.

from functools import reduce

a = [1, 4, 5, 6, 4, 5, 6, 5, 4]
b = 4

def accumulate(acc, x):
    if x == b:
        acc.append([])
    else:
        acc[-1].append(x)
    return acc

res = reduce(accumulate, a, [[]])

# Remove empty sublists
res = [lst for lst in res if lst]

print(res)

[[1], [5, 6], [5, 6, 5]]

Explanation: reduce(accumulate, a, [[]]) processes the list a, starting with an empty sublist. The accumulate function creates new sublists whenever x equals b and adds elements to the last sublist when x is not b. The reduce function splits the list at each occurrence of b and a list comprehension removes any empty sublists created at the start or end.