我有一个Python脚本，它把一个整数列表作为输入，我需要一次处理四个整数。不幸的是，我无法控制输入，否则我将它作为一个四元素元组列表传入。目前，我以这种方式迭代它:
for i in range(0, len(ints), 4):
# dummy op for example code
foo += ints[i] * ints[i + 1] + ints[i + 2] * ints[i + 3]
不过，它看起来很像“C-think”，这让我怀疑有一种更python的方式来处理这种情况。该列表在迭代后被丢弃，因此不需要保留。也许这样会更好?
while ints:
foo += ints[0] * ints[1] + ints[2] * ints[3]
ints[0:4] = []
不过，感觉还是不太对。: - /
相关问题:在Python中如何将列表分割成大小均匀的块?
当前回答
要避免所有到列表的转换，请导入itertools和:
>>> for k, g in itertools.groupby(xrange(35), lambda x: x/10):
... list(g)
生产:
...
0 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1 [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
2 [20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
3 [30, 31, 32, 33, 34]
>>>
我检查了groupby，它不转换为列表或使用len，所以我(认为)这将延迟每个值的解析，直到它实际使用。不幸的是，没有一个现成的答案(在这个时候)似乎提供了这种变化。
显然，如果你需要依次处理每一项，在g上嵌套一个for循环:
for k,g in itertools.groupby(xrange(35), lambda x: x/10):
for i in g:
# do what you need to do with individual items
# now do what you need to do with the whole group
我对此特别感兴趣的是需要消耗一个生成器，以批量提交最多1000个更改到gmail API:
messages = a_generator_which_would_not_be_smart_as_a_list
for idx, batch in groupby(messages, lambda x: x/1000):
batch_request = BatchHttpRequest()
for message in batch:
batch_request.add(self.service.users().messages().modify(userId='me', id=message['id'], body=msg_labels))
http = httplib2.Http()
self.credentials.authorize(http)
batch_request.execute(http=http)
其他回答
另一种方法是使用双参数形式的iter:
from itertools import islice
def group(it, size):
it = iter(it)
return iter(lambda: tuple(islice(it, size)), ())
这可以很容易地适应使用填充(这类似于Markus Jarderot的答案):
from itertools import islice, chain, repeat
def group_pad(it, size, pad=None):
it = chain(iter(it), repeat(pad))
return iter(lambda: tuple(islice(it, size)), (pad,) * size)
这些甚至可以组合为可选的填充:
_no_pad = object()
def group(it, size, pad=_no_pad):
if pad == _no_pad:
it = iter(it)
sentinel = ()
else:
it = chain(iter(it), repeat(pad))
sentinel = (pad,) * size
return iter(lambda: tuple(islice(it, size)), sentinel)
似乎没有一个漂亮的方法来做到这一点。下面是一个有很多方法的页面，包括:
def split_seq(seq, size):
newseq = []
splitsize = 1.0/size*len(seq)
for i in range(size):
newseq.append(seq[int(round(i*splitsize)):int(round((i+1)*splitsize))])
return newseq
这个问题的理想解决方案是使用迭代器(而不仅仅是序列)。它还应该是快速的。
这是itertools文档提供的解决方案:
def grouper(n, iterable, fillvalue=None):
#"grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
args = [iter(iterable)] * n
return itertools.izip_longest(fillvalue=fillvalue, *args)
在我的mac book air上使用ipython的%timeit，我每次循环得到47.5 us。
然而，这真的不适合我，因为结果被填充为偶数大小的组。没有填充的解决方案稍微复杂一些。最天真的解决方案可能是:
def grouper(size, iterable):
i = iter(iterable)
while True:
out = []
try:
for _ in range(size):
out.append(i.next())
except StopIteration:
yield out
break
yield out
简单，但相当慢:每循环693个
我能想到的最好的解决方案是使用islice进行内循环:
def grouper(size, iterable):
it = iter(iterable)
while True:
group = tuple(itertools.islice(it, None, size))
if not group:
break
yield group
对于同样的数据集，我每循环得到305 us。
由于无法更快地得到一个纯粹的解决方案，我提供了以下解决方案，但有一个重要的警告:如果您的输入数据中有filldata的实例，则可能会得到错误的答案。
def grouper(n, iterable, fillvalue=None):
#"grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
args = [iter(iterable)] * n
# itertools.zip_longest on Python 3
for x in itertools.izip_longest(*args, fillvalue=fillvalue):
if x[-1] is fillvalue:
yield tuple(v for v in x if v is not fillvalue)
else:
yield x
我真的不喜欢这个答案，但它明显更快。每回路124 us
类似于其他提案，但不完全相同，我喜欢这样做，因为它简单易读:
it = iter([1, 2, 3, 4, 5, 6, 7, 8, 9])
for chunk in zip(it, it, it, it):
print chunk
>>> (1, 2, 3, 4)
>>> (5, 6, 7, 8)
这样你就不会得到最后一部分。如果你想获取(9,None, None, None)作为最后一个块，只需使用itertools中的izip_longest。
使用map()而不是zip()修复填充问题在J.F.塞巴斯蒂安的回答:
>>> def chunker(iterable, chunksize):
... return map(None,*[iter(iterable)]*chunksize)
例子:
>>> s = '1234567890'
>>> chunker(s, 3)
[('1', '2', '3'), ('4', '5', '6'), ('7', '8', '9'), ('0', None, None)]
>>> chunker(s, 4)
[('1', '2', '3', '4'), ('5', '6', '7', '8'), ('9', '0', None, None)]
>>> chunker(s, 5)
[('1', '2', '3', '4', '5'), ('6', '7', '8', '9', '0')]
