Question

我正在寻找一种方法来轻松地将python列表分成两半。

如果我有一个数组：

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

我能得到：

B = [0,1,2]

C = [3,4,5]

Answer 1

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

如果你想要一个功能：

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 2

更通用的解决方案（您可以指定所需的部件数量，而不仅仅是分成两半）：

编辑：更新帖子以处理奇数列表长度

EDIT2 ：根据Brians信息性评论再次更新帖子

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 3

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

n - 预定义的结果数组长度

Answer 4

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

测试：

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

结果：

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

Answer 5

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

Answer 6

这是一个常见的解决方案，将arr分成计数部分

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

Answer 7

如果你不关心订单......

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

list[::2]从第0个元素开始获取列表中的每个第二个元素 list[1::2]从第一个元素开始获取列表中的每个第二个元素。

Answer 8

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

 return (B,C)

我测试了，并且需要双斜杠来强制在python 3中进行int划分。我的原始帖子是正确的，尽管wysiwyg因为某种原因在Opera中出现了。

Answer 9

对于将数组拆分为大小为n的较小数组的更一般化情况，有一个官方的Python接收。

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)

此代码段来自python itertools doc page。

Answer 10

使用list slicing。语法基本上是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]

要获得列表的前半部分，您可以从第一个索引切换到len(i)//2（其中//是整数除法 - 所以3//2 will give the floored result of 1 , instead of the invalid list index of 1.5 ）：

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

..并交换周围的值以获得下半场：

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

Answer 11

虽然上面的答案或多或少都是正确的，但如果数组的大小不能被2整除，则可能会遇到麻烦，因为a / 2的结果是奇数，是python中的一个浮点数3.0，如果您在脚本开头指定from __future__ import division，则在早期版本中。在任何情况下，你都可以更好地进行整数除法，即a // 2，以获得代码的“前向”兼容性。

Answer 12

如果列表很大，最好使用 itertools 并编写一个函数以根据需要生成每个部分：

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)]

您可以这样使用：

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

size = len(A) // 2

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

输出为：

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

感谢@thefourtheye和@Bede Constantinides

Answer 13

10年后。.我想-为什么不添加另一个：

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

Answer 14

这与其他解决方案类似，但速度要快一些。

# 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 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

在2020年再次解决这个问题...这是问题的概括。我将“将列表分成两半”解释为..（即仅两个列表，并且如果出现奇数等，则不会溢出到第三数组）。例如，如果数组长度为19，并使用//运算符将其除以2，则结果为9，我们最终将得到两个长度为9的数组和一个长度为1的数组（第三个）（因此总共有三个数组）。如果我们想要一个通用的解决方案一直提供两个数组，那么我会假设我们对结果长度不相等的二重奏数组感到满意（一个长于另一个长）。并且假定可以混合顺序（在这种情况下为交替）是可以的。

"""
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

此概念适用于任意数量的列表分区（您必须根据所需的列表部分数量来调整代码）。并且很容易解释。为了加快速度，您甚至可以在cython / C / C ++中编写此循环以加快速度。再说一次，我已经在相对较小的列表（约10,000行）上尝试了此代码，并且在不到一秒的时间内完成了代码。

我只有两美分。

谢谢！

Answer 17

通用解决方案将列表拆分为 n 个部分并进行参数验证：

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

将列表拆分为较小的列表（分成两半）

17 个答案: