我希望有一个可以迭代列表切片的算法。切片的大小在函数外部设定并且可能不同。
在我的想象中，它应该是这样的：
for list_of_x_items in fatherList:
foo(list_of_x_items)
list_of_x_items或其他使用Python 2.5实现的方式？
edit1: Clarification，“分区”和“滑动窗口”这两个术语似乎都适用于我的任务，但我不是专家。因此，我将更深入地解释问题并添加到问题中：mean()函数。现在为了扩展问题：
edit2:如何修改您提供的函数以存储额外的项目，并在下一个fatherList被馈送到函数时使用它们？如果您想将列表切片，可以使用以下技巧：
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)]
这是一个不太光彩的小技巧。
好的，我来解释一下它是如何工作的。虽然解释起来可能有点棘手，但我会尽力的。
首先讲一下背景：
在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])
迭代器对象可以像这样被消耗掉一次：
And an iterator object can be consumed once like this:
>>> 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前面的星号用于解包参数。你可以在这里找到更多详细信息。
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 -> 会生成 N 个对 the_list 迭代器的引用。
zip(*(iter(the_list),) * N) -> 将这些迭代器列表传递给 zip 函数，zip 函数将把它们分组成大小为 N 的元组。但是由于所有 N 个项实际上都是对同一个迭代器 iter(the_list) 的引用，所以结果将重复调用原始迭代器上的 next()。
希望这能解释清楚。我建议您选择更易理解的解决方案。我只是想提及这个技巧，因为我喜欢它。
f(*([1]+g()))。 - ThomasHfrom 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)
next(it)而不是it.next()。对于那些想知道的人：islice不会引发StopIteration异常，这就是为什么我们要调用next的原因。 - Tim-Erwinnext(it) 更改为 ichunked，但是我收到了警告 DeprecationWarning: generator 'ichunked' raised StopIteration。我不明白这是在哪里引发的，因为它不是显式的。 - davidAnext() 中引发的。这在 Python 3.5 及以下版本中是预期的，在 3.6 中已弃用，在 3.7 中已损坏。我在答案中添加了一个与 3.7+ 兼容的版本。 - Tim-Erwin使用生成器：
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 实现了一个宽度为 sliceLen 的“滑动窗口”在序列 lst 上，即它产生重叠的切片：[1,2,3]、[2,3,4]、[3,4,5]... 不确定这是否是OP的意图。
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)
size，除了最后一个可能会有所不同——且不重叠。当长度为6且大小为7时，请思考您的代码会发生什么......有5个不同长度的切片...... - Alex Martelli问题更新：如何修改您提供的函数以存储额外项目，并在下一个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
__call__ 可能会被调用多次，因此您不能在 for 循环后仅仅产生剩余项。这就是类的意义所在。它回答了问题中明确说明的部分：“在下一个 fatherList 被提供给函数时存储额外的项目并使用它们”。 - jfsnumpy.ones(n) / n更改为其他内容）。你的问题需要更多细节，但是如下回答可能会有所帮助：
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)
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)]
enumerate()来替代itertools.count()的要求，但是代码会变得更加丑陋：[ [e[1] for e in grp] for k,grp in itt.groupby(enumerate(myseq), key=lambda x: x[0]//chunksize%2) ]
enumerate() 是多余的，但不是所有的序列都像这样整齐，显然。itertools。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]