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

我有一份清单：

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]

但这似乎是一种非常幼稚和基本的方法。。有更好的方法吗

---

仅供参考不需要的天数列表，这只是为了了解总天数。

您确定需要天数列表吗

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)

def（n）：
assert 0很好地涵盖了这个问题的细节（这是一个关于如何使用模运算的问题）。然而，在访问任何列表的上一个和下一个元素的一般情况下，我会这样做-

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


第一个表达式
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
s-

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

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

如果您使用编码为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]

您只需使用
切片
（为了美观，还可以选择使用mod），如下所示：


示例：

# 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))  # -> []    

我想你提到的
技巧
就是著名的循环链表。如果我错了，请纠正我

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)]

对于前面的例子，您可以利用这样一个事实，即在索引列表时，负索引意味着“从最后一个元素开始为负”。这有助于我将
[-1]
视为“溢出”，这意味着转到第一个元素（索引
0
）并从最后一个元素开始计数

接下来，您可以使用操作符，确保索引保持在
0
和
len（天数列表）
之间。仅当要计算下一个的数字的索引是列表的最后一个元素时（索引
5
，值
6
，在
day\u列表中
）。只需将
+1
添加到索引
5
就会将您放入
6
，这不是有效的
索引。但是你得到了
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)

我要说的是以下工作：

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

取决于您是否也只接受
1
试试这个函数，或者你可以在这个函数中使用循环链表，我模仿了这个行为
为什么6是6的下一个呢？你从来没有在
dummy（）
@timgeb中访问过
day\u list
，这是一个打字错误，因为在代码中，6后面的下一项是1。@timgeb 6的下一项是1，您应该创建一个循环列表数据结构。天数列表不是必需的，这只是为了理解总数。请验证我的代码是否满足您的要求。没问题。无论如何，到目前为止你有3个答案。看看什么最适合你，或者把答案结合起来；）查找
prev
不需要%6，因为访问为负。@cᴏʟᴅsᴘᴇᴇᴅ 没有切片正在进行。。。最初的问题描述有误导性，这是关于编码为1-6的前几天和后几天的问题，而不是一般列表的问题。@cᴏʟᴅsᴘᴇᴇᴅ 是的，min day=1和max=6，它将不是一个常规列表，您可以从列表中删除list参数function@cᴏʟᴅsᴘᴇᴇᴅ 不，没有名单。本质上，问题是如何做模运算…@cᴏʟᴅsᴘᴇᴇᴅ 嗯，这个标题很容易让人误解。你的意思是
return
行上的
len（l）
。你正在返回一个元组。抱歉吹毛求疵，这是出于好意。我其实是个粉丝：）
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)

def getPrevNext(no):
    day_list = [1, 2, 3, 4, 5, 6]
    return([day_list[(no-2) % 6], day_list[(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)

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")