获取列表python中每个元素的下一个和上一个

Question

我有一个清单：

day_list = [1,2,3,4,5,6]

我想编写一个函数，该函数将从此列表中取任何数字（ no ）并返回下一个和上一个元素。

因此，例如，如果我通过2 ，我应该得到[1,3] （ 1是前一个元素，3是下一个元素 ）。

但是有一个问题：

如果no = 1则前一个元素应为6，类似地，如果no = 6下一个元素应为1

我想要类似的东西：

def getPrevNext(no):
    ....
    ....
    return [prev,next]

result = getPrevNext(2)  # result should be [1,3]
result2 = getPrevNext(5)  # result2 should be [4,5]
result3 = getPrevNext(1)  # result3 should be [6,2]
result4 = getPrevNext(6)  # result3 should be [5,1]

我试过了：

def dummy(no):
        if no == 1:
            prev_no = 6
            next_no = 2
        elif no == 6:
            prev_no = 5
            next_no = 1
        else:
            prev_no = no - 1
            next_no = no + 1
        return [prev_no,next_no]

但这似乎是一种非常幼稚且基本的方法。是否有更好的方法来做到这一点？

仅供参考，无需填写天数，仅用于了解总数。

Answer 1

@ juanpa.arrivillaga的答案很好地涵盖了该问题的细节（这是有关如何使用模算术的问题）。 但是，在访问任何列表的上一个和下一个元素的一般情况下，这就是我的处理方式-

def getPrevNext(l, no):
    i = l.index(no)
    return [l[i - 1], l[(i + 1) % len(l)]]

days = list(range(1, 7))

getPrevNext(days, 2)
[1, 3]

getPrevNext(days, 1)
[6, 2]

getPrevNext(days, 6)
[5, 1]

第一个表达式l[i - 1]利用python使用负索引访问元素的能力。 第二个表达式l[(i + 1) % len(l)]是常见的循环列表访问习惯用法。

要返回元组而不是列表，请在return语句中放置方括号-

def getPrevNextAsTuple(l, no):
    i = l.index(no)
    return l[i - 1], l[(i + 1) % len(l)]

---

请注意，这不能解决no不在列表中的可能性。 在这种情况下，您将使用异常处理之类的方法来捕获任何ValueError引发的错误-

def getPrevNext(l, no):
    try:
        i = l.index(no)
    except ValueError:
        return None

    return l[i - 1], l[(i + 1) % len(l)]

Answer 2

如果您使用的是编码为1-6的“天”，请使用以下代码：

>>> def prev_next_day(day):
...     day -= 1
...     prev = ((day - 1) % 6) + 1
...     next_ = ((day + 1) % 6) + 1
...     return [prev, next_]
...
>>> prev_next_day(2)
[1, 3]
>>> prev_next_day(5)
[4, 6]
>>> prev_next_day(1)
[6, 2]
>>> prev_next_day(6)
[5, 1]

Answer 3

您可以像下面这样使用slicing （也可以选择使用mod进行修饰 ）：

day_list = [1,2,3,4,5,6]

def get_prev_next(my_list, no):
  try:
    pointer = my_list.index(no)
  except ValueError:
    return []
  else:
    return [my_list[pointer-1], my_list[(pointer+1) % len(my_list)]]

---

例子：

# first element
print(get_prev_next(day_list, 1))   # -> [6, 2]

# last element
print(get_prev_next(day_list, 6))   # -> [5, 1]

# any other
print(get_prev_next(day_list, 3))   # -> [2, 4]

# non-existent element
print(get_prev_next(day_list, 98))  # -> []    

Answer 4

我会说以下作品：

def getPrevNext(no):
    day_list = [1, 2, 3, 4, 5, 6]
    return([day_list[(no-2) % 6], day_list[(no) % 6]])

根据您是否还只接受1 <= no <= 6 ，可以向此函数添加条件，如下所示：

def getPrevNext(no):
    day_list = [1, 2, 3, 4, 5, 6]
    return([day_list[(no-2) % 6], day_list[(no) % 6]] if 1 <= no <= 6 else 0)

Answer 5

def getem(lst,element):
index=lst.index(element)
try:
    if index!=0 and index!=(len(lst)-1):
        return [lst[index-1],lst[index+1]]
    else:
        if index==0:
            return [lst[len(lst)-1],lst[index+1]]
        else:
            return [lst[index-1],lst[0]]
except Exception as e:
print("element does not exists")

尝试此功能，或者您可以在此功能中使用循环链接列表，我已经模仿了该行为

Answer 6

您确定需要几天的清单吗？

def f(n):
    assert 0<n<7, "numbers should be between 1 and 6"
    return n-1 if n!=1 else 6, n+1 if n!=6 else 1
f(1)
#result (6, 2)

Answer 7

我认为您提到的trick以循环链接列表而闻名。 如果我错了，请纠正我。

day_list = [1,2,3,4,5,6] 
def get_prev_next(elem):
    if elem not in day_list:
       return False     # element not found
    index = day_list.index(elem)
    return day_list[i - 1], l[(i + 1) % len(day_list)]

Answer 8

对于上一个 ，您可以利用以下事实：对列表建立索引时，负索引表示“ 从最后一个元素开始为负 ”。 它帮助我将[-1]视为“溢出”，这意味着转到第一个元素（索引0 ）并从最后一个元素开始计数。

接下来 ，您可以使用模（％）运算符，以确保索引保持在0到len(days_list) 。 仅在要计算下一个数字的索引是列表的最后一个元素（索引5 ， day_list值6 ）的情况下，这才是至关重要的。 仅将+1加到索引5会使您进入6 ，这不是有效的index 。 但是随后您得到了6 % 6的模块，并且“成为” 0 。

day_list = [1, 2, 3, 4, 5, 6]


def find(thing):
    position = day_list.index(thing)
    prev_pos = day_list[position - 1]
    next_pos = day_list[(position + 1) % len(day_list)]
    return prev_pos, next_pos


if __name__ == "__main__":
    for i in range(1, 7):
        print("prev_next %s: %s" % (i, find(i)))

输出：

prev_next 1: (6, 2)
prev_next 2: (1, 3)
prev_next 3: (2, 4)
prev_next 4: (3, 5)
prev_next 5: (4, 6)
prev_next 6: (5, 1)