목록을 더 작은 목록으로 나누기 (반으로 분할)

파이썬 목록을 쉽게 반으로 나눌 수있는 방법을 찾고 있습니다.

그래서 배열이 있다면 :

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

나는 얻을 수있을 것입니다 :

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

기능을 원한다면 :

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)

좀 더 일반적인 해결책 ( '반으로 나누지 않고 원하는 부분 수를 지정할 수 있습니다) :

편집 : 홀수 목록 길이를 처리하도록 게시물이 업데이트되었습니다.

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)

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

n -사전 정의 된 길이의 결과 배열

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

주문에 신경 쓰지 않으면 ...

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

list[::2]0 번째 요소부터 시작하여 목록의 모든 두 번째 요소를 가져옵니다.
list[1::2]목록에서 첫 번째 요소부터 시작하여 매 초마다 요소를 가져옵니다.

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

다음은 일반적인 해결책입니다. arr을 카운트 부분으로 나눕니다.

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)

나는 파이썬 3에서 int 나누기를 강제하기 위해 이중 슬래시가 필요했다. 왜냐하면 원래의 게시물은 wysiwyg가 Opera에서 파단되었지만 어떤 이유로 든 정확했다.

배열을 더 작은 크기의 배열로 분할하는보다 일반적인 경우에 대한 공식적인 파이썬 저장소가 있습니다 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)

이 코드 스 니펫은 python itertools doc 페이지 에서 가져온 것 입니다.

목록 슬라이싱 사용 . 문법은 기본적으로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 of1.5`)로 슬라이스하십시오.

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

.. 그리고 값을 바꾸어 후반부를 얻습니다.

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

큰 목록이 있다면 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 덕분에

10 년 후. 나는 생각했다-왜 다른 것을 추가하지 않는가 :

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

위의 답변은 다소 정확하지만 배열의 크기를 2로 나눌 수 없으면, 결과 a / 2가 이상하고 파이썬 3.0에서는 부동이고 이전 버전에서는 from __future__ import division스크립트 시작 부분에 지정 하십시오. 어떤 경우에도 정수 나누기, 즉 a // 2코드의 "앞으로"호환성을 얻으려면 더 나은 방법 입니다.

이것은 다른 솔루션과 비슷하지만 조금 더 빠릅니다.

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

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

2020 년에이 문제에 대한 또 다른 취지 ... 문제의 일반화가 있습니다. 나는 '리스트를 반으로 나누는 것'을로 해석합니다. (즉, 두 개의 목록 만 있고 홀수 하나 등의 경우 세 번째 배열로의 유출은 없을 것입니다). 예를 들어 배열 길이가 19이고 // 연산자를 사용하여 2로 나누면 9가 주어지면 길이 9의 배열 두 개와 길이 1의 배열 하나 (세 번째)가 생깁니다 (총 3 개의 배열). 일반적인 솔루션으로 항상 두 배열을 제공하려면 길이가 같지 않은 두 배열의 결과에 만족한다고 가정합니다 (하나는 다른 것보다 길다). 그리고 주문이 혼합되어 있다고 가정합니다 (이 경우 대체).

"""
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 행에서 시도했으며 몇 초 안에 끝납니다.

내 두 센트.

감사!