直接从（旧的）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个项组成的元组。

我在这个问题的副本中看到了最棒的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=范围（1，15），那么结果将是：

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

如果列表被平均划分，那么可以用zip替换zip_langest，否则三元组（13、14、None）将丢失。上面使用了Python 3。对于Python 2，请使用izip_length。

我想我没有看到这个选项，所以只需添加另一个：）：

def chunks(iterable, chunk_size):
  i = 0;
  while i < len(iterable):
    yield iterable[i:i+chunk_size]
    i += chunk_size

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

没有魔力，但简单而正确：

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

直接从（旧的）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个项组成的元组。