在Python中按（n）块迭代迭代器？

Question

你能想出一个很好的方法（也许使用 itertools）来将迭代器分成给定大小的块吗？

因此 l=[1,2,3,4,5,6,7] 和 chunks(l,3) 成为迭代器 [1,2,3], [4,5,6], [7]

我可以想到一个小程序来做到这一点，但可能不是使用 itertools 的好方法。

Answer 1

itertools 文档的 recipes 中的 grouper() 配方接近您想要的：

def grouper(n, iterable, fillvalue=None):
    "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

不过，它会用填充值填充最后一个块。

一种不太通用的解决方案，它只适用于序列，但可以根据需要处理最后一个块

[my_list[i:i + chunk_size] for i in range(0, len(my_list), chunk_size)]

最后，一个适用于通用迭代器并按需要运行的解决方案是

def grouper(n, iterable):
    it = iter(iterable)
    while True:
        chunk = tuple(itertools.islice(it, n))
        if not chunk:
            return
        yield chunk

Answer 2

“简单胜于复杂”- 一个几行长的简单生成器就可以完成这项工作。只需将它放在一些实用程序模块中即可：

def grouper (iterable, n):
    iterable = iter(iterable)
    count = 0
    group = []
    while True:
        try:
            group.append(next(iterable))
            count += 1
            if count % n == 0:
                yield group
                group = []
        except StopIteration:
            yield group
            break

Answer 3

这是一个返回惰性块的方法；如果需要列表，请使用 map(list, chunks(...))。

from itertools import islice, chain
from collections import deque

def chunks(items, n):
    items = iter(items)
    for first in items:
        chunk = chain((first,), islice(items, n-1))
        yield chunk
        deque(chunk, 0)

if __name__ == "__main__":
    for chunk in map(list, chunks(range(10), 3)):
        print chunk

    for i, chunk in enumerate(chunks(range(10), 3)):
        if i % 2 == 1:
            print "chunk #%d: %s" % (i, list(chunk))
        else:
            print "skipping #%d" % i

Answer 4

我忘记了我是从哪里找到这个灵感的。我对其进行了一些修改，以便在 Windows 注册表中使用 MSI GUID：

def nslice(s, n, truncate=False, reverse=False):
    """Splits s into n-sized chunks, optionally reversing the chunks."""
    assert n > 0
    while len(s) >= n:
        if reverse: yield s[:n][::-1]
        else: yield s[:n]
        s = s[n:]
    if len(s) and not truncate:
        yield s

reverse 不适用于您的问题，但这是我在此功能中广泛使用的东西。

>>> [i for i in nslice([1,2,3,4,5,6,7], 3)]
[[1, 2, 3], [4, 5, 6], [7]]
>>> [i for i in nslice([1,2,3,4,5,6,7], 3, truncate=True)]
[[1, 2, 3], [4, 5, 6]]
>>> [i for i in nslice([1,2,3,4,5,6,7], 3, truncate=True, reverse=True)]
[[3, 2, 1], [6, 5, 4]]

Answer 5

给你。

def chunksiter(l, chunks):
    i,j,n = 0,0,0
    rl = []
    while n < len(l)/chunks:        
        rl.append(l[i:j+chunks])        
        i+=chunks
        j+=j+chunks        
        n+=1
    return iter(rl)


def chunksiter2(l, chunks):
    i,j,n = 0,0,0
    while n < len(l)/chunks:        
        yield l[i:j+chunks]
        i+=chunks
        j+=j+chunks        
        n+=1

示例：

for l in chunksiter([1,2,3,4,5,6,7,8],3):
    print(l)

[1, 2, 3]
[4, 5, 6]
[7, 8]

for l in chunksiter2([1,2,3,4,5,6,7,8],3):
    print(l)

[1, 2, 3]
[4, 5, 6]
[7, 8]


for l in chunksiter2([1,2,3,4,5,6,7,8],5):
    print(l)

[1, 2, 3, 4, 5]
[6, 7, 8]

Answer 6

一个简洁的实现是：

chunker = lambda iterable, n: (ifilterfalse(lambda x: x == (), chunk) for chunk in (izip_longest(*[iter(iterable)]*n, fillvalue=())))

