Wrapping around a list as a slice operation

Left:

L[:1], L[1:] = L[-1:], L[:-1]

Right:

L[-1:], L[:-1] = L[:1], L[1:]

Rotate left n elements (or right for negative n):

L = L[n:] + L[:n]

Note that collections.deque has support for rotations. It might be better to use that instead of lists.

If you are not overly attached to the exact slicing syntax, you can write a function that produces the desired output including the wrapping behavior.

E.g., like this:

def wrapping_slice(lst, *args):
    return [lst[i%len(lst)] for i in range(*args)]

Example output:

>>> L = range(3)
>>> wrapping_slice(L, 1, 4)
[1, 2, 0]
>>> wrapping_slice(L, -1, 4)
[2, 0, 1, 2, 0]
>>> wrapping_slice(L, -1, 4, 2)
[2, 1, 0]

Caveat: You can't use this on the left-hand side of a slice assignment.

To my mind, there's no way, unless you agree to cut and concatenate lists as shown above. To make the wrapping you describe you need to alter both starting and finishing index.

• A positive starting index cuts away some of initial items.
• A negative starting index gives you some of the tail items, cutting initial items again.
• A positive finishing index cuts away some of the tail items.
• A negative finishing index gives you some of the initial items, cutting tail items again.

No combination of these can provide the wrapping point where tail items are followed by initial items. So the entire thing can't be created.

Numerous workarounds exist. See answers above, see also itertools.islice and .chain for a no-copy sequential approach if sequential access is what you need (e.g. in a loop).