Vfrdtyky

Perhaps just use a numpy array:

In [19]: import numpy as np



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

Basic slicing numpy arrays returns a view, not a copy:

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



In [22]: lv

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

Altering l affects lv:

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



In [24]: lv

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

And altering lv affects l:

In [25]: lv[1]=4



In [26]: l

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

You can do that by creating your own generator using the original list reference.

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

However this being a generator, you can only go through the list once, forwards and it will explode if you remove more elements than you requested with range.

Edit: The object argument must be an object that supports the buffer call interface (such as strings, arrays, and buffers). - so no, sadly.

I think buffer type is what you are looking for.

Pasting example from linked page:

>>> 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' 

As soon as you will take a slice from a list, you will be creating a new list. Ok, it will contain same objects so as long as objects of the list are concerned it would be the same, but if you modify a slice the original list is unchanged.

If you really want to create a modifiable view, you could imagine a new class based on collection.MutableSequence

This could be a starting point for a full featured sub list - it correctly processes slice indexes, but at least is lacking specification for negative indexes processing:

class Sublist(collections.MutableSequence):

    def __init__(self, ls, beg, end):

        self.ls = ls

        self.beg = beg

        self.end = end

    def __getitem__(self, i):

        self._valid(i)

        return self.ls[self._newindex(i)]

    def __delitem__(self, i):

        self._valid(i)

        del self.ls[self._newindex(i)]

    def insert(self, i, x):

        self._valid(i)

        self.ls.insert(i+ self.beg, x)

    def __len__(self):

        return self.end - self.beg

    def __setitem__(self, i, x):

        self.ls[self._newindex(i)] = x

    def _valid(self, i):

        if isinstance(i, slice):

            self._valid(i.start)

            self._valid(i.stop)

        elif isinstance(i, int):

            if i<0 or i>=self.__len__():

                raise IndexError()

        else:

            raise TypeError()

    def _newindex(self, i):

        if isinstance(i, slice):

            return slice(self.beg + i.start, self.beg + i.stop, i.step)

        else:

            return i + self.beg

Example:

>>> a = list(range(10))

>>> s = Sublist(a, 3, 8)

>>> s[2:4]

[5, 6]

>>> s[2] = 15

>>> a

[0, 1, 2, 3, 4, 15, 6, 7, 8, 9]

Subclass the more_itertools.SequenceView to affect views by mutating sequences and vice versa.

Code

import more_itertools as mit





class SequenceView(mit.SequenceView):

    """Overload assignments in views."""

    def __setitem__(self, index, item):

        self._target[index] = item

Demo

>>> seq = list(range(10))

>>> view = SequenceView(seq)

>>> view

SequenceView([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])



>>> # Mutate Sequence -> Affect View

>>> seq[6] = -1

>>> view[5:8]

[5, -1, 7]



>>> # Mutate View -> Affect Sequence

>>> view[5] = -2

>>> seq[5:8]

[-2, -1, 7]

more_itertools is a third-party library. Install via > pip install more_itertools.

https://gist.github.com/mathieucaroff/0cf094325fb5294fb54c6a577f05a2c1

Above link is a solution based on python 3 range ability to be sliced and
indexed in constant time.

It supports slicing, equality comparsion, string casting (__str__), and
reproducers (__repr__), but doesn't support assigment.

Creating a SliceableSequenceView of a SliceableSequenceView won't slow down
access times as this case is detected.

sequenceView.py

# stackoverflow.com/q/3485475/can-i-create-a-view-on-a-python-list

try:

    from collections.abc import Sequence

except ImportError:

    from collections import Sequence # pylint: disable=no-name-in-module



class SliceableSequenceView(Sequence):

    """

    A read-only sequence which allows slicing without copying the viewed list.

    Supports negative indexes.

    Usage:

        li = list(range(100))

        s = SliceableSequenceView(li)

        u = SliceableSequenceView(li, slice(1,7,2))

        v = s[1:7:2]

        w = s[-99:-93:2]

        li[1] += 10

        assert li[1:7:2] == list(u) == list(v) == list(w)

    """

    __slots__ = "seq range".split()

    def __init__(self, seq, sliced=None):

        """

        Accept any sequence (such as lists, strings or ranges).

        """

        if sliced is None:

            sliced = slice(len(seq))

        l = looksSliceable = True

        l = l and hasattr(seq, "seq") and isinstance(seq.seq, Sequence)

        l = l and hasattr(seq, "range") and isinstance(seq.range, range)

        looksSliceable = l

        if looksSliceable:

            self.seq = seq.seq

            self.range = seq.range[sliced]

        else:

            self.seq = seq

            self.range = range(len(seq))[sliced]



    def __len__(self):

        return len(self.range)



    def __getitem__(self, i):

        if isinstance(i, slice):

            return SliceableSequenceView(self.seq, i)

        return self.seq[self.range[i]]



    def __str__(self):

        r = self.range

        s = slice(r.start, r.stop, r.step)

        return str(self.seq[s])



    def __repr__(self):

        r = self.range

        s = slice(r.start, r.stop, r.step)

        return "SliceableSequenceView({!r})".format(self.seq[s])



    def equal(self, otherSequence):

        if self is otherSequence:

            return True

        if len(self) != len(otherSequence):

            return False

        for v, w in zip(self, otherSequence):

            if v != w:

                print(v, w)

                return False

        return True

You could edit: not do something like

shiftedlist = type('ShiftedList',

                   (list,),

                   {"__getitem__": lambda self, i: list.__getitem__(self, i + 3)}

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

Being essentially a one-liner, it's not very Pythonic, but that's the basic gist.

edit: I've belatedly realized that this doesn't work because list() will essentially do a shallow copy of the list it's passed. So this will end up being more or less the same as just slicing the list. Actually less, due to a missing override of __len__. You'll need to use a proxy class; see Mr. Martelli's answer for the details.

If you are going to be accessing the "view" sequentially then you can just use itertools.islice(..)You can see the documentation for more info.

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

d = [1:3] #[2, 3]

d = itertools.islice(2, 3) # iterator yielding -> 2, 3

You can't access individual elements to change them in the slice and if you do change the list you have to re-call isclice(..).