Edit - Stack Overflow

You are not logged in. Your edit will be placed in a queue until it is peer reviewed.

We welcome edits that make the post easier to understand and more valuable for readers. Because community members review edits, please try to make the post substantially better than how you found it, for example, by fixing grammar or adding additional resources and hyperlinks.

Required fields*

Rev

Required fields*

How slicing in Python works

How does Python's slice notation work? That is: when I write code like a[x:y:z], a[:], a[::2] etc., how can I understand which elements end up in the slice?

_{See Why are slice and range upper-bound exclusive? to learn why xs[0:2] == [xs[0], xs[1]], not [..., xs[2]].}
_{See Make a new list containing every Nth item in the original list for xs[::N].}
_{See How does assignment work with list slices? to learn what xs[0:2] = ["a", "b"] does.}

Answer*

> ## Explain Python's slice notation

In short, the colons (`:`) in subscript notation (`subscriptable[subscriptarg]`) make slice notation, which has the optional arguments `start`, `stop`, and `step`:

```py
sliceable[start:stop:step]
```

Python slicing is a computationally fast way to methodically access parts of your data. In my opinion, to be even an intermediate Python programmer, it's one aspect of the language that it is necessary to be familiar with.

## Important Definitions

To begin with, let's define a few terms:

> **`start`:** the beginning index of the slice, it will include the element at this index unless it is the same as *stop*, defaults to 0, i.e. the first index. If it's negative, it means to start `n` items from the end.
>
> **`stop`:** the ending index of the slice, it does *not* include the element at this index, defaults to length of the sequence being sliced, that is, up to and including the end.
>
> **`step`:** the amount by which the index increases, defaults to 1. If it's negative, you're slicing over the iterable in reverse.

## How Indexing Works

