Python 使用环绕遍历连续元素的所有对（或三元组）

我发现了许多类似的问题，但没有一个是环绕式的

我正在编写一些代码，其中有很多列表，其中一个项目连接到下面的项目，甚至是下面的项目和前面的项目。因此，我得到了很多这种模式，尽管有时我只使用

当前项目

和

后面的项目

，所以没有

前面的项目

适用于范围内的i（len（我的列表））：
当前_项=我的_列表[i]
以下项目=我的列表[（i+1）%len（我的列表）]
上一项=我的列表[（i-1）%len（我的列表）]

或者，使用

枚举

：

对于i，枚举（我的\u列表）中的当前\u项：
以下项目=我的列表[（i+1）%len（我的列表）]
上一项=我的列表[（i-1）%len（我的列表）]

---

对我来说，这两个都不是很“蟒蛇”。有没有一种很好的蟒蛇式的方法？我已经看到了一些相关问题的答案，这些问题的答案类似于

zip（我的列表，我的列表[1:]）

，但这并没有结束，我也没有看到一个很好的方法来扩展它以包括前一项。

可能您正在寻找类似的内容：

mylist = [1,2,3,4,5,6,7,8,9,10]
for previous, current, following in zip([mylist[-1]] + mylist[:-1], mylist, mylist[1:] + [mylist[0]]):
    print(previous, current, following)

from itertools import cycle

lst = [1, 2, 3]

pool = cycle(lst)

previous = lst[-1]
current = next(pool)
following = next(pool)

print(previous, current, following)
>>> 3 1 2

while True:
    previous, current = current, following
    following = next(pool)
    
    break

print(previous, current, following)
>>> 1 2 3

---

在这里，我只是简单地使用了zip和列表连接。

您可能正在寻找类似的内容：

mylist = [1,2,3,4,5,6,7,8,9,10]
for previous, current, following in zip([mylist[-1]] + mylist[:-1], mylist, mylist[1:] + [mylist[0]]):
    print(previous, current, following)

from itertools import cycle

lst = [1, 2, 3]

pool = cycle(lst)

previous = lst[-1]
current = next(pool)
following = next(pool)

print(previous, current, following)
>>> 3 1 2

while True:
    previous, current = current, following
    following = next(pool)
    
    break

print(previous, current, following)
>>> 1 2 3

---

这里我只是简单地使用了zip和列表连接。

请告诉我这是否是您想要的，但您可能想要的。您可以尝试以下方法：

mylist = [1,2,3,4,5,6,7,8,9,10]
for previous, current, following in zip([mylist[-1]] + mylist[:-1], mylist, mylist[1:] + [mylist[0]]):
    print(previous, current, following)

from itertools import cycle

lst = [1, 2, 3]

pool = cycle(lst)

previous = lst[-1]
current = next(pool)
following = next(pool)

print(previous, current, following)
>>> 3 1 2

while True:
    previous, current = current, following
    following = next(pool)
    
    break

print(previous, current, following)
>>> 1 2 3

现在，调用

next（pool）

总是会在一个循环中给出列表中的下一项，所以希望这就是您正在谈论的总结

---

打印语句当然只是为了显示列表中发生了什么，但正如您所看到的，1个循环的

while

循环将把列表中的每个变量向上移动一个。

请告诉我这是否是您想要的，但可能是您想要的。您可以尝试以下方法：

mylist = [1,2,3,4,5,6,7,8,9,10]
for previous, current, following in zip([mylist[-1]] + mylist[:-1], mylist, mylist[1:] + [mylist[0]]):
    print(previous, current, following)

from itertools import cycle

lst = [1, 2, 3]

pool = cycle(lst)

previous = lst[-1]
current = next(pool)
following = next(pool)

print(previous, current, following)
>>> 3 1 2

while True:
    previous, current = current, following
    following = next(pool)
    
    break

print(previous, current, following)
>>> 1 2 3

现在，调用

next（pool）

总是会在一个循环中给出列表中的下一项，所以希望这就是您正在谈论的总结

---

打印语句当然只是为了显示列表中发生了什么，但是正如您所看到的，1个循环的

，而
循环会将列表中的每个变量向上移动一个。
您的问题实际上归结为将最后一个元素添加到
上一个
中，将第一个元素添加到
下一个
。因此，您可以“展开”列表：

l=[1,2,3,4,5,6]
新的l=[l[-1]]+l+[l[0]]
对于zip中的上一个、当前、下一个（新的、新的、新的[2:]）：
打印（上一页、当前页、下一页）

将提供：

612
1 2 3
2 3 4
3 4 5
4 5 6
5 6 1

这使用了根据最短iterable（即原始的
l
）停止的事实


如果出于某种原因，需要在同一个列表上重复执行此操作，可以使用在列表上创建一个无休止的环绕迭代器：

来自itertools导入周期的

对于上一个，cur，zip中的下一个（循环（new_l[：-2]），循环（l），循环（new_l[2:]）：
打印（上一页、当前页、下一页）

这将提供：

612
1 2 3
2 3 4
3 4 5
4 5 6
5 6 1
6 1 2
1 2 3
...
您的问题实际上归结为将最后一个元素添加到上一个
元素，将第一个元素添加到下一个
。因此，您可以“展开”列表：

l=[1,2,3,4,5,6]
新的l=[l[-1]]+l+[l[0]]
对于zip中的上一个、当前、下一个（新的、新的、新的[2:]）：
打印（上一页、当前页、下一页）

将提供：

612
1 2 3
2 3 4
3 4 5
4 5 6
5 6 1

这使用了根据最短iterable（即原始的
l
）停止的事实


如果出于某种原因，需要在同一个列表上重复执行此操作，可以使用在列表上创建一个无休止的环绕迭代器：

来自itertools导入周期的

对于上一个，cur，zip中的下一个（循环（new_l[：-2]），循环（l），循环（new_l[2:]）：
打印（上一页、当前页、下一页）

这将提供：

612
1 2 3
2 3 4
3 4 5
4 5 6
5 6 1
6 1 2
1 2 3
...
我想知道是否可以更简洁地完成，但这似乎正是我想要的。谢谢。我想知道是否可以做得更简洁，但这似乎正是我想要的。谢谢