На самом деле не слишком трудно реализовать это самостоятельно использование range.*, можно нарезать диапазон, и это делает всю сложную арифметику для Вас:

>>> range(20)[10:]
range(10, 20)
>>> range(10, 20)[::2]
range(10, 20, 2)
>>> range(10, 20, 2)[::-3]
range(18, 8, -6)

, Таким образом, Вам просто нужен класс объекта, который содержит ссылку на исходную последовательность и диапазон. Вот код для такого класса (не слишком большой, я надеюсь):

class SequenceView:

    def __init__(self, sequence, range_object=None):
        if range_object is None:
            range_object = range(len(sequence))
        self.range    = range_object
        self.sequence = sequence

    def __getitem__(self, key):
        if type(key) == slice:
            return SequenceView(self.sequence, self.range[key])
        else:
            return self.sequence[self.range[key]]

    def __setitem__(self, key, value):
        self.sequence[self.range[key]] = value

    def __len__(self):
        return len(self.range)

    def __iter__(self):
        for i in self.range:
            yield self.sequence[i]

    def __repr__(self):
        return f"SequenceView({self.sequence!r}, {self.range!r})"

    def __str__(self):
        if type(self.sequence) == str:
            return ''.join(self)
        elif type(self.sequence) in (list, tuple):
            return str(type(self.sequence)(self))
        else:
            return repr(self)

(Это было bodged вместе приблизительно за 5 минут, поэтому удостоверьтесь, что Вы тестируете его полностью перед использованием его где угодно важный.)

Использование:

>>> p = list(range(10))
>>> q = SequenceView(p)[3:6]
>>> print(q)
[3, 4, 5]
>>> q[1] = -1
>>> print(q)
[3, -1, 5]
>>> print(p)
[0, 1, 2, 3, -1, 5, 6, 7, 8, 9]

* в Python 3

Вы можете отредактировать: not сделать что-то вроде

shiftedlist = type('ShiftedList',
                   (list,),
                   {"__getitem__": lambda self, i: list.__getitem__(self, i + 3)}
                  )([1, 2, 3, 4, 5, 6])

По сути, это однострочный, это не очень Pythonic, но это основная суть.

edit: Я с опозданием понял, что это не работает, потому что list () , по сути, сделает мелкую копию переданного списка. Таким образом, это будет более или менее похоже на разрезание списка. Фактически меньше из-за отсутствия переопределения __ len __ . Вам нужно будет использовать прокси-класс; см. Mr. Ответ Мартелли для подробностей.

Изменить: Аргумент объекта должен быть объектом, который поддерживает интерфейс вызова буфера (например, строки, массивы и буферы). - так что нет, к сожалению.

Думаю, тип буфера - это то, что вы ищете.

Пример вставки со связанной страницы:

>>> s = bytearray(1000000)   # a million zeroed bytes
>>> t = buffer(s, 1)         # slice cuts off the first byte
>>> s[1] = 5                 # set the second element in s
>>> t[0]                     # which is now also the first element in t!
'\x05' 

Возможно, просто используйте массив numpy:

In [19]: import numpy as np

In [20]: l=np.arange(10)

Базовое нарезание массивов numpy возвращает представление , а не копию:

In [21]: lv=l[3:6]

In [22]: lv
Out[22]: array([3, 4, 5])

Изменение l влияет на lv :

In [23]: l[4]=-1

In [24]: lv
Out[24]: array([ 3, -1,  5])

И изменение lv влияет на l :

In [25]: lv[1]=4

In [26]: l
Out[26]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Вы можете сделать это, создав свой собственный генератор, используя исходный список ссылок.

l = [1,2,3,4,5]
lv = (l[i] for i in range(1,4))

lv.next()   # 2
l[2]=-1
lv.next()   # -1
lv.next()   # 4

Однако, поскольку это генератор, вы можете просмотреть список только один раз, вперед, и он взорвется, если вы удалите больше элементов, чем вы запрашивали с range .