Возвратите подсписок из списка, где последний элемент ссылается на начальный индекс в списке

Question

Как вы можете вернуть подсписок из списка, возвращающего 3 последовательных элемента, где последний элемент ссылается на первый, если в списке есть какой-либо индекс?

Например, данный индекс 3 для list = [1,2,3,4,5] вернет [4,5,1]. Или данный индекс 4 со списком = [1,2,3,4,5] вернет [5,1,2].

Опции у меня есть:

1. return list[index:] + list[:index+3]
2. return list[index:index+3] + list[:len(list)-index]
3. return list[index+3:] + list[:len(list)-index]
4. return list[index:index+3] + list[:max(0 , -1*(len(list)-index-3))]

Answer 1

Есть и другие способы. Например, вы можете использовать collections.deque через deque.rotate, а затем использовать itertools.islice:

from collections import deque
from itertools import islice

L = [1,2,3,4,5]
k, n = -3, 3

dq = deque(L)
dq.rotate(k)
res = list(islice(dq, 0, n))

[4, 5, 1]

Answer 2

Я предлагаю один метод, но это включает в себя создание списка в два раза больше вашего текущего списка

>>> l = [1,2,3,4,5]
>>> def roundlist(l,index,value):
...     return (l+l)[index:index+value]
... 
>>> roundlist(l,3,3)
[4, 5, 1]
>>> roundlist(l,4,3)
[5, 1, 2]

Answer 3

Что-то вроде:

def return_consecutive(a, index, n=3):
    while index > len(a):
        index -= len(a)
    a.extend(a)
    return a [index:index + n]

return_consecutive(a, 3)
[4, 5, 1]
return_consecutive(a, 4)
[5, 1, 2]
return_consecutive(a, 6)
[2, 3, 4]

Это также работает для значений, превышающих длину списка

Answer 4

Вы можете использовать цикл , из документации:

Сделать итератор, возвращающий элементы из итерируемого и сохраняющий копия каждого. Когда итерация исчерпана, вернуть элементы из сохраненная копия.

Код:

from itertools import cycle, islice

lst = [1, 2, 3, 4, 5]


def get(l, index, length=3):
    return list(islice(cycle(l), index, index + length))


print(get(lst, 3))
print(get(lst, 4))

выход

[4, 5, 1]
[5, 1, 2]

Answer 5

Этого легко достичь, используя np.roll :

lst = [1,2,3,4,5]

def roll_n(x, index, length=3):
    return np.roll(x,-index)[:length].tolist()

roll_n(lst,3)
[4, 5, 1]

roll_n(lst,4)
[5, 1, 2]

Answer 6

Типичный вариант использования для оператора по модулю %:

lst = [1,2,3,4,5]  # do not shadow built-in 'list'

i = 3
[lst[x % len(lst)] for x in range(i, i+3)]
# [4, 5, 1]

i = 4
[lst[x % len(lst)] for x in range(i, i+3)]
# [5, 1, 2]

Из указанных вами вариантов последний (4.) - тот, который дает те же результаты:

lst[i:i+3] + lst[:max(0 , -1*(len(lst)-i-3))]

Это легко проверить, просто попробовав;)