Python 生成器将另一个可迭代分为 N 组

Question

我正在寻找一个函数，它接受可迭代的 i 和大小 n 并生成长度为 n 的元组，这些元组是来自 的顺序值>i:

x = [1,2,3,4,5,6,7,8,9,0]
[z for z in TheFunc(x,3)]

给出

[(1,2,3),(4,5,6),(7,8,9),(0)]

标准库中是否存在这样的函数？

如果它作为标准库的一部分存在，我似乎无法找到它，并且我已经没有要搜索的术语了。我可以自己写，但我不愿意。

Answer 1

当您想要将迭代器分成 n 块进行分组时，不使用填充值填充最终组，请使用 iter(lambda: list(IT. islice(iterable, n)), []):

import itertools as IT

def grouper(n, iterable):
    """
    >>> list(grouper(3, 'ABCDEFG'))
    [['A', 'B', 'C'], ['D', 'E', 'F'], ['G']]
    """
    iterable = iter(iterable)
    return iter(lambda: list(IT.islice(iterable, n)), [])

seq = [1,2,3,4,5,6,7]
print(list(grouper(3, seq)))

yields

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

这个答案。

---

当您想要将迭代器分成 n 块并用填充值填充最终组时，请使用 石斑鱼食谱 zip_longest(*[iterator]*n)：

例如，在Python2：

>>> list(IT.izip_longest(*[iter(seq)]*3, fillvalue='x'))
[(1, 2, 3), (4, 5, 6), (7, 'x', 'x')]

在 Python3 中，izip_longest 现已重命名为 zip_longest：

>>> list(IT.zip_longest(*[iter(seq)]*3, fillvalue='x'))
[(1, 2, 3), (4, 5, 6), (7, 'x', 'x')]

---

当您想要将序列分组为 块时n你可以使用chunks配方：

def chunks(seq, n):
    # https://stackoverflow.com/a/312464/190597 (Ned Batchelder)
    """ Yield successive n-sized chunks from seq."""
    for i in xrange(0, len(seq), n):
        yield seq[i:i + n]

请注意，与一般的迭代器不同，根据定义的序列具有长度（即定义了__len__）。

Answer 2

请参阅 itertoolsgrouper 配方> package

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

（但是，这是相当多的问题的重复。）

Answer 3

这个怎么样？但它没有填充值。

>>> def partition(itr, n):
...     i = iter(itr)
...     res = None
...     while True:
...             res = list(itertools.islice(i, 0, n))
...             if res == []:
...                     break
...             yield res
...
>>> list(partition([1, 2, 3, 4, 5, 6, 7, 8, 9], 3))
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>>

它使用原始可迭代对象的副本，并为每个连续的拼接耗尽该副本。我疲惫的大脑能想到的唯一其他方法是生成具有范围的拼接端点。

也许我应该将 list() 更改为 tuple() ，以便它更好地对应您的输出。

Answer 4

这是 Python 中非常常见的请求。它非常常见，以至于它被纳入 boltons 统一实用程序包中。首先，这里有大量文档。此外，模块的设计和测试仅依赖于标准库（Python 2 和 3 兼容），这意味着您可以 只需下载该文件直接进入您的项目。

# if you downloaded/embedded, try:
# from iterutils import chunked

# with `pip install boltons` use:

from boltons.iterutils import chunked 

print(chunked(range(10), 3))
# [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]

还有用于不定/长序列的迭代器/生成器形式：

print(list(chunked_iter(range(10), 3, fill=None)))
# [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, None, None]]

如您所见，您也可以用您选择的值填充序列。最后，作为维护者，我可以向您保证，虽然代码已被数千名开发人员下载/测试，但如果您遇到任何问题，您将通过 boltons GitHub 问题页面。希望这个（和/或任何其他 150 多个 Bolton 食谱）有所帮助！

Answer 5

我使用 more_itertools 包中的分块函数。

$ pip install more_itertools
$ python
>>> x = [1,2,3,4,5,6,7,8,9,0]
>>> [tuple(z) for z in more_itertools.more.chunked(x, 3)]
[(1, 2, 3), (4, 5, 6), (7, 8, 9), (0,)]

Answer 6

这是一个非常古老的问题，但我认为针对一般情况提及以下方法是有用的。它的主要优点是它只需要迭代数据一次，因此它可以与数据库游标或其他只能使用一次的序列一起使用。我还发现它更具可读性。

def chunks(n, iterator):
    out = []
    for elem in iterator:
        out.append(elem)
        if len(out) == n:
            yield out
            out = []
    if out:
        yield out

Answer 7

我知道这个问题已经被回答过好几次了，但我添加了我的解决方案，与石斑鱼配方相比，它应该在序列和迭代器的一般适用性、可读性（没有 StopIteration 异常导致的不可见循环退出条件）和性能方面得到改进。它与 Svein 的最后一个答案最相似。

def chunkify(iterable, n):
    iterable = iter(iterable)
    n_rest = n - 1

    for item in iterable:
        rest = itertools.islice(iterable, n_rest)
        yield itertools.chain((item,), rest)

Answer 8

这是一个不同的解决方案，它不使用 itertools，尽管它多了几行，但当块比可迭代长度短得多时，它显然优于给定的答案。
然而，对于大块，其他答案要快得多。

def batchiter(iterable, batch_size):
    """
    >>> list(batchiter('ABCDEFG', 3))
    [['A', 'B', 'C'], ['D', 'E', 'F'], ['G']]
    """
    next_batch = []
    for element in iterable:
        next_batch.append(element)
        if len(next_batch) == batch_size:
            batch, next_batch = next_batch, []
            yield batch
    if next_batch:
        yield next_batch


In [19]: %timeit [b for b in batchiter(range(1000), 3)]
1000 loops, best of 3: 644 µs per loop

In [20]: %timeit [b for b in grouper(3, range(1000))]
1000 loops, best of 3: 897 µs per loop

In [21]: %timeit [b for b in partition(range(1000), 3)]
1000 loops, best of 3: 890 µs per loop

In [22]: %timeit [b for b in batchiter(range(1000), 333)]
1000 loops, best of 3: 540 µs per loop

In [23]: %timeit [b for b in grouper(333, range(1000))]
10000 loops, best of 3: 81.7 µs per loop

In [24]: %timeit [b for b in partition(range(1000), 333)]
10000 loops, best of 3: 80.1 µs per loop

Answer 9

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