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

非常简单的事情：

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

对于Python 2，使用xrange（）代替range（）。

下面我有一个解决方案确实有效，但比这个解决方案更重要的是对其他方法的一些评论。首先，一个好的解决方案不应该要求一个循环按顺序遍历子迭代器。如果我跑

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]

not

 []

正如这里大多数基于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_langest（或zip）函数的内部行为，而这些行为不是其发布行为的一部分。特别是，grouper函数只起作用，因为在zip_langest（i0…In）中，下一个函数总是按next（i0）、next（i 1）、……的顺序调用。。。在重新开始之前。当grouper传递同一迭代器对象的n个副本时，它依赖于此行为。

最后，虽然下面的解决方案可以得到改进，但如果您对上面的假设进行了批评，即子迭代器是按顺序访问的，并且在没有这个假设的情况下被完全阅读，则必须隐式（通过调用链）或显式（通过deques或其他数据结构）为每个子迭代程序存储元素。所以，不要浪费时间（就像我所做的那样），假设人们可以用一些巧妙的技巧来解决这个问题。

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)

您可以使用更多的intertools.chunked_甚至与math.eil一起使用。这可能是最容易理解的吗？

from math import ceil
import more_itertools as mit
from pprint import pprint

pprint([*mit.chunked_even(range(19), ceil(19 / 5))])
# [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15], [16, 17, 18]]

pprint([*mit.chunked_even(range(20), ceil(20 / 5))])
# [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15], [16, 17, 18, 19]]

pprint([*mit.chunked_even(range(21), ceil(21 / 5))])
# [[0, 1, 2, 3, 4],
# [5, 6, 7, 8],
# [9, 10, 11, 12],
# [13, 14, 15, 16],
# [17, 18, 19, 20]]

pprint([*mit.chunked_even(range(3), ceil(3 / 5))])
# [[0], [1], [2]]

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