Solving problem is about exposing yourself to as many situations as possible like Why does substring slicing with index out of range work? and practice these strategies over and over. With time, it becomes second nature and a natural way you approach any problems in general. Big or small, always start with a plan, use other strategies mentioned here till you are confident and ready to code the solution.

In this post, my aim is to share an overview the topic about Why does substring slicing with index out of range work?, which can be followed any time. Take easy to follow this discuss.

Why doesn’t `'example'[999:9999]`

result in error? Since `'example'[9]`

does, what is the motivation behind it?

From this behavior I can assume that `'example'[3]`

is, essentially/internally, not the same as `'example'[3:4]`

, even though both result in the same `'m'`

string.

##
Answer #1:

You’re correct! `'example'[3:4]`

and `'example'[3]`

are fundamentally different, and slicing outside the bounds of a sequence (at least for built-ins) doesn’t cause an error.

It might be surprising at first, but it makes sense when you think about it. Indexing returns a single item, but slicing returns a subsequence of items. So when you try to index a nonexistent value, there’s nothing to return. But when you slice a sequence outside of bounds, you can still return an empty sequence.

Part of what’s confusing here is that strings behave a little differently from lists. Look what happens when you do the same thing to a list:

```
>>> [0, 1, 2, 3, 4, 5][3]
3
>>> [0, 1, 2, 3, 4, 5][3:4]
[3]
```

Here the difference is obvious. In the case of strings, the results appear to be identical because in Python, there’s no such thing as an individual character outside of a string. A single character is just a 1-character string.

(For the exact semantics of slicing outside the range of a sequence, see mgilson’s answer.)

##
Answer #2:

For the sake of adding an answer that points to a robust section in the documentation:

Given a slice expression like `s[i:j:k]`

,

The slice of

sfromitojwith stepkis defined as the sequence of items with index`x = i + n*k`

such that`0 <= n < (j-i)/k`

. In other words, the indices are`i`

,`i+k`

,`i+2*k`

,`i+3*k`

and so on, stopping whenjis reached (but never includingj).Whenkis positive,iandjare reduced to`len(s)`

if they are greater

if you write `s[999:9999]`

, python is returning `s[len(s):len(s)]`

since `len(s) < 999`

and your step is positive (`1`

— the default).

##
Answer #3:

Slicing is not bounds-checked by the built-in types. And although both of your examples appear to have the same result, they work differently; try them with a list instead.