这是有效的，因为[iter(iterable)]*n 是一个包含相同迭代器 n 次的列表；压缩从列表中的每个迭代器中获取一个项目，这是相同的迭代器，结果每个 zip 元素包含一组 n 项目。

需要izip_longest 来完全消耗底层的可迭代对象，而不是在到达第一个用尽的迭代器时停止迭代，这会切断iterable 的任何剩余部分。这导致需要过滤掉填充值。因此，一个稍微更健壮的实现将是：

def chunker(iterable, n):
    class Filler(object): pass
    return (ifilterfalse(lambda x: x is Filler, chunk) for chunk in (izip_longest(*[iter(iterable)]*n, fillvalue=Filler)))

这保证了填充值永远不会是底层迭代中的项目。使用上面的定义：

iterable = range(1,11)

map(tuple,chunker(iterable, 3))
[(1, 2, 3), (4, 5, 6), (7, 8, 9), (10,)]

map(tuple,chunker(iterable, 2))
[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]

map(tuple,chunker(iterable, 4))
[(1, 2, 3, 4), (5, 6, 7, 8), (9, 10)]

---

此实现几乎可以满足您的要求，但存在问题：

def chunks(it, step):
  start = 0
  while True:
    end = start+step
    yield islice(it, start, end)
    start = end

（不同之处在于，因为islice 不会在超过it 结束的调用上引发 StopIteration 或其他任何事情，这将永远产生；还有一个稍微棘手的问题，islice 结果必须是在迭代此生成器之前消耗）。

功能性地生成移动窗口：

izip(count(0, step), count(step, step))

这样就变成了：

(it[start:end] for (start,end) in izip(count(0, step), count(step, step)))

但是，这仍然会创建一个无限迭代器。所以，你需要暂时（或者其他可能更好的方法）来限制它：

chunk = lambda it, step: takewhile((lambda x: len(x) > 0), (it[start:end] for (start,end) in izip(count(0, step), count(step, step))))

g = chunk(range(1,11), 3)

tuple(g)
([1, 2, 3], [4, 5, 6], [7, 8, 9], [10])

---

Answer 7

虽然 OP 要求函数以列表或元组的形式返回块，但如果您需要返回迭代器，则可以修改 Sven Marnach's 解决方案：

def grouper_it(n, iterable):
    it = iter(iterable)
    while True:
        chunk_it = itertools.islice(it, n)
        try:
            first_el = next(chunk_it)
        except StopIteration:
            return
        yield itertools.chain((first_el,), chunk_it)

一些基准测试：http://pastebin.com/YkKFvm8b

仅当您的函数遍历每个块中的元素时，它才会稍微更有效。

Answer 8

我今天正在做一些事情，并想出了一个我认为很简单的解决方案。它类似于jsbueno's 的答案，但我相信当iterable 的长度可以被n 整除时，他会产生空的groups。当iterable 用尽时，我的回答会做一个简单的检查。

def chunk(iterable, chunk_size):
    """Generates lists of `chunk_size` elements from `iterable`.
    
    
    >>> list(chunk((2, 3, 5, 7), 3))
    [[2, 3, 5], [7]]
    >>> list(chunk((2, 3, 5, 7), 2))
    [[2, 3], [5, 7]]
    """
    iterable = iter(iterable)
    while True:
        chunk = []
        try:
            for _ in range(chunk_size):
                chunk.append(next(iterable))
            yield chunk
        except StopIteration:
            if chunk:
                yield chunk
            break

Answer 9

这适用于任何可迭代对象。它返回生成器的生成器（以获得完全的灵活性）。我现在意识到它与@reclosedevs 解决方案基本相同，但没有绒毛。不需要try...except，因为StopIteration 向上传播，这就是我们想要的。

当可迭代对象为空时，需要调用 next(iterable) 来引发 StopIteration，因为如果您允许，islice 将永远生成空生成器。

这更好，因为它只有两行长，但易于理解。

def grouper(iterable, n):
    while True:
        yield itertools.chain((next(iterable),), itertools.islice(iterable, n-1))

注意next(iterable) 被放入一个元组中。否则，如果 next(iterable) 本身是可迭代的，那么 itertools.chain 会将其展平。感谢 Jeremy Brown 指出这个问题。