这个问题让我想起Raku（以前的Perl6）.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']

让r是块大小，L是初始列表，您可以这样做。

chunkL = [ [i for i in L[r*k:r*(k+1)] ] for k in range(len(L)/r)] 

在这一点上，我认为我们需要一个递归生成器，以防万一。。。

在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

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

更新

从Python 3.12开始，这个精确的实现可以作为itertools.batch获得

因为这里的每个人都在谈论迭代器。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]]

但如果您不想在内存上手下留情，您可以使用旧方法，首先使用iterutils.chunked存储完整列表。

我创建了这两个漂亮的一行程序，它们既高效又懒惰，输入和输出都是可迭代的，而且它们不依赖于任何模块：

首先，一行是完全懒惰的，这意味着它返回迭代器生成迭代器（即，生成的每个块都是迭代器对块的元素进行迭代），如果块非常大或元素一个接一个地缓慢生成，并且在生成时应立即可用，则此版本适用于这种情况：

在线试用！

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_iter的多行版本一行，它返回迭代器生成另一个迭代器（遍历每个chunk的元素）：

在线试用！

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)