Split list into smaller lists (split in half)

Question

I am looking for a way to easily split a python list in half.

So that if I have an array:

A = [0,1,2,3,4,5]

I would be able to get:

B = [0,1,2]

C = [3,4,5]

Answer 1

Taken from GeeksForGeeks, in my opinion better than anything else so far if you don't mind numpy:

import numpy as np

a = [1, 2, 3, 4, 5, 6]

# Creates two sub-arrays, dividing the list evenly
split_lst = np.array_split(a, 2)

# Assign the first half to x
x = split_lst[0]

# Assign the second half to y
y = split_lst[1]

print(x)
print(y)

# Convert back to list if you want 
x = x.tolist()

Answer 2

def splitList(lst,lgh):
    return [lst[y*lgh:lgh*(y+1)] for y in range(-(len(lst)//-lgh))]

Example:

>>> def splitList(list,lgh):
...     return [lst[y*lgh:lgh*(y+1)] for y in range(-(len(lst)//-lgh))]
... 
>>> x=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
>>> splitList(x,3)
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13]]
>>> splitList(x,len(x)//2)
[[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12], [13]]

Answer 3

If you have Python 3.12 use batched:

from itertools import batched
array = [1,2,3,4,5,6,7,8,9,0]
chunks = batched(array, len(array)/2 + 1) 

This splits the array into chunks of specified size ( which is much more common operation that splitting into two pars).

Answer 4

You can try something like this with numpy

import numpy as np
np.array_split([1,2,3,4,6,7,8], 2)

result:

[array([1, 2, 3, 4]), array([6, 7, 8])]

Answer 5

Since there was no restriction put on which package we can use.. Numpy has a function called split with which you can easily split an array any way you like.

Example

import numpy as np
A = np.array(list('abcdefg'))
np.split(A, 2)

Answer 6

A little more generic solution (you can specify the number of parts you want, not just split 'in half'):

def split_list(alist, wanted_parts=1):
    length = len(alist)
    return [ alist[i*length // wanted_parts: (i+1)*length // wanted_parts] 
             for i in range(wanted_parts) ]

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

print split_list(A, wanted_parts=1)
print split_list(A, wanted_parts=2)
print split_list(A, wanted_parts=8)

Answer 7

from itertools import islice 

Input = [2, 5, 3, 4, 8, 9, 1] 
small_list_length = [1, 2, 3, 1] 

Input1 = iter(Input) 

Result = [list(islice(Input1, elem)) for elem in small_list_length] 

print("Input list :", Input) 

print("Split length list: ", small_list_length) 

print("List after splitting", Result)

Answer 8

General solution split list into n parts with parameter verification:

def sp(l,n):
    # split list l into n parts 
    if l: 
        p = len(l) if n < 1 else len(l) // n   # no split
        p = p if p > 0 else 1                  # split down to elements
        for i in range(0, len(l), p):
            yield l[i:i+p]
    else:
        yield [] # empty list split returns empty list

Answer 9

Another take on this problem in 2020 ... Here's a generalization of the problem. I interpret the 'divide a list in half' to be .. (i.e. two lists only and there shall be no spillover to a third array in case of an odd one out etc). For instance, if the array length is 19 and a division by two using // operator gives 9, and we will end up having two arrays of length 9 and one array (third) of length 1 (so in total three arrays). If we'd want a general solution to give two arrays all the time, I will assume that we are happy with resulting duo arrays that are not equal in length (one will be longer than the other). And that its assumed to be ok to have the order mixed (alternating in this case).

"""
arrayinput --> is an array of length N that you wish to split 2 times
"""
ctr = 1 # lets initialize a counter

holder_1 = []
holder_2 = []

for i in range(len(arrayinput)): 

    if ctr == 1 :
        holder_1.append(arrayinput[i])
    elif ctr == 2: 
        holder_2.append(arrayinput[i])

    ctr += 1 

    if ctr > 2 : # if it exceeds 2 then we reset 
        ctr = 1 

This concept works for any amount of list partition as you'd like (you'd have to tweak the code depending on how many list parts you want). And is rather straightforward to interpret. To speed things up , you can even write this loop in cython / C / C++ to speed things up. Then again, I've tried this code on relatively small lists ~ 10,000 rows and it finishes in a fraction of second.

Just my two cents.

Thanks!

Answer 10

Using list slicing. The syntax is basically my_list[start_index:end_index]

>>> i = [0,1,2,3,4,5]
>>> i[:3] # same as i[0:3] - grabs from first to third index (0->2)
[0, 1, 2]
>>> i[3:] # same as i[3:len(i)] - grabs from fourth index to end
[3, 4, 5]

To get the first half of the list, you slice from the first index to len(i)//2 (where // is the integer division - so 3//2 will give the floored result of1, instead of the invalid list index of1.5`):

>>> i[:len(i)//2]
[0, 1, 2]

..and the swap the values around to get the second half:

>>> i[len(i)//2:]
[3, 4, 5]

Answer 11

10 years later.. I thought - why not add another:

arr = 'Some random string' * 10; n = 4
print([arr[e:e+n] for e in range(0,len(arr),n)])

Answer 12

If you have a big list, It's better to use itertools and write a function to yield each part as needed:

from itertools import islice

def make_chunks(data, SIZE):
    it = iter(data)
    # use `xragne` if you are in python 2.7:
    for i in range(0, len(data), SIZE):
        yield [k for k in islice(it, SIZE)]

You can use this like:

A = [0, 1, 2, 3, 4, 5, 6]

size = len(A) // 2

for sample in make_chunks(A, size):
    print(sample)

The output is:

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

Thanks to @thefourtheye and @Bede Constantinides

Answer 13

A = [1,2,3,4,5,6]
B = A[:len(A)//2]
C = A[len(A)//2:]

If you want a function:

def split_list(a_list):
    half = len(a_list)//2
    return a_list[:half], a_list[half:]

A = [1,2,3,4,5,6]
B, C = split_list(A)

Answer 14

def split(arr, size):
     arrs = []
     while len(arr) > size:
         pice = arr[:size]
         arrs.append(pice)
         arr   = arr[size:]
     arrs.append(arr)
     return arrs

Test:

x=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
print(split(x, 5))

result:

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

Answer 15

#for python 3
    A = [0,1,2,3,4,5]
    l = len(A)/2
    B = A[:int(l)]
    C = A[int(l):]       

Answer 16

If you don't care about the order...

def split(list):  
    return list[::2], list[1::2]

list[::2] gets every second element in the list starting from the 0th element.
list[1::2] gets every second element in the list starting from the 1st element.

Answer 17

This is similar to other solutions, but a little faster.

# Usage: split_half([1,2,3,4,5]) Result: ([1, 2], [3, 4, 5])

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

Answer 18

f = lambda A, n=3: [A[i:i+n] for i in range(0, len(A), n)]
f(A)

n - the predefined length of result arrays

Answer 19

There is an official Python receipe for the more generalized case of splitting an array into smaller arrays of size n.

from itertools import izip_longest
def grouper(n, iterable, fillvalue=None):
    "Collect data into fixed-length chunks or blocks"
    # grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

This code snippet is from the python itertools doc page.

Answer 20

With hints from @ChristopheD

def line_split(N, K=1):
    length = len(N)
    return [N[i*length/K:(i+1)*length/K] for i in range(K)]

A = [0,1,2,3,4,5,6,7,8,9]
print line_split(A,1)
print line_split(A,2)

Answer 21

Here is a common solution, split arr into count part

def split(arr, count):
     return [arr[i::count] for i in range(count)]

Answer 22

While the answers above are more or less correct, you may run into trouble if the size of your array isn't divisible by 2, as the result of a / 2, a being odd, is a float in python 3.0, and in earlier version if you specify from __future__ import division at the beginning of your script. You are in any case better off going for integer division, i.e. a // 2, in order to get "forward" compatibility of your code.

Answer 23

def splitter(A):
    B = A[0:len(A)//2]
    C = A[len(A)//2:]

 return (B,C)

I tested, and the double slash is required to force int division in python 3. My original post was correct, although wysiwyg broke in Opera, for some reason.

Answer 24

B,C=A[:len(A)/2],A[len(A)/2:]