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's answer很好地涵盖了这个问题的细节（这是关于如何使用模运算的问题）。但是，在访问任何列表的上一个和下一个元素的一般情况下，我就是这样做的 -

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

如果您正在使用＆＃34; days＆＃34;编码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

您可以使用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)]]（以及可选的，优雅， 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))  # -> []

<强>示例：

{{1}}

Answer 4

我会说以下作品：

JSONobject

根据您是否也只接受@GET("/stockers/login") Call<JsonElement> getLogin( @Query("email") String email, @Query("password") String password );，您可以像这样为此函数添加条件：

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

Answer 5

1 <= no <= 6

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

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

对于之前的，您可以利用以下事实：在索引列表时，负索引意味着＆＃34; 从最后一个元素开始＆＃34 ;。它帮助我思考[-1] as＆＃34;溢出＆＃34;，这意味着转到第一个元素（索引0）并从最后一个元素开始计数。

对于 next ，您可以使用modulo (%)运算符，以确保将索引保持在0和len(days_list)之间。只有在您想要计算下一个数字的索引是列表的最后一个元素（索引5，6中的值day_list）时，这才是至关重要的。只需将+1添加到索引5，您就会进入6，这不是有效的 index 。但是你得到了6 % 6的模块，并且＆＃34;变为＆＃34; 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)

获取列表python

8 个答案: