我有一个任意长度的列表，我需要将它分成大小相等的块并对其进行操作。有一些明显的方法可以做到这一点，比如保留一个计数器和两个列表，当第二个列表填满时，将其添加到第一个列表中，并为下一轮数据清空第二个列表，但这可能非常昂贵。
我想知道是否有人对任何长度的列表有一个很好的解决方案，例如使用生成器。
我一直在寻找有用的东西，itertools但找不到任何明显有用的东西。不过可能错过了。
jespern
问问题
1352373 次
69 回答
4018
这是一个产生你想要的块的生成器：
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)]
Python 2 版本：
[lst[i:i + n] for i in xrange(0, len(lst), n)]
于 2008-11-23T12:33:53.433 回答
635
如果你想要一些超级简单的东西：
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()
于 2009-11-17T20:17:16.617 回答
355
我知道这有点老了，但还没有人提到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])]
于 2013-06-05T08:54:26.183 回答
336
直接来自（旧）Python 文档（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)
我猜Guido 的时间机器工作——工作——将工作——将工作——又工作了。
这些解决方案之所以有效，是因为[iter(iterable)]*n（或早期版本中的等效方案）创建了一个迭代器，n在列表中重复了多次。izip_longest然后有效地执行“每个”迭代器的循环；因为这是同一个迭代器，所以每次这样的调用都会推进它，导致每个这样的 zip-roundrobin 生成一个n项目元组。
于 2008-11-23T15:48:53.540 回答
254
我很惊讶没有人想到使用iter's 的两个参数形式：
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)]
这适用于任何可迭代对象并延迟生成输出。它返回元组而不是迭代器，但我认为它仍然具有一定的优雅性。它也不垫；如果你想要填充，上面的简单变化就足够了：
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 所观察到的，如果两个填充分块器遇到一长串填充值，它们将意外停止。这是以合理方式解决该问题的最终变体：
_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)]
于 2014-02-26T15:02:00.293 回答
114
这是一个适用于任意迭代的生成器：
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]]
于 2008-11-23T12:41:37.317 回答
78
简单而不失优雅
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)
于 2010-07-12T07:58:43.420 回答
65
def chunk(input, size):
return map(None, *([iter(input)] * size))
于 2010-06-26T19:10:07.963 回答
57
你如何将列表分成大小均匀的块？
对我来说，“大小均匀的块”意味着它们的长度都相同，或者除非该选项，否则它们的长度差异最小。例如，21 个项目的 5 个篮子可能会产生以下结果：
>>> import statistics
>>> statistics.variance([5,5,5,5,1])
3.2
>>> statistics.variance([5,4,4,4,4])
0.19999999999999998
更喜欢后一种结果的一个实际原因是：如果您使用这些功能来分配工作，那么您已经内置了一个可能在其他人之前完成的前景，因此它会在其他人继续努力工作时无所事事。
在这里批评其他答案
当我最初写这个答案时，其他答案都不是大小均匀的块 - 它们最后都留下了一个小块，所以它们没有很好的平衡，并且具有高于必要的长度差异。
例如，当前的最佳答案以：
[60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
[70, 71, 72, 73, 74]]
其他人，喜欢list(grouper(3, range(7)))，并且chunk(range(7), 3)都返回：[(0, 1, 2), (3, 4, 5), (6, None, None)]。' Nones 只是填充，在我看来相当不雅。他们没有均匀地分块迭代。
为什么我们不能更好地划分这些？
循环解决方案
使用 的高级平衡解决方案itertools.cycle，这就是我今天可能会这样做的方式。这是设置：
from itertools import cycle
items = range(10, 75)
number_of_baskets = 10
现在我们需要我们的列表来填充元素：
baskets = [[] for _ in range(number_of_baskets)]
最后，我们将要分配的元素与篮子循环一起压缩，直到我们用完元素，从语义上讲，这正是我们想要的：
for element, basket in zip(items, cycle(baskets)):
basket.append(element)
结果如下：
>>> from pprint import pprint
>>> pprint(baskets)
[[10, 20, 30, 40, 50, 60, 70],
[11, 21, 31, 41, 51, 61, 71],
[12, 22, 32, 42, 52, 62, 72],
[13, 23, 33, 43, 53, 63, 73],
[14, 24, 34, 44, 54, 64, 74],
[15, 25, 35, 45, 55, 65],
[16, 26, 36, 46, 56, 66],
[17, 27, 37, 47, 57, 67],
[18, 28, 38, 48, 58, 68],
[19, 29, 39, 49, 59, 69]]
为了生产这个解决方案，我们编写了一个函数，并提供类型注释：
from itertools import cycle
from typing import List, Any
def cycle_baskets(items: List[Any], maxbaskets: int) -> List[List[Any]]:
baskets = [[] for _ in range(min(maxbaskets, len(items)))]
for item, basket in zip(items, cycle(baskets)):
basket.append(item)
return baskets
在上面，我们获取了我们的项目列表，以及篮子的最大数量。我们创建一个空列表列表，以循环方式在其中附加每个元素。
切片
另一个优雅的解决方案是使用切片 - 特别是切片的不太常用的step参数。IE：
start = 0
stop = None
step = number_of_baskets
first_basket = items[start:stop:step]
这特别优雅，因为切片不关心数据的长度——结果，我们的第一个篮子，只要它需要的长度。我们只需要增加每个篮子的起点。
事实上，这可能是单行代码，但我们将使用多行代码以提高可读性并避免代码行过长：
from typing import List, Any
def slice_baskets(items: List[Any], maxbaskets: int) -> List[List[Any]]:
n_baskets = min(maxbaskets, len(items))
return [items[i::n_baskets] for i in range(n_baskets)]
并且islice从 itertools 模块将提供一种惰性迭代方法，就像问题中最初要求的那样。
我不认为大多数用例会受益匪浅，因为原始数据已经完全物化在列表中，但对于大型数据集，它可以节省近一半的内存使用量。
from itertools import islice
from typing import List, Any, Generator
def yield_islice_baskets(items: List[Any], maxbaskets: int) -> Generator[List[Any], None, None]:
n_baskets = min(maxbaskets, len(items))
for i in range(n_baskets):
yield islice(items, i, None, n_baskets)
查看结果：
from pprint import pprint
items = list(range(10, 75))
pprint(cycle_baskets(items, 10))
pprint(slice_baskets(items, 10))
pprint([list(s) for s in yield_islice_baskets(items, 10)])
更新了先前的解决方案
这是另一个平衡的解决方案，改编自我过去在生产中使用的一个函数，它使用了模运算符：
def baskets_from(items, maxbaskets=25):
baskets = [[] for _ in range(maxbaskets)]
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 range(baskets):
yield [items[y_i] for y_i in range(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 range(baskets):
length = ceiling if x_i < stepdown else floor
yield [items.next() for _ in range(length)]
输出
要测试它们：
print(baskets_from(range(6), 8))
print(list(iter_baskets_from(range(6), 8)))
print(list(iter_baskets_contiguous(range(6), 8)))
print(baskets_from(range(22), 8))
print(list(iter_baskets_from(range(22), 8)))
print(list(iter_baskets_contiguous(range(22), 8)))
print(baskets_from('ABCDEFG', 3))
print(list(iter_baskets_from('ABCDEFG', 3)))
print(list(iter_baskets_contiguous('ABCDEFG', 3)))
print(baskets_from(range(26), 5))
print(list(iter_baskets_from(range(26), 5)))
print(list(iter_baskets_contiguous(range(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]]
请注意，连续生成器以与其他两个相同的长度模式提供块，但项目都是有序的，并且它们被均匀划分，就像一个可以划分离散元素的列表一样。
于 2014-02-13T23:07:17.073 回答
53
如果您知道列表大小：
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
在后一种情况下，如果您可以确定序列始终包含给定大小的整数块（即没有不完整的最后一个块），则可以以更漂亮的方式对其进行改写。
于 2008-11-23T12:40:39.830 回答
51
我在这个问题的副本中看到了最棒的 Python 式答案：
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)将丢失。上面使用了 Python 3。对于 Python 2，使用izip_longest.
于 2015-03-12T12:36:10.303 回答
37
[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
要扩展 py3 中的范围，请执行
(py3) >>> [list(AA[i:i+SS]) for i in range(len(AA))[::SS]]
[[10, 11, 12], [13, 14, 15], [16, 17, 18], [19, 20]]
于 2015-12-16T21:42:56.703 回答
36
不要重新发明轮子。
给定
import itertools as it
import collections as ct
import more_itertools as mit
iterable = range(11)
n = 3
代码
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)]
list(mit.chunked_even(iterable, n))
# [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]]
（或DIY，如果你愿意）
标准库
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.chunked（相关贴）more_itertools.slicedmore_itertools.grouper（相关帖子）more_itertools.windowed（另见stagger，zip_offset）more_itertools.chunked_evenzip_longest（相关职位，相关职位）setdefault（排序结果需要 Python 3.6+）collections.defaultdict（排序结果需要 Python 3.6+）
+实现itertools 配方等的第三方库。> pip install more_itertools
于 2018-08-26T01:40:11.330 回答
28
例如，如果您的块大小为 3，则可以执行以下操作：
zip(*[iterable[i::3] for i in range(3)])
来源： http ://code.activestate.com/recipes/303060-group-a-list-into-sequential-n-tuples/
当我的块大小是我可以输入的固定数字时，我会使用它，例如“3”，并且永远不会改变。
于 2011-04-19T05:27:19.640 回答
27
toolz库具有以下功能partition：
from toolz.itertoolz.core import partition
list(partition(2, [1, 2, 3, 4]))
[(1, 2), (3, 4)]
于 2013-11-20T20:55:22.177 回答
26
使用Python 3.8 中的赋值表达式，它变得非常好：
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]]
于 2019-12-10T11:59:57.977 回答
23
我对不同方法的性能很好奇，这里是：
在 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
于 2018-01-07T08:58:54.647 回答
21
我非常喜欢 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))
于 2013-10-09T06:17:29.367 回答
20
您还可以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]]
您可以utilspie通过 pip 安装：
sudo pip install utilspie
免责声明：我是utilspie library的创建者。
于 2017-01-27T23:12:07.890 回答
18
代码：
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]]
于 2015-07-02T07:32:49.237 回答
15
在这一点上，我认为我们需要一个递归生成器，以防万一......
在python 2中：
def chunks(li, n):
if li == []:
return
yield li[:n]
for e in chunks(li[n:], n):
yield e
在python 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
于 2015-11-03T23:10:50.297 回答
13
呵呵，一行版本
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]]
于 2008-11-23T12:51:16.863 回答
13
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
于 2008-11-24T16:56:57.067 回答
12
不调用 len() 这对大型列表有好处：
def splitter(l, n):
i = 0
chunk = l[:n]
while chunk:
yield chunk
i += n
chunk = l[i:i+n]
这是针对可迭代的：
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))
于 2010-02-16T05:49:47.980 回答
12
另一个更明确的版本。
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
于 2015-02-28T20:05:03.317 回答
11
请参阅此参考
>>> 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]]
>>>
Python3
于 2013-02-18T13:31:51.440 回答
10
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]]'
于 2012-02-13T04:50:38.350 回答
10
因为这里的每个人都在谈论迭代器。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.
于 2016-11-03T19:10:45.350 回答
9
考虑使用matplotlib.cbook片段
例如：
import matplotlib.cbook as cbook
segments = cbook.pieces(np.arange(20), 3)
for s in segments:
print s
于 2011-05-03T16:27:37.780 回答
7
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
CHUNK = 4
[a[i*CHUNK:(i+1)*CHUNK] for i in xrange((len(a) + CHUNK - 1) / CHUNK )]
于 2015-07-15T23:27:19.153 回答
6
另一种解决方案
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]
>>>
于 2017-04-17T15:38:56.040 回答
5
>>> def f(x, n, acc=[]): return f(x[n:], n, acc+[(x[:n])]) if x else acc
>>> f("Hallo Welt", 3)
['Hal', 'lo ', 'Wel', 't']
>>>
如果你在括号中 - 我拿起一本关于 Erlang 的书 :)
于 2009-11-03T16:45:31.877 回答
5
我意识到这个问题很老（在谷歌上偶然发现），但肯定比任何巨大的复杂建议更简单、更清晰，并且只使用切片：
def chunker(iterable, chunksize):
for i,c in enumerate(iterable[::chunksize]):
yield iterable[i*chunksize:(i+1)*chunksize]
>>> for chunk in chunker(range(0,100), 10):
... print list(chunk)
...
[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]
... etc ...
于 2012-08-27T22:58:05.640 回答
5
根据这个答案，票数最高的答案最后会留下一个“矮子”。这是我的解决方案，可以真正获得尽可能均匀大小的块，没有矮子。它基本上试图准确地选择应该拆分列表的小数点，但只是将其四舍五入到最接近的整数：
from __future__ import division # not needed in Python 3
def n_even_chunks(l, n):
"""Yield n as even chunks as possible from l."""
last = 0
for i in range(1, n+1):
cur = int(round(i * (len(l) / n)))
yield l[last:cur]
last = cur
示范：
>>> pprint.pprint(list(n_even_chunks(list(range(100)), 9)))
[[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, 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]]
>>> pprint.pprint(list(n_even_chunks(list(range(100)), 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, 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]]
与投票最多的chunks答案进行比较：
>>> pprint.pprint(list(chunks(list(range(100)), 100//9)))
[[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, 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]]
>>> pprint.pprint(list(chunks(list(range(100)), 100//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, 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]]
于 2016-08-06T20:44:07.587 回答
5
您可以使用 numpy 的 array_split 函数，例如，np.array_split(np.array(data), 20)分成 20 个几乎相等大小的块。
为了确保块的大小完全相等，请使用np.split.
于 2016-11-20T04:32:29.887 回答
5
我想我没有看到这个选项，所以只是添加另一个:))：
def chunks(iterable, chunk_size):
i = 0;
while i < len(iterable):
yield iterable[i:i+chunk_size]
i += chunk_size
于 2017-11-03T12:38:56.040 回答
5
pythonpydash包可能是一个不错的选择。
from pydash.arrays import chunk
ids = ['22', '89', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '1']
chunk_ids = chunk(ids,5)
print(chunk_ids)
# output: [['22', '89', '2', '3', '4'], ['5', '6', '7', '8', '9'], ['10', '11', '1']]
更多结帐pydash 块列表
于 2019-07-09T14:04:12.397 回答
4
def chunk(lst):
out = []
for x in xrange(2, len(lst) + 1):
if not len(lst) % x:
factor = len(lst) / x
break
while lst:
out.append([lst.pop(0) for x in xrange(factor)])
return out
于 2008-11-26T07:24:49.110 回答
4
让 r 是块大小， L 是初始列表，你可以这样做。
chunkL = [ [i for i in L[r*k:r*(k+1)] ] for k in range(len(L)/r)]
于 2014-12-09T03:54:49.717 回答
4
使用列表推导：
l = [1,2,3,4,5,6,7,8,9,10,11,12]
k = 5 #chunk size
print [tuple(l[x:y]) for (x, y) in [(x, x+k) for x in range(0, len(l), k)]]
于 2015-02-27T02:33:35.490 回答
4
在这一点上，我认为我们需要强制匿名递归函数。
Y = lambda f: (lambda x: x(x))(lambda y: f(lambda *args: y(y)(*args)))
chunks = Y(lambda f: lambda n: [n[0][:n[1]]] + f((n[0][n[1]:], n[1])) if len(n[0]) > 0 else [])
于 2015-11-04T09:12:27.593 回答
4
我在下面有一个解决方案确实有效，但比该解决方案更重要的是对其他方法的一些评论。首先，一个好的解决方案不应该要求一个按顺序遍历子迭代器的循环。如果我跑
g = paged_iter(list(range(50)), 11))
i0 = next(g)
i1 = next(g)
list(i1)
list(i0)
最后一个命令的适当输出是
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
不是
[]
由于这里大多数基于 itertools 的解决方案都返回了。这不仅仅是按顺序访问迭代器的常见无聊限制。想象一个消费者试图清理输入不当的数据，这些数据颠倒了 5 个块的适当顺序，即数据看起来像 [B5, A5, D5, C5] 并且应该看起来像 [A5, B5, C5, D5]（其中A5 只是五个元素而不是子列表）。这个消费者会查看分组函数声称的行为，并毫不犹豫地编写一个循环，例如
i = 0
out = []
for it in paged_iter(data,5)
if (i % 2 == 0):
swapped = it
else:
out += list(it)
out += list(swapped)
i = i + 1
如果你偷偷地假设子迭代器总是按顺序完全使用，这将产生神秘的错误结果。如果您想从块中交错元素，情况会变得更糟。
其次，相当数量的建议解决方案隐含地依赖于迭代器具有确定性顺序的事实（例如，它们没有设置），虽然一些使用 islice 的解决方案可能没问题，但让我担心。
第三，itertools grouper 方法有效，但配方依赖于 zip_longest（或 zip）函数的内部行为，这不是其已发布行为的一部分。特别是，grouper 函数之所以起作用，是因为在 zip_longest(i0...in) 中，下一个函数总是在重新开始之前按 next(i0)、next(i1)、... next(in) 的顺序调用。当 grouper 传递同一个迭代器对象的 n 个副本时，它依赖于这种行为。
最后，虽然下面的解决方案可以改进，如果你做出上面批评的假设，即子迭代器是按顺序访问的，并且在没有这个假设的情况下完全阅读，一个必须隐式（通过调用链）或显式（通过双端队列或其他数据结构）存储元素对于某个地方的每个子迭代器。所以不要浪费时间（就像我一样）假设一个人可以通过一些聪明的技巧来解决这个问题。
def paged_iter(iterat, n):
itr = iter(iterat)
deq = None
try:
while(True):
deq = collections.deque(maxlen=n)
for q in range(n):
deq.append(next(itr))
yield (i for i in deq)
except StopIteration:
yield (i for i in deq)
于 2017-01-11T09:18:53.907 回答
4
这是一个使用 itertools.groupby 的想法：
def chunks(l, n):
c = itertools.count()
return (it for _, it in itertools.groupby(l, lambda x: next(c)//n))
这将返回一个生成器的生成器。如果你想要一个列表列表，只需将最后一行替换为
return [list(it) for _, it in itertools.groupby(l, lambda x: next(c)//n)]
返回列表的示例：
>>> chunks('abcdefghij', 4)
[['a', 'b', 'c', 'd'], ['e', 'f', 'g', 'h'], ['i', 'j']]
（所以是的，这会受到“矮小的问题”的影响，在给定的情况下这可能是也可能不是问题。）
于 2017-03-08T17:03:46.637 回答
3
上面的答案（由 koffein 提供）有一个小问题：列表总是被分割成相等数量的分割，而不是每个分区的相同数量的项目。这是我的版本。"// chs + 1" 考虑到项目的数量可能无法完全除以分区大小，因此最后一个分区只会被部分填充。
# Given 'l' is your list
chs = 12 # Your chunksize
partitioned = [ l[i*chs:(i*chs)+chs] for i in range((len(l) // chs)+1) ]
于 2015-04-17T18:48:35.570 回答
3
没有魔法，但简单而正确：
def chunks(iterable, n):
"""Yield successive n-sized chunks from iterable."""
values = []
for i, item in enumerate(iterable, 1):
values.append(item)
if i % n == 0:
yield values
values = []
if values:
yield values
于 2017-10-30T08:13:46.497 回答
3
一个抽象将是
l = [1,2,3,4,5,6,7,8,9]
n = 3
outList = []
for i in range(n, len(l) + n, n):
outList.append(l[i-n:i])
print(outList)
这将打印：
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
于 2020-06-29T17:54:13.790 回答
3
一个简单的解决方案
OP 已请求“大小相等的块”。我将“大小相等”理解为“平衡”大小：如果不可能大小相等（例如，23/5），我们正在寻找大小大致相同的物品组。
这里的输入是：
- 项目列表：（
input_list例如 23 个数字的列表） - 拆分这些项目的组数：（
n_groups例如5）
输入：
input_list = list(range(23))
n_groups = 5
连续元素组：
approx_sizes = len(input_list)/n_groups
groups_cont = [input_list[int(i*approx_sizes):int((i+1)*approx_sizes)]
for i in range(n_groups)]
“每 N 个”元素组：
groups_leap = [input_list[i::n_groups]
for i in range(n_groups)]
结果
print(len(input_list))
print('Contiguous elements lists:')
print(groups_cont)
print('Leap every "N" items lists:')
print(groups_leap)
将输出：
23 Contiguous elements lists: [[0, 1, 2, 3], [4, 5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16, 17], [18, 19, 20, 21, 22]] Leap every "N" items lists: [[0, 5, 10, 15, 20], [1, 6, 11, 16, 21], [2, 7, 12, 17, 22], [3, 8, 13, 18], [4, 9, 14, 19]]
于 2021-04-06T11:06:37.140 回答
2
- 适用于任何可迭代的
- 内部数据是生成器对象（不是列表）
- 一个班轮
在 [259] 中：get_in_chunks = lambda itr,n: ((v for _,v in g) for _,g in itertools.groupby(enumerate(itr),lambda (ind,_): ind/n)) 在 [260] 中：list(list(x) for x in get_in_chunks(range(30),7)) 输出[260]： [[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]]
于 2013-09-13T19:11:44.557 回答
2
就像@AaronHall 一样，我来到这里寻找大小大致均匀的块。对此有不同的解释。就我而言，如果所需的大小为 N，我希望每个组的大小>=N。因此，在上述大多数情况下创建的孤儿应该重新分配给其他组。
这可以使用以下方法完成：
def nChunks(l, n):
""" Yield n successive chunks from l.
Works for lists, pandas dataframes, etc
"""
newn = int(1.0 * len(l) / n + 0.5)
for i in xrange(0, n-1):
yield l[i*newn:i*newn+newn]
yield l[n*newn-newn:]
（从将列表拆分为大约相等长度的 N 部分）只需将其称为 nChunks(l,l/n) 或 nChunks(l,floor(l/n))
于 2014-09-03T17:43:15.433 回答
2
我已经提出了以下解决方案，而无需创建临时列表对象，它应该适用于任何可迭代对象。请注意，此版本适用于 Python 2.x：
def chunked(iterable, size):
stop = []
it = iter(iterable)
def _next_chunk():
try:
for _ in xrange(size):
yield next(it)
except StopIteration:
stop.append(True)
return
while not stop:
yield _next_chunk()
for it in chunked(xrange(16), 4):
print list(it)
输出：
[0, 1, 2, 3]
[4, 5, 6, 7]
[8, 9, 10, 11]
[12, 13, 14, 15]
[]
如您所见，如果 len(iterable) % size == 0 那么我们有额外的空迭代器对象。但我不认为这是一个大问题。
于 2015-09-18T17:54:39.500 回答
2
这适用于 v2/v3，可内联，基于生成器并且仅使用标准库：
import itertools
def split_groups(iter_in, group_size):
return ((x for _, x in item) for _, item in itertools.groupby(enumerate(iter_in), key=lambda x: x[0] // group_size))
于 2017-07-06T22:24:14.247 回答
1
由于我必须做这样的事情，这是我的解决方案，给出了一个生成器和一个批量大小：
def pop_n_elems_from_generator(g, n):
elems = []
try:
for idx in xrange(0, n):
elems.append(g.next())
return elems
except StopIteration:
return elems
于 2015-10-16T22:09:29.580 回答
1
这个问题让我想起了 Raku（以前的 Perl 6）.comb(n)方法。它将字符串分解为- 大小的n块。（除此之外还有更多内容，但我会省略细节。）
在 Python3 中实现类似的函数作为 lambda 表达式很容易：
comb = lambda s,n: (s[i:i+n] for i in range(0,len(s),n))
然后你可以这样称呼它：
some_list = list(range(0, 20)) # creates a list of 20 elements
generator = comb(some_list, 4) # creates a generator that will generate lists of 4 elements
for sublist in generator:
print(sublist) # prints a sublist of four elements, as it's generated
当然，您不必将生成器分配给变量；你可以像这样直接循环它：
for sublist in comb(some_list, 4):
print(sublist) # prints a sublist of four elements, as it's generated
作为奖励，此comb()函数还对字符串进行操作：
list( comb('catdogant', 3) ) # returns ['cat', 'dog', 'ant']
于 2019-07-15T15:27:09.277 回答
1
任何可迭代的通用分块器，它使用户可以选择最后如何处理部分块。
在 Python 3 上测试。
chunker.py
from enum import Enum
class PartialChunkOptions(Enum):
INCLUDE = 0
EXCLUDE = 1
PAD = 2
ERROR = 3
class PartialChunkException(Exception):
pass
def chunker(iterable, n, on_partial=PartialChunkOptions.INCLUDE, pad=None):
"""
A chunker yielding n-element lists from an iterable, with various options
about what to do about a partial chunk at the end.
on_partial=PartialChunkOptions.INCLUDE (the default):
include the partial chunk as a short (<n) element list
on_partial=PartialChunkOptions.EXCLUDE
do not include the partial chunk
on_partial=PartialChunkOptions.PAD
pad to an n-element list
(also pass pad=<pad_value>, default None)
on_partial=PartialChunkOptions.ERROR
raise a RuntimeError if a partial chunk is encountered
"""
on_partial = PartialChunkOptions(on_partial)
iterator = iter(iterable)
while True:
vals = []
for i in range(n):
try:
vals.append(next(iterator))
except StopIteration:
if vals:
if on_partial == PartialChunkOptions.INCLUDE:
yield vals
elif on_partial == PartialChunkOptions.EXCLUDE:
pass
elif on_partial == PartialChunkOptions.PAD:
yield vals + [pad] * (n - len(vals))
elif on_partial == PartialChunkOptions.ERROR:
raise PartialChunkException
return
return
yield vals
test.py
import chunker
chunk_size = 3
for it in (range(100, 107),
range(100, 109)):
print("\nITERABLE TO CHUNK: {}".format(it))
print("CHUNK SIZE: {}".format(chunk_size))
for option in chunker.PartialChunkOptions.__members__.values():
print("\noption {} used".format(option))
try:
for chunk in chunker.chunker(it, chunk_size, on_partial=option):
print(chunk)
except chunker.PartialChunkException:
print("PartialChunkException was raised")
print("")
的输出test.py
ITERABLE TO CHUNK: range(100, 107)
CHUNK SIZE: 3
option PartialChunkOptions.INCLUDE used
[100, 101, 102]
[103, 104, 105]
[106]
option PartialChunkOptions.EXCLUDE used
[100, 101, 102]
[103, 104, 105]
option PartialChunkOptions.PAD used
[100, 101, 102]
[103, 104, 105]
[106, None, None]
option PartialChunkOptions.ERROR used
[100, 101, 102]
[103, 104, 105]
PartialChunkException was raised
ITERABLE TO CHUNK: range(100, 109)
CHUNK SIZE: 3
option PartialChunkOptions.INCLUDE used
[100, 101, 102]
[103, 104, 105]
[106, 107, 108]
option PartialChunkOptions.EXCLUDE used
[100, 101, 102]
[103, 104, 105]
[106, 107, 108]
option PartialChunkOptions.PAD used
[100, 101, 102]
[103, 104, 105]
[106, 107, 108]
option PartialChunkOptions.ERROR used
[100, 101, 102]
[103, 104, 105]
[106, 107, 108]
于 2020-06-05T13:34:18.177 回答
1
虽然有很多答案我有很简单的方法：
x = list(range(10, 75))
indices = x[0::10]
print("indices: ", indices)
xx = [x[i-10:i] for i in indices ]
print("x= ", x)
print ("xx= ",xx)
结果将是：
指数：[10, 20, 30, 40, 50, 60, 70] x= [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]
xx = [[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]]
于 2021-03-21T16:27:34.113 回答
0
我不喜欢按块大小拆分元素的想法，例如脚本可以将 101 到 3 个块划分为 [50, 50, 1]。为了我的需要，我需要按比例拆分，并保持顺序不变。首先，我编写了自己的脚本，效果很好，而且非常简单。但是我后来看到了这个答案，脚本比我的好，我推荐它。这是我的脚本：
def proportional_dividing(N, n):
"""
N - length of array (bigger number)
n - number of chunks (smaller number)
output - arr, containing N numbers, diveded roundly to n chunks
"""
arr = []
if N == 0:
return arr
elif n == 0:
arr.append(N)
return arr
r = N // n
for i in range(n-1):
arr.append(r)
arr.append(N-r*(n-1))
last_n = arr[-1]
# last number always will be r <= last_n < 2*r
# when last_n == r it's ok, but when last_n > r ...
if last_n > r:
# ... and if difference too big (bigger than 1), then
if abs(r-last_n) > 1:
#[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 7] # N=29, n=12
# we need to give unnecessary numbers to first elements back
diff = last_n - r
for k in range(diff):
arr[k] += 1
arr[-1] = r
# and we receive [3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2]
return arr
def split_items(items, chunks):
arr = proportional_dividing(len(items), chunks)
splitted = []
for chunk_size in arr:
splitted.append(items[:chunk_size])
items = items[chunk_size:]
print(splitted)
return splitted
items = [1,2,3,4,5,6,7,8,9,10,11]
chunks = 3
split_items(items, chunks)
split_items(['a','b','c','d','e','f','g','h','i','g','k','l', 'm'], 3)
split_items(['a','b','c','d','e','f','g','h','i','g','k','l', 'm', 'n'], 3)
split_items(range(100), 4)
split_items(range(99), 4)
split_items(range(101), 4)
和输出：
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11]]
[['a', 'b', 'c', 'd'], ['e', 'f', 'g', 'h'], ['i', 'g', 'k', 'l', 'm']]
[['a', 'b', 'c', 'd', 'e'], ['f', 'g', 'h', 'i', 'g'], ['k', 'l', 'm', 'n']]
[range(0, 25), range(25, 50), range(50, 75), range(75, 100)]
[range(0, 25), range(25, 50), range(50, 75), range(75, 99)]
[range(0, 25), range(25, 50), range(50, 75), range(75, 101)]
于 2018-03-23T18:27:35.233 回答
0
如果您不关心订单：
> from itertools import groupby
> batch_no = 3
> data = 'abcdefgh'
> [
[x[1] for x in x[1]]
for x in
groupby(
sorted(
(x[0] % batch_no, x[1])
for x in
enumerate(data)
),
key=lambda x: x[0]
)
]
[['a', 'd', 'g'], ['b', 'e', 'h'], ['c', 'f']]
此解决方案不会生成相同大小的集合，而是分配值以使批次尽可能大，同时保持生成的批次数量。
于 2019-05-23T10:35:48.957 回答
0
我创建了这两个高效且懒惰的花哨的单行代码，输入和输出都是可迭代的，而且它们不依赖于任何模块：
第一个单行是完全惰性的，这意味着它返回生成迭代器的迭代器（即生成的每个块都是迭代块元素的迭代器），这个版本适用于块非常大或元素一个接一个缓慢生成的情况，应该成为生产后立即可用：
chunk_iters = lambda it, n: ((e for i, g in enumerate(((f,), cit)) for j, e in zip(range((1, n - 1)[i]), g)) for cit in (iter(it),) for f in cit)
第二个单行返回生成列表的迭代器。一旦整个块的元素通过输入迭代器变得可用，或者如果到达最后一个块的最后一个元素，就会生成每个列表。如果输入元素快速生成或立即可用，则应使用此版本。其他明智的第一个更懒惰的单线版本应该被使用。
chunk_lists = lambda it, n: (l for l in ([],) for i, g in enumerate((it, ((),))) for e in g for l in (l[:len(l) % n] + [e][:1 - i],) if (len(l) % n == 0) != i)
我还提供了第一个单行的多行版本chunk_iters，它返回生成另一个迭代器的迭代器（遍历每个块的元素）：
def chunk_iters(it, n):
cit = iter(it)
def one_chunk(f):
yield f
for i, e in zip(range(n - 1), cit):
yield e
for f in cit:
yield one_chunk(f)
于 2020-09-24T07:01:48.677 回答
0
from itertools import islice
l=[1,2,3,4,5,6]
chuncksize=input("Enter chunk size")
m=[]
obj=iter(l)
m.append(list(islice(l,3)))
m.append(list(islice(l,3)))
print(m)
于 2021-04-20T14:46:09.390 回答
0
使用接受的答案中的生成器可以轻松完成此任务。我正在添加实现长度方法的类实现，这可能对某人有用。我需要知道进度（用tqdm），所以生成器应该已经返回了块的数量。
class ChunksIterator(object):
def __init__(self, data, n):
self._data = data
self._l = len(data)
self._n = n
def __iter__(self):
for i in range(0, self._l, self._n):
yield self._data[i:i + self._n]
def __len__(self):
rem = 1 if self._l % self._n != 0 else 0
return self._l // self._n + rem
用法：
it = ChunksIterator([1,2,3,4,5,6,7,8,9], 2)
print(len(it))
for i in it:
print(i)
于 2021-12-16T15:29:25.557 回答
0
senderle 答案的单行版本：
from itertools import islice
from functools import partial
seq = [1,2,3,4,5,6,7]
size = 3
result = list(iter(partial(lambda it: tuple(islice(it, size)), iter(seq)), ()))
assert result == [(1, 2, 3), (4, 5, 6), (7,)]
于 2022-01-02T11:14:27.230 回答
0
假设列表是lst
import math
# length of the list len(lst) is ln
# size of a chunk is size
for num in range ( math.ceil(ln/size) ):
start, end = num*size, min((num+1)*size, ln)
print(lst[start:end])
于 2022-01-31T14:53:24.967 回答
-1
懒加载版
import pprint pprint.pprint(list(chunks(range(10, 75), 10))) [range(10, 20), range(20, 30), range(30, 40), range(40, 50), range(50, 60), range(60, 70), range(70, 75)]将此实现的结果与接受的答案的示例使用结果相结合。
上述许多函数都假设整个迭代的长度是预先知道的，或者至少计算起来很便宜。
对于一些流对象，这意味着首先将完整数据加载到内存中（例如下载整个文件）以获取长度信息。
但是，如果您还不知道完整尺寸，则可以改用此代码：
def chunks(iterable, size):
"""
Yield successive chunks from iterable, being `size` long.
https://stackoverflow.com/a/55776536/3423324
:param iterable: The object you want to split into pieces.
:param size: The size each of the resulting pieces should have.
"""
i = 0
while True:
sliced = iterable[i:i + size]
if len(sliced) == 0:
# to suppress stuff like `range(max, max)`.
break
# end if
yield sliced
if len(sliced) < size:
# our slice is not the full length, so we must have passed the end of the iterator
break
# end if
i += size # so we start the next chunk at the right place.
# end while
# end def
这是有效的，因为如果您传递了可迭代的结尾， slice 命令将返回更少/没有元素：
"abc"[0:2] == 'ab'
"abc"[2:4] == 'c'
"abc"[4:6] == ''
我们现在使用切片的结果，并计算生成的块的长度。如果它低于我们的预期，我们知道我们可以结束迭代。
这样迭代器将不会被执行，除非访问。
于 2019-04-20T18:28:54.083 回答
-1
一种不需要 itertools 但仍适用于任意生成器的老式方法：
def chunks(g, n):
"""divide a generator 'g' into small chunks
Yields:
a chunk that has 'n' or less items
"""
n = max(1, n)
buff = []
for item in g:
buff.append(item)
if len(buff) == n:
yield buff
buff = []
if buff:
yield buff
于 2019-12-03T18:34:33.307 回答
-1
def main():
print(chunkify([1,2,3,4,5,6],2))
def chunkify(list, n):
chunks = []
for i in range(0, len(list), n):
chunks.append(list[i:i+n])
return chunks
main()
我认为这很简单，可以给你一大块数组。
于 2020-04-14T16:18:52.350 回答
-1
这是一段用 Python3 编写的代码，其作用与 np.array_split 相同。
list(map(list, map(functools.partial(filter, None), itertools.zip_longest(*iter(lambda: tuple(itertools.islice(a, n)), ())))))
这是一个相当长的单行，但它确实将项目平均分配到生成的子列表中。
于 2020-07-28T14:07:15.307 回答
-2
使用python的List Comprehensions
[range(t,t+10) for t in range(1,1000,10)]
[[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],....
....[981, 982, 983, 984, 985, 986, 987, 988, 989, 990],
[991, 992, 993, 994, 995, 996, 997, 998, 999, 1000]]
访问此链接以了解列表理解
于 2013-05-26T15:18:42.210 回答
-2
是的，这是一个老问题，但我不得不发布这个问题，因为它比类似的问题还要短一点。是的，结果看起来很乱，但如果它的长度差不多……
>>> n = 3 # number of groups
>>> biglist = range(30)
>>>
>>> [ biglist[i::n] for i in xrange(n) ]
[[0, 3, 6, 9, 12, 15, 18, 21, 24, 27],
[1, 4, 7, 10, 13, 16, 19, 22, 25, 28],
[2, 5, 8, 11, 14, 17, 20, 23, 26, 29]]
于 2013-11-26T21:58:03.577 回答