Chia danh sách thành các danh sách nhỏ hơn (chia làm đôi)

Tôi đang tìm cách để dễ dàng chia một danh sách trăn làm đôi.

Vì vậy, nếu tôi có một mảng:

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

Tôi sẽ có thể nhận được:

B = [0,1,2]

C = [3,4,5]

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

Nếu bạn muốn một chức năng:

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)

Một giải pháp chung chung hơn một chút (bạn có thể chỉ định số lượng phần bạn muốn, không chỉ chia 'một nửa'):

EDIT : bài đăng được cập nhật để xử lý độ dài danh sách lẻ

EDIT2 : cập nhật bài viết một lần nữa dựa trên ý kiến ​​thông tin 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)

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

n - độ dài được xác định trước của mảng kết quả

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

Kiểm tra:

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

kết quả:

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

Nếu bạn không quan tâm đến thứ tự ...

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

list[::2]được mọi phần tử thứ hai trong danh sách bắt đầu từ phần tử thứ 0.
list[1::2]được mọi phần tử thứ hai trong danh sách bắt đầu từ phần tử thứ nhất.

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

Đây là một giải pháp phổ biến, chia mảng thành phần đếm

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

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

 return (B,C)

Tôi đã thử nghiệm và dấu gạch chéo kép được yêu cầu để buộc phân chia int trong python 3. Bài viết gốc của tôi là chính xác, mặc dù wysiwyg đã phá vỡ trong Opera, vì một số lý do.

Có một biên nhận Python chính thức cho trường hợp tổng quát hơn là chia một mảng thành các mảng có kích thước nhỏ hơn 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)

Đoạn mã này là từ trang tài liệu itertools python .

Sử dụng danh sách cắt . Cú pháp cơ bản là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]

Để có được nửa đầu của danh sách, bạn cắt từ chỉ mục đầu tiên sang len(i)//2( //phân chia số nguyên - vì vậy 3//2 will give the floored result of1 , instead of the invalid list index of1,5`):

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

..và hoán đổi các giá trị xung quanh để có được nửa thứ hai:

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

Nếu bạn có một danh sách lớn, tốt hơn là sử dụng itertools và viết một hàm để mang lại từng phần khi cần:

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

Bạn có thể sử dụng như thế này:

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

size = len(A) // 2

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

Đầu ra là:

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

Cảm ơn @thefourtheye và @Bede Constantinides

10 năm sau .. tôi nghĩ - tại sao không thêm cái khác:

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

Mặc dù các câu trả lời ở trên ít nhiều đúng, bạn có thể gặp rắc rối nếu kích thước của mảng không chia hết cho 2, do đó a / 2, là một số lẻ, là một số float trong python 3.0 và trong phiên bản trước đó nếu bạn chỉ định from __future__ import divisionở đầu tập lệnh của bạn. Trong mọi trường hợp, tốt hơn hết là bạn nên phân chia số nguyên, nghĩa là a // 2, để có được khả năng tương thích "chuyển tiếp" của mã của bạn.

Điều này tương tự như các giải pháp khác, nhưng nhanh hơn một chút.

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

Với gợi ý từ @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)

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

Một vấn đề khác về vấn đề này vào năm 2020 ... Đây là một khái quát của vấn đề. Tôi diễn giải 'chia một danh sách thành một nửa' thành .. (nghĩa là chỉ có hai danh sách và sẽ không có sự lan tỏa đến mảng thứ ba trong trường hợp có một số lẻ, v.v.). Chẳng hạn, nếu độ dài mảng là 19 và chia cho hai bằng cách sử dụng toán tử // cho 9 và cuối cùng chúng ta sẽ có hai mảng có độ dài 9 và một mảng (thứ ba) có độ dài 1 (trong tổng số ba mảng). Nếu chúng ta muốn một giải pháp chung để cung cấp hai mảng mọi lúc, tôi sẽ cho rằng chúng ta hài lòng với các mảng bộ đôi kết quả không dài bằng nhau (một mảng sẽ dài hơn các mảng khác). Và rằng nó được coi là ok để có thứ tự hỗn hợp (xen kẽ trong trường hợp này).

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

Khái niệm này hoạt động cho bất kỳ số lượng phân vùng danh sách nào bạn muốn (bạn phải điều chỉnh mã tùy thuộc vào số lượng phần danh sách bạn muốn). Và là khá đơn giản để giải thích. Để tăng tốc mọi thứ, bạn thậm chí có thể viết vòng lặp này bằng cython / C / C ++ để tăng tốc mọi thứ. Sau đó, một lần nữa, tôi đã thử mã này trên các danh sách tương đối nhỏ ~ 10.000 hàng và nó kết thúc sau một phần giây.

Chỉ hai xu của tôi.

Cảm ơn!