迭代列表切片

Question

我想要一个算法来迭代列表切片。切片大小在函数外部设置并且可以不同。

在我看来，它是这样的：

for list_of_x_items in fatherList:
    foo(list_of_x_items)

有没有办法正确定义 list_of_x_items 或使用 python 2.5 执行此操作的其他方式？

---

编辑1：澄清“分区”和“滑动窗口”术语听起来都适用于我的任务，但我不是专家。所以我将更深入地解释这个问题并添加到问题中：

fatherList 是我从文件中获取的多级 numpy.array 。函数必须找到系列的平均值（用户提供系列的长度）为了求平均值，我使用 mean() 函数。现在进行问题扩展：

edit2：如何修改您提供的函数来存储额外的项目，并在下一个fatherList输入到该函数时使用它们？

例如，如果列表的长度为 10 并且块的大小为 3，则存储列表的第 10 个成员并将其附加到下一个列表的开头。

---

相关：

• 什么是最“Pythonic”方式以块的形式迭代列表？

Answer 1

扩展@Ants Aasma的答案：在Python 3.7中，StopIteration异常的处理更改（根据 PEP-479< /a>）。兼容版本是：

from itertools import chain, islice

def ichunked(seq, chunksize):
    it = iter(seq)
    while True:
        try:
            yield chain([next(it)], islice(it, chunksize - 1))
        except StopIteration:
            return

Answer 2

你的问题可以使用更多细节，但是怎么样：

def iterate_over_slices(the_list, slice_size):
    for start in range(0, len(the_list)-slice_size):
        slice = the_list[start:start+slice_size]
        foo(slice)

Answer 3

对于一个近乎一个的衬垫（在itertools导入之后），按照Nadia的答案处理非块可整除尺寸而无需填充：

