리스트를 어떻게 고른 크기의 덩어리로 나누나요?

나는 임의의 길이의 목록을 가지고 있으며, 그것을 동일한 크기의 덩어리로 나누고 작동해야합니다. 카운터와 두 개의 목록을 유지하는 것과 같은 명백한 방법이 있습니다. 두 번째 목록이 채워지면 첫 번째 목록에 추가하고 다음 데이터 라운드를 위해 두 번째 목록을 비 웁니다. 그러나 이것은 잠재적으로 매우 비쌉니다.

누구든지 길이가 긴 목록 (예 : 생성기 사용)에 대해 이것에 대한 좋은 해결책이 있는지 궁금합니다.

유용한 무언가를 찾고 itertools있었지만 분명히 유용한 것을 찾을 수 없었습니다. 그래도 놓쳤을 수도 있습니다.

관련 질문 : 청크 목록을 반복하는 가장 "파이썬"방법은 무엇입니까?

다음은 원하는 청크를 생성하는 생성기입니다.

def chunks(lst, n):
    """Yield successive n-sized chunks from lst."""
    for i in range(0, len(lst), n):
        yield lst[i:i + n]

import pprint
pprint.pprint(list(chunks(range(10, 75), 10)))
[[10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
 [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
 [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
 [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
 [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
 [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
 [70, 71, 72, 73, 74]]

Python 2를 사용 xrange()하는 경우 대신 다음을 사용해야 합니다 range().

def chunks(lst, n):
    """Yield successive n-sized chunks from lst."""
    for i in xrange(0, len(lst), n):
        yield lst[i:i + n]

또한 함수를 작성하는 대신 간단히 목록 이해를 사용할 수 있지만 코드를 이해하기 쉽도록 명명 된 함수에 이와 같은 연산을 캡슐화하는 것이 좋습니다. 파이썬 3 :

[lst[i:i + n] for i in range(0, len(lst), n)]

파이썬 2 버전 :

[lst[i:i + n] for i in xrange(0, len(lst), n)]

아주 간단한 것을 원한다면 :

def chunks(l, n):
    n = max(1, n)
    return (l[i:i+n] for i in range(0, len(l), n))

Python 2.x의 경우 xrange()대신 사용range()

(구) 파이썬 문서 (itertools에 대한 레시피)에서 직접 :

from itertools import izip, chain, repeat

def grouper(n, iterable, padvalue=None):
    "grouper(3, 'abcdefg', 'x') --> ('a','b','c'), ('d','e','f'), ('g','x','x')"
    return izip(*[chain(iterable, repeat(padvalue, n-1))]*n)

JFSebastian이 제안한 현재 버전 :

#from itertools import izip_longest as zip_longest # for Python 2.x
from itertools import zip_longest # for Python 3.x
#from six.moves import zip_longest # for both (uses the six compat library)

def grouper(n, iterable, padvalue=None):
    "grouper(3, 'abcdefg', 'x') --> ('a','b','c'), ('d','e','f'), ('g','x','x')"
    return zip_longest(*[iter(iterable)]*n, fillvalue=padvalue)

귀도의 타임머신 작업 (작동했거나 작동했을 것임)이 다시 작동 한 것 같습니다.

이러한 솔루션 은 목록에서 반복되는 하나의 반복자를 [iter(iterable)]*n작성 하기 때문에 작동합니다 (또는 이전 버전과 동일) . 그런 다음 효과적으로 "각"반복자의 라운드 로빈을 수행합니다. 이것은 동일한 반복자이므로 각 호출에 의해 진행되어 이러한 zip-roundrobin이 하나의 튜플 항목을 생성 합니다.nizip_longestn

나는 이것이 오래되었지만 아무도 언급하지 않았다는 것을 알고있다 numpy.array_split.

import numpy as np

lst = range(50)
np.array_split(lst, 5)
# [array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
#  array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19]),
#  array([20, 21, 22, 23, 24, 25, 26, 27, 28, 29]),
#  array([30, 31, 32, 33, 34, 35, 36, 37, 38, 39]),
#  array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49])]

나는 놀랄 아무도 사용하여 생각하지 않았다이야 iter이야 ' 2 개의 인수를 양식 :

from itertools import islice

def chunk(it, size):
    it = iter(it)
    return iter(lambda: tuple(islice(it, size)), ())

데모:

>>> list(chunk(range(14), 3))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13)]

이것은 모든 iterable과 작동하며 느리게 출력됩니다. 반복자보다는 튜플을 반환하지만 그럼에도 불구하고 특정 우아함이 있다고 생각합니다. 또한 패드가 없습니다. 패딩을 원한다면 위의 간단한 변형으로 충분합니다.

from itertools import islice, chain, repeat

def chunk_pad(it, size, padval=None):
    it = chain(iter(it), repeat(padval))
    return iter(lambda: tuple(islice(it, size)), (padval,) * size)

데모:

>>> list(chunk_pad(range(14), 3))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, None)]
>>> list(chunk_pad(range(14), 3, 'a'))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, 'a')]