You can make any of these positive or negative numbers. The meaning of the positive numbers is straightforward, but for negative numbers, just like indexes in Python, you count backwards from the end for the *start* and *stop*, and for the *step*, you simply decrement your index. This example is [from the documentation's tutorial][1], but I've modified it slightly to indicate which item in a sequence each index references:

```py
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5 
  -6  -5  -4  -3  -2  -1
```

## How Slicing Works

To use slice notation with a sequence that supports it, you must include at least one colon in the square brackets that follow the sequence (which actually [implement the `__getitem__` method of the sequence, according to the Python data model][2].)

Slice notation works like this:

```py
sequence[start:stop:step]
```

And recall that there are defaults for *start*, *stop*, and *step*, so to access the defaults, simply leave out the argument.

Slice notation to get the last nine elements from a list (or any other sequence that supports it, like a string) would look like this:

```py
my_list[-9:]
```

When I see this, I read the part in the brackets as "9th from the end, to the end." (Actually, I abbreviate it mentally as "-9, on")

## Explanation:

The full notation is

```py
my_list[-9:None:None]
```

and to substitute the defaults (actually when `step` is negative, `stop`'s default is `-len(my_list) - 1`, so `None` for stop really just means it goes to whichever end step takes it to):

```py
my_list[-9:len(my_list):1]
```

The **colon**, `:`,  is what tells Python you're giving it a slice and not a regular index. That's why the idiomatic way of making a shallow copy of lists in Python 2 is

```py
list_copy = sequence[:]
```

And clearing them is with:

```py
del my_list[:]
```

(Python 3 gets a `list.copy` and `list.clear` method.)

### When `step` is negative, the defaults for `start` and `stop` change

By default, when the `step` argument is empty (or `None`), it is assigned to `+1`.

But you can pass in a negative integer, and the list (or most other standard sliceables) will be sliced from the end to the beginning.

Thus a negative slice will change the defaults for `start` and `stop`!

### Confirming this in the source

I like to encourage users to read the source as well as the documentation. The [source code for slice objects and this logic is found here][3]. First we determine if `step` is negative:

> ```c
> step_is_negative = step_sign < 0;
> ```

If so, the lower bound is `-1`  meaning we slice all the way up to and including the beginning, and the upper bound is the length minus 1, meaning we start at the end. (Note that the semantics of this `-1` is *different* from a `-1` that users may pass indexes in Python indicating the last item.)

> ```c
> if (step_is_negative) {
>     lower = PyLong_FromLong(-1L);
>     if (lower == NULL)
>         goto error;
> 
>     upper = PyNumber_Add(length, lower);
>     if (upper == NULL)
>         goto error;
> }
> ```

Otherwise `step` is positive, and the lower bound will be zero and the upper bound (which we go up to but not including) the length of the sliced list.

> ```c
> else {
>     lower = _PyLong_Zero;
>     Py_INCREF(lower);
>     upper = length;
>     Py_INCREF(upper);
> }
> ```

Then, we may need to apply the defaults for `start` and `stop`&mdash;the default then for `start` is calculated as the upper bound when `step` is negative:

> ```c
> if (self->start == Py_None) {
>     start = step_is_negative ? upper : lower;
>     Py_INCREF(start);
> }
> ```

and `stop`, the lower bound:

> ```c
> if (self->stop == Py_None) {
>     stop = step_is_negative ? lower : upper;
>     Py_INCREF(stop);
> }
> ```

# Give your slices a descriptive name!

You may find it useful to separate forming the slice from passing it to the `list.__getitem__` method ([that's what the square brackets do][2]). Even if you're not new to it, it keeps your code more readable so that others that may have to read your code can more readily understand what you're doing.

However, you can't just assign some integers separated by colons to a variable. You need to use the slice object:

```py
last_nine_slice = slice(-9, None)
```

The second argument, `None`, is required, so that the first argument is interpreted as the `start` argument [otherwise it would be the `stop` argument][4].

You can then pass the slice object to your sequence:

```py
>>> list(range(100))[last_nine_slice]
[91, 92, 93, 94, 95, 96, 97, 98, 99]
```

It's interesting that ranges also take slices:

```py
>>> range(100)[last_nine_slice]
range(91, 100)
```

# Memory Considerations:

Since slices of Python lists create new objects in memory, another important function to be aware of is `itertools.islice`. Typically you'll want to iterate over a slice, not just have it created statically in memory. `islice` is perfect for this. A caveat, it doesn't support negative arguments to `start`, `stop`, or `step`, so if that's an issue you may need to calculate indices or reverse the iterable in advance.

```py
length = 100
last_nine_iter = itertools.islice(list(range(length)), length-9, None, 1)
list_last_nine = list(last_nine_iter)
```

and now:

```py
>>> list_last_nine
[91, 92, 93, 94, 95, 96, 97, 98, 99]
```

The fact that list slices make a copy is a feature of lists themselves. If you're slicing advanced objects like a Pandas DataFrame, it may return a view on the original, and not a copy.

[1]: https://docs.python.org/2/tutorial/introduction.html
  [2]: https://docs.python.org/2/reference/datamodel.html#object.__getitem__
  [3]: https://github.com/python/cpython/blob/master/Objects/sliceobject.c
  [4]: https://docs.python.org/2/library/functions.html#slice

Edit Summary*

Cancel

@WinEunuuchs2Unix that's great feedback - this is a standard Python behavior, but it could be made clearer in that sort of way, so I'll consider updating my material to include this semantic.
– Aaron Hall ♦
Commented Sep 30, 2020 at 1:37
Your answer is the only one (?) that touches the tip of what would be interesting here, when you write "slicable" - the rest is triviality. I wanted to know how the slicing is done, using the __getitem__ method. But if I understand well, you have to do all of it on your own: check whether the arg to your __getitem__ is an int or a slice (or what else could it be?), and in that (slice) case, deal with all possible cases ((A) or (A,B) or (A,B,C), and all possible sign combinations) on your own.... is that right?
– Max
Commented Nov 29, 2022 at 21:09

Add a comment |

Correct minor typos or mistakes
Clarify meaning without changing it
Add related resources or links
Always respect the author’s intent
Don’t use edits to reply to the author

create code fences with backticks ` or tildes ~
```
like so
```
add language identifier to highlight code
```python
def function(foo):
print(foo)
```
put returns between paragraphs
for linebreak add 2 spaces at end
_italic_ or **bold**
indent code by 4 spaces
backtick escapes `like _so_`
quote by placing > at start of line
to make links (use https whenever possible)

<https://example.com>

[example](https://example.com)

<a href="https://example.com">example</a>

formatting help »
answering help »

Collectives™ on Stack Overflow

How slicing in Python works

Answer*