>>> import itertools as itt
>>> chunksize = 5
>>> myseq = range(18)
>>> cnt = itt.count()
>>> print [ tuple(grp) for k,grp in itt.groupby(myseq, key=lambda x: cnt.next()//chunksize%2)]
[(0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13, 14), (15, 16, 17)]

如果你愿意，你可以摆脱itertools.count () 要求使用 enumerate()，但比较丑陋：（

[ [e[1] for e in grp] for k,grp in itt.groupby(enumerate(myseq), key=lambda x: x[0]//chunksize%2) ]

在本例中，enumerate() 是多余的，但并非所有序列都是整齐的范围就像这样，显然）

远没有其他答案那么简洁，但在紧要关头很有用，特别是如果已经导入了itertools。

Answer 4

将列表或迭代器分割成给定大小的块的函数。如果最后一个块较小，也可以正确处理这种情况：

def slice_iterator(data, slice_len):
    it = iter(data)
    while True:
        items = []
        for index in range(slice_len):
            try:
                item = next(it)
            except StopIteration:
                if items == []:
                    return # we are done
                else:
                    break # exits the "for" loop
            items.append(item)
        yield items

用法示例：

for slice in slice_iterator([1,2,3,4,5,6,7,8,9,10],3):
    print(slice)

结果：

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

Answer 5

如果你想将列表分成切片，你可以使用这个技巧：

list_of_slices = zip(*(iter(the_list),) * slice_size)

例如，

>>> zip(*(iter(range(10)),) * 3)
[(0, 1, 2), (3, 4, 5), (6, 7, 8)]

如果项目的数量不能被切片大小整除，并且你想用 None 填充列表，你可以这样做：

>>> map(None, *(iter(range(10)),) * 3)
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, None, None)]

这是一个肮脏的小技巧

---

OK ，我将解释它是如何工作的。解释起来会很棘手，但我会尽力。

首先是一些背景知识：

在 Python 中，您可以将列表乘以数字，如下所示：

[1, 2, 3] * 3 -> [1, 2, 3, 1, 2, 3, 1, 2, 3]
([1, 2, 3],) * 3 -> ([1, 2, 3], [1, 2, 3], [1, 2, 3])

以及 迭代器 对象可以像这样使用一次：

>>> l=iter([1, 2, 3])
>>> l.next()
1
>>> l.next()
2
>>> l.next()
3

zip 函数返回一个元组列表，其中第 i 个元组包含每个参数序列或可迭代对象中的第 i 个元素。例如：

zip([1, 2, 3], [20, 30, 40]) -> [(1, 20), (2, 30), (3, 40)]
zip(*[(1, 20), (2, 30), (3, 40)]) -> [[1, 2, 3], [20, 30, 40]]

zip 前面的 * 用于解压参数。您可以在此处找到更多详细信息。
So

zip(*[(1, 20), (2, 30), (3, 40)])

实际上相当于

zip((1, 20), (2, 30), (3, 40))

但可以使用可变数量的参数

现在回到技巧：

list_of_slices = zip(*(iter(the_list),) * slice_size)

iter(the_list) ->将列表转换为迭代器

(iter(the_list),) * N ->将生成对 the_list 迭代器的 N 引用。

zip(*(iter(the_list),) * N) ->会将这些迭代器列表输入 zip 中。这又会将它们分组为 N 大小的元组。但由于所有 N 个项目实际上都是对同一个迭代器 iter(the_list) 的引用，因此结果将在原始迭代器上重复调用 next()

我希望能解释这一点。我建议您采用更容易理解的解决方案。我只是想提及这个技巧，因为我喜欢它。

Answer 6

如果您希望能够使用任何可迭代对象，您可以使用以下函数：

from itertools import chain, islice

def ichunked(seq, chunksize):
    """Yields items from an iterator in iterable chunks."""
    it = iter(seq)
    while True:
        yield chain([it.next()], islice(it, chunksize-1))

def chunked(seq, chunksize):
    """Yields items from an iterator in list chunks."""
    for chunk in ichunked(seq, chunksize):
        yield list(chunk)

Answer 7

使用生成器：

big_list = [1,2,3,4,5,6,7,8,9]
slice_length = 3
def sliceIterator(lst, sliceLen):
    for i in range(len(lst) - sliceLen + 1):
        yield lst[i:i + sliceLen]

for slice in sliceIterator(big_list, slice_length):
    foo(slice)

sliceIterator 在序列 lst 上实现宽度为 sliceLen 的“滑动窗口”，即它生成重叠切片：[1,2 ，3]，[2,3,4]，[3,4,5]，...但不确定这是否是OP的意图。

Answer 8

您的意思是：

def callonslices(size, fatherList, foo):
  for i in xrange(0, len(fatherList), size):
    foo(fatherList[i:i+size])

如果这大致是您想要的功能，如果您愿意，您可以在生成器中对其进行一些修饰：

def sliceup(size, fatherList):
  for i in xrange(0, len(fatherList), size):
    yield fatherList[i:i+size]

然后：

def callonslices(size, fatherList, foo):
  for sli in sliceup(size, fatherList):
    foo(sli)

Answer 9

回答问题的最后一部分：

问题更新：如何修改
您提供的存储函数
额外的物品并在以下情况下使用它们
下一个fatherList被馈送到
功能？

如果您需要存储状态，那么您可以使用对象来存储状态。

class Chunker(object):
    """Split `iterable` on evenly sized chunks.

    Leftovers are remembered and yielded at the next call.
    """
    def __init__(self, chunksize):
        assert chunksize > 0
        self.chunksize = chunksize        
        self.chunk = []

    def __call__(self, iterable):
        """Yield items from `iterable` `self.chunksize` at the time."""
        assert len(self.chunk) < self.chunksize
        for item in iterable:
            self.chunk.append(item)
            if len(self.chunk) == self.chunksize:
                # yield collected full chunk
                yield self.chunk
                self.chunk = [] 

示例：

chunker = Chunker(3)
for s in "abcd", "efgh":
    for chunk in chunker(s):
        print ''.join(chunk)

if chunker.chunk: # is there anything left?
    print ''.join(chunker.chunk)

输出：

abc
def
gh

Answer 10

我不确定，但你似乎想做所谓的移动平均线。 numpy 为此提供了工具（卷积函数）。

>>> x = numpy.array(range(20))
>>> x
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19])    
>>> n = 2 # moving average window
>>> numpy.convolve(numpy.ones(n)/n, x)[n-1:-n+1]
array([  0.5,   1.5,   2.5,   3.5,   4.5,   5.5,   6.5,   7.5,   8.5,
         9.5,  10.5,  11.5,  12.5,  13.5,  14.5,  15.5,  16.5,  17.5,  18.5])

好处是它可以很好地适应不同的权重方案（只需将 numpy.ones(n) / n 更改为其他内容即可）。

您可以在这里找到完整的材料：
http://www.scipy.org/Cookbook/SignalSmooth