问题很简单，我想迭代遍历列表中的每个元素和成对的下一个元素（用最后一个元素包装第一个元素）。
我已经考虑过两种非语言方式：
def pairs(lst):
n = len(lst)
for i in range(n):
yield lst[i],lst[(i+1)%n]
和
def pairs(lst):
return zip(lst,lst[1:]+[lst[:1]])
预期产出：
>>> for i in pairs(range(10)):
print i
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
(5, 6)
(6, 7)
(7, 8)
(8, 9)
(9, 0)
>>>
关于更多pythonic方式的任何建议吗？也许有一个我没有听说过的预定义函数？
也是一个更普遍的n-fold（有三胞胎，四重奏等，而不是成对）版本可能很有趣。
答案 0 :(得分：27)
def pairs(lst):
i = iter(lst)
first = prev = item = i.next()
for item in i:
yield prev, item
prev = item
yield item, first
适用于任何非空序列，无需索引。
答案 1 :(得分：9)
我自己编写了元组通用版本，我喜欢第一个版本，因为它的简洁，我看得越多，它对我的感觉就越多......毕竟，Pythonic比一个更多带拉链的衬里，星号参数扩展，列表推导，列表切片，列表连接和“范围”？
def ntuples(lst, n):
return zip(*[lst[i:]+lst[:i] for i in range(n)])
即使对于大型列表，itertools版本也应该足够高效......
from itertools import *
def ntuples(lst, n):
return izip(*[chain(islice(lst,i,None), islice(lst,None,i)) for i in range(n)])
非可索引序列的版本：
from itertools import *
def ntuples(seq, n):
iseq = iter(seq)
curr = head = tuple(islice(iseq, n))
for x in chain(iseq, head):
yield curr
curr = curr[1:] + (x,)
无论如何，感谢大家的建议！ ： - ）
答案 2 :(得分：6)
我一如既往地喜欢开球：
from itertools import tee, izip, chain
def pairs(iterable):
a, b = tee(iterable)
return izip(a, chain(b, [next(b)]))
答案 3 :(得分：5)
这可能是令人满意的：
def pairs(lst):
for i in range(1, len(lst)):
yield lst[i-1], lst[i]
yield lst[-1], lst[0]
>>> a = list(range(5))
>>> for a1, a2 in pairs(a):
... print a1, a2
...
0 1
1 2
2 3
3 4
4 0
如果你喜欢这种东西，请查看wordaligned.org上的python文章。作者对python中的生成器特别喜欢。
答案 4 :(得分：2)
我会这样做（主要是因为我可以读到这个）：
class Pairs(object):
def __init__(self, start):
self.i = start
def next(self):
p, p1 = self.i, self.i + 1
self.i = p1
return p, p1
def __iter__(self):
return self
if __name__ == "__main__":
x = Pairs(0)
y = 1
while y < 20:
print x.next()
y += 1
给出：
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
(5, 6)
(6, 7)
(7, 8)
(8, 9)
答案 5 :(得分：1)
[(i,(i+1)%len(range(10))) for i in range(10)]
用您想要的列表替换范围（10）。
一般来说，“循环索引”在python中非常容易;只需使用：
a[i%len(a)]
答案 6 :(得分：0)
回答关于解决一般情况的问题：
import itertools
def pair(series, n):
s = list(itertools.tee(series, n))
try:
[ s[i].next() for i in range(1, n) for j in range(i)]
except StopIteration:
pass
while True:
result = []
try:
for j, ss in enumerate(s):
result.append(ss.next())
except StopIteration:
if j == 0:
break
else:
s[j] = iter(series)
for ss in s[j:]:
result.append(ss.next())
yield result
输出如下：
>>> for a in pair(range(10), 2):
... print a
...
[0, 1]
[1, 2]
[2, 3]
[3, 4]
[4, 5]
[5, 6]
[6, 7]
[7, 8]
[8, 9]
[9, 0]
>>> for a in pair(range(10), 3):
... print a
...
[0, 1, 2]
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]
[5, 6, 7]
[6, 7, 8]
[7, 8, 9]
[8, 9, 0]
[9, 0, 1]
答案 7 :(得分：0)
这无限循环，无论好坏，但在算法上非常清楚。
from itertools import tee, cycle
def nextn(iterable,n=2):
''' generator that yields a tuple of the next n items in iterable.
This generator cycles infinitely '''
cycled = cycle(iterable)
gens = tee(cycled,n)
# advance the iterators, this is O(n^2)
for (ii,g) in zip(xrange(n),gens):
for jj in xrange(ii):
gens[ii].next()
while True:
yield tuple([x.next() for x in gens])
def test():
data = ((range(10),2),
(range(5),3),
(list("abcdef"),4),)
for (iterable, n) in data:
gen = nextn(iterable,n)
for j in range(len(iterable)+n):
print gen.next()
test()
给出：
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
(5, 6)
(6, 7)
(7, 8)
(8, 9)
(9, 0)
(0, 1)
(1, 2)
(0, 1, 2)
(1, 2, 3)
(2, 3, 4)
(3, 4, 0)
(4, 0, 1)
(0, 1, 2)
(1, 2, 3)
(2, 3, 4)
('a', 'b', 'c', 'd')
('b', 'c', 'd', 'e')
('c', 'd', 'e', 'f')
('d', 'e', 'f', 'a')
('e', 'f', 'a', 'b')
('f', 'a', 'b', 'c')
('a', 'b', 'c', 'd')
('b', 'c', 'd', 'e')
('c', 'd', 'e', 'f')
('d', 'e', 'f', 'a')
答案 8 :(得分：0)
更短版本的Fortran的zip *范围解决方案（这次使用lambda;）：
group = lambda t, n: zip(*[t[i::n] for i in range(n)])
group([1, 2, 3, 3], 2)
给出：
[(1, 2), (3, 4)]
答案 9 :(得分：0)
这是一个支持可选启动索引的版本（例如，返回（4,0）作为第一对，使用start = -1：
import itertools
def iterrot(lst, start = 0):
if start == 0:
i = iter(lst)
elif start > 0:
i1 = itertools.islice(lst, start, None)
i2 = itertools.islice(lst, None, start)
i = itertools.chain(i1, i2)
else:
# islice doesn't support negative slice indices so...
lenl = len(lst)
i1 = itertools.islice(lst, lenl + start, None)
i2 = itertools.islice(lst, None, lenl + start)
i = itertools.chain(i1, i2)
return i
def iterpairs(lst, start = 0):
i = iterrot(lst, start)
first = prev = i.next()
for item in i:
yield prev, item
prev = item
yield prev, first
def itertrios(lst, start = 0):
i = iterrot(lst, start)
first = prevprev = i.next()
second = prev = i.next()
for item in i:
yield prevprev, prev, item
prevprev, prev = prev, item
yield prevprev, prev, first
yield prev, first, second
答案 10 :(得分：0)
def pairs(ex_list):
for i, v in enumerate(ex_list):
if i < len(list) - 1:
print v, ex_list[i+1]
else:
print v, ex_list[0]
Enumerate返回一个带有索引号和值的元组。我打印列表ex_list[i+1]的值和以下元素。 if i < len(list) - 1表示v是不列表的最后一个成员。如果是：print v和列表print v, ex_list[0]的第一个元素。
您可以让它返回一个列表。只需将打印的元组附加到列表中并将其返回。
def pairs(ex_list):
result = []
for i, v in enumerate(ex_list):
if i < len(list) - 1:
result.append((v, ex_list[i+1]))
else:
result.append((v, ex_list[0]))
return result
答案 11 :(得分：0)
当然，您始终可以使用 deque ：
from collections import deque
from itertools import *
def pairs(lst, n=2):
itlst = iter(lst)
start = list(islice(itlst, 0, n-1))
deq = deque(start, n)
for elt in chain(itlst, start):
deq.append(elt)
yield list(deq)
答案 12 :(得分：-1)
i=(range(10))
for x in len(i):
print i[:2]
i=i[1:]+[i[1]]
比这更不可能是pythonic