izip_longest기반 솔루션 과 마찬가지로 위의 내용은 항상 채워집니다. 내가 아는 한, 선택적으로 패딩 하는 함수에 대한 한 줄 또는 두 줄의 itertools 레시피는 없습니다 . 위의 두 가지 접근 방식을 결합하면이 접근 방식이 매우 가깝습니다.

_no_padding = object()

def chunk(it, size, padval=_no_padding):
    if padval == _no_padding:
        it = iter(it)
        sentinel = ()
    else:
        it = chain(iter(it), repeat(padval))
        sentinel = (padval,) * size
    return iter(lambda: tuple(islice(it, size)), sentinel)

데모:

>>> list(chunk(range(14), 3))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13)]
>>> list(chunk(range(14), 3, None))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, None)]
>>> list(chunk(range(14), 3, 'a'))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, 'a')]

나는 이것이 선택적 패딩을 제공하는 가장 짧은 청커 제안이라고 생각합니다.

Tomasz Gandor가 관찰 한 바와 같이 , 2 개의 패딩 청커는 긴 일련의 패드 값을 만나면 예기치 않게 멈출 것입니다. 다음은 합리적으로 해당 문제를 해결하는 최종 변형입니다.

_no_padding = object()
def chunk(it, size, padval=_no_padding):
    it = iter(it)
    chunker = iter(lambda: tuple(islice(it, size)), ())
    if padval == _no_padding:
        yield from chunker
    else:
        for ch in chunker:
            yield ch if len(ch) == size else ch + (padval,) * (size - len(ch))

데모:

>>> list(chunk([1, 2, (), (), 5], 2))
[(1, 2), ((), ()), (5,)]
>>> list(chunk([1, 2, None, None, 5], 2, None))
[(1, 2), (None, None), (5, None)]

다음은 임의의 이터 러블에서 작동하는 생성기입니다.

def split_seq(iterable, size):
    it = iter(iterable)
    item = list(itertools.islice(it, size))
    while item:
        yield item
        item = list(itertools.islice(it, size))

예:

