我正在尝试用Python编写Haskel函数'splitEvery'。这是它的定义：
splitEvery :: Int -> [e] -> [[e]]
@'splitEvery' n@ splits a list into length-n pieces. The last
piece will be shorter if @n@ does not evenly divide the length of
the list.
这个的基本版本工作正常，但我想要一个适用于生成器表达式，列表和迭代器的版本。 和，如果有一个生成器作为输入，它应该返回一个生成器作为输出！
# should not enter infinite loop with generators or lists
splitEvery(itertools.count(), 10)
splitEvery(range(1000), 10)
# last piece must be shorter if n does not evenly divide
assert splitEvery(5, range(9)) == [[0, 1, 2, 3, 4], [5, 6, 7, 8]]
# should give same correct results with generators
tmp = itertools.islice(itertools.count(), 10)
assert list(splitEvery(5, tmp)) == [[0, 1, 2, 3, 4], [5, 6, 7, 8]]
这是我目前拥有的代码，但它不适用于简单的列表。
def splitEvery_1(n, iterable):
res = list(itertools.islice(iterable, n))
while len(res) != 0:
yield res
res = list(itertools.islice(iterable, n))
这个不适用于生成器表达式（感谢使用软糖来修复它）：
def splitEvery_2(n, iterable):
return [iterable[i:i+n] for i in range(0, len(iterable), n)]
必须有一段简单的代码来完成拆分。我知道我可以有不同的功能，但它似乎应该是容易的事情。我可能会陷入一个不重要的问题，但这真的让我烦恼。
它类似于来自http://docs.python.org/library/itertools.html#itertools.groupby的石斑鱼，但我不希望它填充额外的值。
def grouper(n, iterable, fillvalue=None):
"grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
args = [iter(iterable)] * n
return izip_longest(fillvalue=fillvalue, *args)
确实提到了截断最后一个值的方法。这不是我想要的。
保证了迭代的从左到右的评估顺序。这使得使用izip（* [iter（s）] * n）将数据系列聚类成n长度组的习惯成为可能。
list(izip(*[iter(range(9))]*5)) == [[0, 1, 2, 3, 4]]
# should be [[0, 1, 2, 3, 4], [5, 6, 7, 8]]
答案 0 :(得分：45)
from itertools import islice
def split_every(n, iterable):
i = iter(iterable)
piece = list(islice(i, n))
while piece:
yield piece
piece = list(islice(i, n))
一些测试：
>>> list(split_every(5, range(9)))
[[0, 1, 2, 3, 4], [5, 6, 7, 8]]
>>> list(split_every(3, (x**2 for x in range(20))))
[[0, 1, 4], [9, 16, 25], [36, 49, 64], [81, 100, 121], [144, 169, 196], [225, 256, 289], [324, 361]]
>>> [''.join(s) for s in split_every(6, 'Hello world')]
['Hello ', 'world']
>>> list(split_every(100, []))
[]
答案 1 :(得分：19)
这是一个快速的单行版本。和Haskell一样，它很懒惰。
from itertools import islice, takewhile, repeat
split_every = (lambda n, it:
takewhile(bool, (list(islice(it, n)) for _ in repeat(None))))
这要求您在调用iter之前使用split_every 。
示例：
list(split_every(5, iter(xrange(9))))
[[0, 1, 2, 3, 4], [5, 6, 7, 8]]
虽然不是单行，但以下版本并不要求您致电iter这可能是一个常见的陷阱。
from itertools import islice, takewhile, repeat
def split_every(n, iterable):
"""
Slice an iterable into chunks of n elements
:type n: int
:type iterable: Iterable
:rtype: Iterator
"""
iterator = iter(iterable)
return takewhile(bool, (list(islice(iterator, n)) for _ in repeat(None)))
（感谢@ eli-korvigo的改进。）
答案 2 :(得分：6)
基于已接受的答案并采用鲜为人知的iter使用（当传递第二个arg时，它会调用第一个直到它收到第二个），你可以很容易地做到这一点：< / p>
python3：
from itertools import islice
def split_every(n, iterable):
iterable = iter(iterable)
yield from iter(lambda: list(islice(iterable, n)), [])
python2：
def split_every(n, iterable):
iterable = iter(iterable)
for chunk in iter(lambda: list(islice(iterable, n)), []):
yield chunk
答案 3 :(得分：6)
more_itertools有一个chunked函数：
import more_itertools as mit
list(mit.chunked(range(9), 5))
# [[0, 1, 2, 3, 4], [5, 6, 7, 8]]
答案 4 :(得分：3)
一个单行的，可内联的解决方案（支持v2 / v3，迭代器，使用标准库和单个生成器理解）：
import itertools
def split_groups(iter_in, group_size):
return ((x for _, x in item) for _, item in itertools.groupby(enumerate(iter_in), key=lambda x: x[0] // group_size))
答案 5 :(得分：2)
改变一点点去裁剪最后一个，我认为对于生成器案例的一个很好的解决方案是：
from itertools import *
def iter_grouper(n, iterable):
it = iter(iterable)
item = itertools.islice(it, n)
while item:
yield item
item = itertools.islice(it, n)
对于支持切片（列表，字符串，元组）的对象，我们可以这样做：
def slice_grouper(n, sequence):
return [sequence[i:i+n] for i in range(0, len(sequence), n)]
现在只需要调度正确的方法：
def grouper(n, iter_or_seq):
if hasattr(iter_or_seq, "__getslice__"):
return slice_grouper(n, iter_or_seq)
elif hasattr(iter_or_seq, "__iter__"):
return iter_grouper(n, iter_or_seq)
我认为你可以稍微改进一下： - ）
答案 6 :(得分：2)
我遇到了这个问题，因为我也试图切断批次，但是从流中的发电机上进行，所以这里的大多数解决方案都不适用，或者不适用在python 3中。
对于仍然磕磕绊绊的人来说，这是使用itertools的一般解决方案：
from itertools import islice, chain
def iter_in_slices(iterator, size=None):
while True:
slice_iter = islice(iterator, size)
# If no first object this is how StopIteration is triggered
peek = next(slice_iter)
# Put the first object back and return slice
yield chain([peek], slice_iter)
答案 7 :(得分：1)
为什么不这样做呢？看起来几乎就像您的splitEvery_2功能。
def splitEveryN(n, it):
return [it[i:i+n] for i in range(0, len(it), n)]
实际上它只会从解决方案中的切片中消除不必要的步骤间隔。 ：）
答案 8 :(得分：1)
这是一个适用于列表和生成器的答案：
from itertools import count, groupby
def split_every(size, iterable):
c = count()
for k, g in groupby(iterable, lambda x: next(c)//size):
yield list(g) # or yield g if you want to output a generator
答案 9 :(得分：0)
以下是处理list vs iterator的方法：
def isList(L): # Implement it somehow - returns True or false
...
return (list, lambda x:x)[int(islist(L))](result)
答案 10 :(得分：0)
def chunks(iterable,n):
"""assumes n is an integer>0
"""
iterable=iter(iterable)
while True:
result=[]
for i in range(n):
try:
a=next(iterable)
except StopIteration:
break
else:
result.append(a)
if result:
yield result
else:
break
g1=(i*i for i in range(10))
g2=chunks(g1,3)
print g2
'<generator object chunks at 0x0337B9B8>'
print list(g2)
'[[0, 1, 4], [9, 16, 25], [36, 49, 64], [81]]'
答案 11 :(得分：-1)
这将解决问题
from itertools import izip_longest
izip_longest(it[::2], it[1::2])
其中* it *是可迭代的
示例：
izip_longest('abcdef'[::2], 'abcdef'[1::2]) -> ('a', 'b'), ('c', 'd'), ('e', 'f')
让我们打破这个
'abcdef'[::2] -> 'ace'
'abcdef'[1::2] -> 'bdf'
正如您所看到的那样，切片中的最后一个数字是指定用于拾取项目的间隔。您可以阅读有关使用扩展切片here的更多信息。
zip函数从第一个iterable中获取第一个项目，并将其与第一个项目与第二个iterable组合。然后，zip函数对第二个和第三个项执行相同的操作，直到其中一个迭代用完了值。
结果是一个迭代器。如果需要列表，请在结果上使用list（）函数。
答案 12 :(得分：-1)
如果你想要一个解决方案
这就是诀窍：
def one_batch(first_value, iterator, batch_size):
yield first_value
for i in xrange(1, batch_size):
yield iterator.next()
def batch_iterator(iterator, batch_size):
iterator = iter(iterator)
while True:
first_value = iterator.next() # Peek.
yield one_batch(first_value, iterator, batch_size)
它通过查看迭代器中的下一个值并将其作为第一个值传递给将生成它的生成器（one_batch()）以及批处理的其余部分来工作。
当输入迭代器耗尽并且没有更多批次时，peek步骤将准确引发StopIteration。由于这是在StopIteration方法中引发batch_iterator()的正确时间，因此无需捕获异常。
这将分批处理stdin中的行：
for input_batch in batch_iterator(sys.stdin, 10000):
for line in input_batch:
process(line)
finalise()
我发现这对于处理大量数据并将结果批量上传到外部商店非常有用。