直接从（旧的）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)

J.F.Sebastian建议的当前版本：

#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（或早期版本中的等价物）创建了一个迭代器，在列表中重复n次。izip_length然后有效地执行“每个”迭代器的循环；因为这是同一个迭代器，所以每一个这样的调用都会使它前进，从而导致每个这样的zip循环生成一个由n个项组成的元组。

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

直接从（旧的）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)

J.F.Sebastian建议的当前版本：

#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（或早期版本中的等价物）创建了一个迭代器，在列表中重复n次。izip_length然后有效地执行“每个”迭代器的循环；因为这是同一个迭代器，所以每一个这样的调用都会使它前进，从而导致每个这样的zip循环生成一个由n个项组成的元组。

简单而优雅

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)

不要重新发明轮子。

更新：即将发布的Python 3.12引入了itertools.batch，最终解决了这个问题。见下文。

鉴于

import itertools as it
import collections as ct

import more_itertools as mit


iterable = range(11)
n = 3

Code

itertools.batch++

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

更多工具+

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（相关已发布）更多intertools.slicedmore_itertools.grouper（相关文章）more_itertools.windowd（另请参见错开、zip_offset）更多intertools.chunked_evenzip_langest（相关帖子，相关帖子）setdefault（排序结果需要Python 3.6+）collections.defaultdict（排序结果需要Python 3.6+）

+第三方库，实现itertools配方等。>pip安装更多工具

++Python标准库3.12+中包含的.batched类似于more_itertools.chunked。

我专门为此写了一个小图书馆，这里有。库的分块函数特别有效，因为它是作为生成器实现的，因此在某些情况下可以节省大量内存。它也不依赖切片表示法，因此可以使用任意迭代器。

import iterlib

print list(iterlib.chunked(xrange(1, 1000), 10))
# prints [(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), (11, 12, 13, 14, 15, 16, 17, 18, 19, 20), ...]