>>> import pprint
>>> pprint.pprint(list(split_seq(xrange(75), 10)))
[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
 [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
 [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
 [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
 [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
 [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
 [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
 [70, 71, 72, 73, 74]]

def chunk(input, size):
    return map(None, *([iter(input)] * size))

단순하면서도 우아함

l = range(1, 1000)
print [l[x:x+10] for x in xrange(0, len(l), 10)]

또는 원하는 경우 :

def chunks(l, n): return [l[x: x+n] for x in xrange(0, len(l), n)]
chunks(l, 10)

다른 답변에 대한 비판 :

이 답변 중 어느 것도 고른 크기의 청크가 아니며 끝 부분에 런트 청크가 남으므로 완전히 균형이 맞지 않습니다. 이러한 기능을 사용하여 작업을 배포하는 경우 다른 작업보다 먼저 마무리 작업이 완료 될 수 있으므로 다른 작업을 계속하는 동안 아무 작업도 수행하지 않아도됩니다.

예를 들어, 현재 최상위 답변은 다음과 같이 끝납니다.

[60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
[70, 71, 72, 73, 74]]

나는 결국 그 런트를 싫어한다!

다른 사람 같은 list(grouper(3, xrange(7))), 그리고 chunk(xrange(7), 3)모두 반환 : [(0, 1, 2), (3, 4, 5), (6, None, None)]. 의 None의견은 단지 패딩이며 오히려 우아하지 않습니다. 그들은 iterables를 고르게 청크하지 않습니다.

왜 더 잘 나눌 수 없습니까?

내 솔루션

여기에 내가 (교체 파이썬 3 주 생산에 사용했던 함수에서 적응 균형 잡힌 솔루션의 xrange와 함께 range) :

def baskets_from(items, maxbaskets=25):
    baskets = [[] for _ in xrange(maxbaskets)] # in Python 3 use range
    for i, item in enumerate(items):
        baskets[i % maxbaskets].append(item)
    return filter(None, baskets) 

그리고 목록에 넣으면 똑같은 발전기를 만들었습니다.

def iter_baskets_from(items, maxbaskets=3):
    '''generates evenly balanced baskets from indexable iterable'''
    item_count = len(items)
    baskets = min(item_count, maxbaskets)
    for x_i in xrange(baskets):
        yield [items[y_i] for y_i in xrange(x_i, item_count, baskets)]

마지막으로 위의 모든 함수가 주어진 순서대로 요소를 연속적인 순서로 반환한다는 것을 알았습니다.

def iter_baskets_contiguous(items, maxbaskets=3, item_count=None):
    '''
    generates balanced baskets from iterable, contiguous contents
    provide item_count if providing a iterator that doesn't support len()
    '''
    item_count = item_count or len(items)
    baskets = min(item_count, maxbaskets)
    items = iter(items)
    floor = item_count // baskets 
    ceiling = floor + 1
    stepdown = item_count % baskets
    for x_i in xrange(baskets):
        length = ceiling if x_i < stepdown else floor
        yield [items.next() for _ in xrange(length)]

산출

테스트하려면 :

print(baskets_from(xrange(6), 8))
print(list(iter_baskets_from(xrange(6), 8)))
print(list(iter_baskets_contiguous(xrange(6), 8)))
print(baskets_from(xrange(22), 8))
print(list(iter_baskets_from(xrange(22), 8)))
print(list(iter_baskets_contiguous(xrange(22), 8)))
print(baskets_from('ABCDEFG', 3))
print(list(iter_baskets_from('ABCDEFG', 3)))
print(list(iter_baskets_contiguous('ABCDEFG', 3)))
print(baskets_from(xrange(26), 5))
print(list(iter_baskets_from(xrange(26), 5)))
print(list(iter_baskets_contiguous(xrange(26), 5)))

출력되는 내용 :

[[0], [1], [2], [3], [4], [5]]
[[0], [1], [2], [3], [4], [5]]
[[0], [1], [2], [3], [4], [5]]
[[0, 8, 16], [1, 9, 17], [2, 10, 18], [3, 11, 19], [4, 12, 20], [5, 13, 21], [6, 14], [7, 15]]
[[0, 8, 16], [1, 9, 17], [2, 10, 18], [3, 11, 19], [4, 12, 20], [5, 13, 21], [6, 14], [7, 15]]
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13, 14], [15, 16, 17], [18, 19], [20, 21]]
[['A', 'D', 'G'], ['B', 'E'], ['C', 'F']]
[['A', 'D', 'G'], ['B', 'E'], ['C', 'F']]
[['A', 'B', 'C'], ['D', 'E'], ['F', 'G']]
[[0, 5, 10, 15, 20, 25], [1, 6, 11, 16, 21], [2, 7, 12, 17, 22], [3, 8, 13, 18, 23], [4, 9, 14, 19, 24]]
[[0, 5, 10, 15, 20, 25], [1, 6, 11, 16, 21], [2, 7, 12, 17, 22], [3, 8, 13, 18, 23], [4, 9, 14, 19, 24]]
[[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20], [21, 22, 23, 24, 25]]

연속 생성기는 다른 두 패턴과 동일한 길이 패턴으로 청크를 제공하지만 항목은 모두 순서대로 나열되며 개별 요소 목록을 분할 할 수있는만큼 균일하게 분할됩니다.

이 질문 의 복제본 에서 가장 멋진 Python-ish 답변을 보았습니다 .

from itertools import zip_longest

a = range(1, 16)
i = iter(a)
r = list(zip_longest(i, i, i))
>>> print(r)
[(1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12), (13, 14, 15)]

모든 n에 대해 n- 튜플을 만들 수 있습니다. 인 경우 a = range(1, 15)결과는 다음과 같습니다.

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

목록이 균등하게 나누어 경우에, 당신은 대체 할 수 zip_longest와 zip달리 삼중가 (13, 14, None)손실 될 것입니다. 파이썬 3이 위에서 사용되었습니다. Python 2의 경우을 사용하십시오 izip_longest.

목록 크기를 알고있는 경우 :

def SplitList(mylist, chunk_size):
    return [mylist[offs:offs+chunk_size] for offs in range(0, len(mylist), chunk_size)]

그렇지 않으면 (반복자) :

def IterChunks(sequence, chunk_size):
    res = []
    for item in sequence:
        res.append(item)
        if len(res) >= chunk_size:
            yield res
            res = []
    if res:
        yield res  # yield the last, incomplete, portion

후자의 경우, 시퀀스에 항상 주어진 크기의 전체 청크 수가 포함되어 있는지 (즉, 불완전한 마지막 청크가 없음) 확신 할 수 있으면보다 아름다운 방식으로 다시 표현할 수 있습니다.

툴들은의 라이브러리는이 partition이것에 대한 기능을 :

from toolz.itertoolz.core import partition

list(partition(2, [1, 2, 3, 4]))
[(1, 2), (3, 4)]

예를 들어 청크 크기가 3 인 경우 다음을 수행 할 수 있습니다.

zip(*[iterable[i::3] for i in range(3)]) 

출처: http://code.activestate.com/recipes/303060-group-a-list-into-sequential-n-tuples/

내 청크 크기가 고정 숫자 일 때 사용할 수 있습니다 (예 : '3'). 변경되지 않습니다.

나는 tzot과 JFSebastian이 제안한 Python doc의 버전을 좋아하지만 두 가지 단점이 있습니다.

• 그것은 명백하지 않다
• 나는 보통 마지막 덩어리에 채우기 값을 원하지 않는다

내 코드에서 이것을 많이 사용하고 있습니다.

from itertools import islice

def chunks(n, iterable):
    iterable = iter(iterable)
    while True:
        yield tuple(islice(iterable, n)) or iterable.next()

업데이트 : 게으른 청크 버전 :

from itertools import chain, islice

def chunks(n, iterable):
   iterable = iter(iterable)
   while True:
       yield chain([next(iterable)], islice(iterable, n-1))

[AA[i:i+SS] for i in range(len(AA))[::SS]]

AA가 배열 인 경우 SS는 청크 크기입니다. 예를 들면 다음과 같습니다.

>>> AA=range(10,21);SS=3
>>> [AA[i:i+SS] for i in range(len(AA))[::SS]]
[[10, 11, 12], [13, 14, 15], [16, 17, 18], [19, 20]]
# or [range(10, 13), range(13, 16), range(16, 19), range(19, 21)] in py3

다른 접근 방식의 성능에 대해 궁금했고 여기에 있습니다.

Python 3.5.1에서 테스트

import time
batch_size = 7
arr_len = 298937

#---------slice-------------

print("\r\nslice")
start = time.time()
arr = [i for i in range(0, arr_len)]
while True:
    if not arr:
        break

    tmp = arr[0:batch_size]
    arr = arr[batch_size:-1]
print(time.time() - start)

#-----------index-----------

print("\r\nindex")
arr = [i for i in range(0, arr_len)]
start = time.time()
for i in range(0, round(len(arr) / batch_size + 1)):
    tmp = arr[batch_size * i : batch_size * (i + 1)]
print(time.time() - start)

#----------batches 1------------

def batch(iterable, n=1):
    l = len(iterable)
    for ndx in range(0, l, n):
        yield iterable[ndx:min(ndx + n, l)]

print("\r\nbatches 1")
arr = [i for i in range(0, arr_len)]
start = time.time()
for x in batch(arr, batch_size):
    tmp = x
print(time.time() - start)

#----------batches 2------------

from itertools import islice, chain

def batch(iterable, size):
    sourceiter = iter(iterable)
    while True:
        batchiter = islice(sourceiter, size)
        yield chain([next(batchiter)], batchiter)


print("\r\nbatches 2")
arr = [i for i in range(0, arr_len)]
start = time.time()
for x in batch(arr, batch_size):
    tmp = x
print(time.time() - start)

#---------chunks-------------
def chunks(l, n):
    """Yield successive n-sized chunks from l."""
    for i in range(0, len(l), n):
        yield l[i:i + n]
print("\r\nchunks")
arr = [i for i in range(0, arr_len)]
start = time.time()
for x in chunks(arr, batch_size):
    tmp = x
print(time.time() - start)

#-----------grouper-----------

from itertools import zip_longest # for Python 3.x
#from six.moves import zip_longest # for both (uses the six compat library)

def grouper(iterable, n, padvalue=None):
    "grouper(3, 'abcdefg', 'x') --> ('a','b','c'), ('d','e','f'), ('g','x','x')"
    return zip_longest(*[iter(iterable)]*n, fillvalue=padvalue)

arr = [i for i in range(0, arr_len)]
print("\r\ngrouper")
start = time.time()
for x in grouper(arr, batch_size):
    tmp = x
print(time.time() - start)

결과 :

slice
31.18285083770752

index
0.02184295654296875

batches 1
0.03503894805908203

batches 2
0.22681021690368652

chunks
0.019841909408569336

grouper
0.006506919860839844

암호:

def split_list(the_list, chunk_size):
    result_list = []
    while the_list:
        result_list.append(the_list[:chunk_size])
        the_list = the_list[chunk_size:]
    return result_list

a_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print split_list(a_list, 3)

결과:

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

라이브러리의 get_chunks기능을 다음 utilspie과 같이 사용할 수도 있습니다 .

>>> from utilspie import iterutils
>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(iterutils.get_chunks(a, 5))
[[1, 2, 3, 4, 5], [6, 7, 8, 9]]

utilspiepip를 통해 설치할 수 있습니다 :

sudo pip install utilspie

면책 조항 : 나는 utilspie library 의 제작자입니다 .

이 시점에서 우리는 재귀 발생기 가 필요하다고 생각합니다 .

파이썬 2에서 :

def chunks(li, n):
    if li == []:
        return
    yield li[:n]
    for e in chunks(li[n:], n):
        yield e

파이썬 3에서 :

def chunks(li, n):
    if li == []:
        return
    yield li[:n]
    yield from chunks(li[n:], n)

또한 대규모 외계인 침공의 경우 장식 된 재귀 생성기 가 유용 할 수 있습니다.

def dec(gen):
    def new_gen(li, n):
        for e in gen(li, n):
            if e == []:
                return
            yield e
    return new_gen

@dec
def chunks(li, n):
    yield li[:n]
    for e in chunks(li[n:], n):
        yield e

Python 3.8의 Assignment Expressions 를 사용하면 꽤 좋아집니다.

import itertools

def batch(iterable, size):
    it = iter(iterable)
    while item := list(itertools.islice(it, size)):
        yield item

이것은 목록뿐만 아니라 임의의 반복 가능에서 작동합니다.

>>> import pprint
>>> pprint.pprint(list(batch(range(75), 10)))
[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
 [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
 [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
 [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
 [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
 [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
 [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
 [70, 71, 72, 73, 74]]

허, 한 줄 버전

In [48]: chunk = lambda ulist, step:  map(lambda i: ulist[i:i+step],  xrange(0, len(ulist), step))

In [49]: chunk(range(1,100), 10)
Out[49]: 
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
 [11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
 [21, 22, 23, 24, 25, 26, 27, 28, 29, 30],
 [31, 32, 33, 34, 35, 36, 37, 38, 39, 40],
 [41, 42, 43, 44, 45, 46, 47, 48, 49, 50],
 [51, 52, 53, 54, 55, 56, 57, 58, 59, 60],
 [61, 62, 63, 64, 65, 66, 67, 68, 69, 70],
 [71, 72, 73, 74, 75, 76, 77, 78, 79, 80],
 [81, 82, 83, 84, 85, 86, 87, 88, 89, 90],
 [91, 92, 93, 94, 95, 96, 97, 98, 99]]

def split_seq(seq, num_pieces):
    start = 0
    for i in xrange(num_pieces):
        stop = start + len(seq[i::num_pieces])
        yield seq[start:stop]
        start = stop

용법:

seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for seq in split_seq(seq, 3):
    print seq

더 명백한 다른 버전.

def chunkList(initialList, chunkSize):
    """
    This function chunks a list into sub lists 
    that have a length equals to chunkSize.

    Example:
    lst = [3, 4, 9, 7, 1, 1, 2, 3]
    print(chunkList(lst, 3)) 
    returns
    [[3, 4, 9], [7, 1, 1], [2, 3]]
    """
    finalList = []
    for i in range(0, len(initialList), chunkSize):
        finalList.append(initialList[i:i+chunkSize])
    return finalList

큰 목록에 좋은 len ()을 호출하지 않으면 :

def splitter(l, n):
    i = 0
    chunk = l[:n]
    while chunk:
        yield chunk
        i += n
        chunk = l[i:i+n]

그리고 이것은 iterables를위한 것입니다 :

def isplitter(l, n):
    l = iter(l)
    chunk = list(islice(l, n))
    while chunk:
        yield chunk
        chunk = list(islice(l, n))

위의 기능적 풍미 :

def isplitter2(l, n):
    return takewhile(bool,
                     (tuple(islice(start, n))
                            for start in repeat(iter(l))))

또는:

def chunks_gen_sentinel(n, seq):
    continuous_slices = imap(islice, repeat(iter(seq)), repeat(0), repeat(n))
    return iter(imap(tuple, continuous_slices).next,())

또는:

def chunks_gen_filter(n, seq):
    continuous_slices = imap(islice, repeat(iter(seq)), repeat(0), repeat(n))
    return takewhile(bool,imap(tuple, continuous_slices))

추가 접근 방식의 목록은 다음과 같습니다.

주어진

import itertools as it
import collections as ct

import more_itertools as mit


iterable = range(11)
n = 3

암호

표준 라이브러리

list(it.zip_longest(*[iter(iterable)] * n))
# [(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, None)]

d = {}
for i, x in enumerate(iterable):
    d.setdefault(i//n, []).append(x)

list(d.values())
# [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]]

dd = ct.defaultdict(list)
for i, x in enumerate(iterable):
    dd[i//n].append(x)

list(dd.values())
# [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]]

more_itertools⁺

list(mit.chunked(iterable, n))
# [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]]

list(mit.sliced(iterable, n))
# [range(0, 3), range(3, 6), range(6, 9), range(9, 11)]

list(mit.grouper(n, iterable))
# [(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, None)]

list(mit.windowed(iterable, len(iterable)//n, step=n))
# [(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, None)]

참고 문헌

• zip_longest( 관련 게시물 , 관련 게시물 )
• setdefault (정렬 된 결과에는 Python 3.6 이상이 필요합니다)
• collections.defaultdict (정렬 된 결과에는 Python 3.6 이상이 필요합니다)
• more_itertools.chunked( 관련 게시 )
• more_itertools.sliced
• more_itertools.grouper( 관련 게시물 )
• more_itertools.windowed(참조 stagger, zip_offset)

_{⁺ itertools 레시피 등 을 구현하는 타사 라이브러리 .> pip install more_itertools}

참조 이 참조를

>>> orange = range(1, 1001)
>>> otuples = list( zip(*[iter(orange)]*10))
>>> print(otuples)
[(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), ... (991, 992, 993, 994, 995, 996, 997, 998, 999, 1000)]
>>> olist = [list(i) for i in otuples]
>>> print(olist)
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ..., [991, 992, 993, 994, 995, 996, 997, 998, 999, 1000]]
>>> 

파이썬 3

여기 모두가 반복자에 대해 이야기하기 때문에. boltons이를위한 완벽한 방법이 iterutils.chunked_iter있습니다.

from boltons import iterutils

list(iterutils.chunked_iter(list(range(50)), 11))

산출:

[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
 [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21],
 [22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32],
 [33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43],
 [44, 45, 46, 47, 48, 49]]

그러나 메모리에 자비를 원하지 않으면 구식을 사용 list하여 처음부터 전체 를 저장할 수 있습니다 iterutils.chunked.

하나 더 솔루션

def make_chunks(data, chunk_size): 
    while data:
        chunk, data = data[:chunk_size], data[chunk_size:]
        yield chunk

>>> for chunk in make_chunks([1, 2, 3, 4, 5, 6, 7], 2):
...     print chunk
... 
[1, 2]
[3, 4]
[5, 6]
[7]
>>> 

def chunks(iterable,n):
    """assumes n is an integer>0
    """
    iterable=iter(iterable)
    while True:
        result=[]
        for i in range(n):
            try:
                a=next(iterable)
            except StopIteration:
                break
            else:
                result.append(a)
        if result:
            yield result
        else:
            break

g1=(i*i for i in range(10))
g2=chunks(g1,3)
print g2
'<generator object chunks at 0x0337B9B8>'
print list(g2)
'[[0, 1, 4], [9, 16, 25], [36, 49, 64], [81]]'

matplotlib.cbook 조각 사용을 고려하십시오

예를 들면 다음과 같습니다.

import matplotlib.cbook as cbook
segments = cbook.pieces(np.arange(20), 3)
for s in segments:
     print s