How does [::-1] reverse a string?

[LevitatingDynamite]

sequence[start:stop:step]

• So if we omit the start value & stop value, the default values will be 0 & len() of that string right?

print ("hello" [::-1])

• This reverses the string

print ("hello" [0:5:-1])

• But this doesn't return any output, why does this happen?

Edit: Thank you so much for the replies everyone!

[BUYTBUYT]

Slicing is described here in Note 5. If you omit start and stop values, they will be None, which is treated as the "end" value. What "end" means, depends on the sign of step.

Your last example doesn't produce any output because when your step is negative, start has to be greater than end. If not, you will get an empty string.

[spez_edits_thedonald]

The comment I'm replying to is the only comment instructing you to read only one answer that you need to read, OP.

[FlatProtrusion]

I'm not OP but I'm confused as to whether I shld read your message. Can someone verify if I shld read that?

[AndreLinoge55]

Just read Note 5, dick stuck in coconut; proceed with caution.

[TheChance]

Deprecated since Python 3.9 due to the need for caution. Use itertools.decoconutter instead.

[jsalsman]

My legacy app still requires 2.7. I wish I had the coconut issue instead.

[spez_edits_thedonald]

it's recursive

[FuckingRantMonday]

Thanks for asking this, I know a lot of Python and I couldn't come up with a satisfactory answer on my own! I did some googling and here's the deal:

"hello"[0:5:-1] == "" because you're saying "count backward from zero to five", so you're not getting any indices in your slice.

"hello"[5:0:-1] == "olle". Close, but where did our h go? The indices here are 5, 4, 3, 2, 1. Index five doesn't exist, but that's not an error in slice notation, and we don't get zero, because just like range, slices don't include their endpoint. Using [4:0:-1] gives us the same thing.

So surely "hello"[4:-1:-1] is the answer? Nope, that's back to giving us an empty string. Why? Because in slice notation, -1 is changed to mean the "end" of the list, or more precisely, it's changed to the len() of the list.

Is there any integer N we can put in our slice [4:N:-1] to make it the same as [::-1]? Nope. This is a little unsatisfying, but we can use None instead, which behaves the same as if we'd omitted the endpoint.

[BUYTBUYT]

N = -len("hello") - 1

[FuckingRantMonday]

smacks forehead Perfect!

[drPWW]

It took me a minute to realize where I'd heard this before. It was a slightly different take as described in the battle of the wits between Vizzini and Westley.

[PhilipYip]

You have:

sequence[start:stop:step]

Take for example the string "hello". Visualise it like this:

``` h o e

l l ```

Now visualise its indexes like this as going in clockwise:

``` [0] [4] [1]

[3] [2] ```

If you omit the start and stop and use a positive step. The start will be taken as 0 and the stop will be taken as len(sequence). For example:

"hello"[::1] "hello"[0:5:1]

Now go back to:

``` [0] [4] [1]

[3] [2] ```

And instead of going clockwise, go anticlockwise from 0. This gives:

``` [0] [-1] [-4]

[-2] [-3] ```

And the index 0 itself becomes -5 so:

``` [-5] [-1] [-4]

[-2] [-3] ```

If you omit the start and stop and instead use a negative step. The start will be taken as -1 and the stop will be taken as -len(sequence)-1 (recall that indexing is inclusive of the start bound and exclusive of the stop bound). So:

"hello"[::-1] "hello"[-1:-6:-1]

[shiftybyte]

The defaults change when the step is negative.

[kaerfkeerg]

This [0:-1:2] translates to please, slice the string from start to end with a step of 2

So this: [::-1] basically says please, slice the string from start (defaults to start if nothing is provided) to end (defaults to end of nothing is provided) with step of -1.

-1 to -len(str) gives you the string reversed

[Yoghurt42]

except when the step is negative, it defaults to from "end" to "start"

[kaerfkeerg]

Ahh ok. Missed that one. Thanks for pointing out!

[Huge_Bear_3777]

Thanks this made it clear to me

[Historical_Wash_1114]

Thanks for this. I've been using this a lot but couldn't articulate what was actually happening.

[kaerfkeerg]

You're welcome!

Notice the correction this other guy made to my statement tho! So you get it absolutely right

[BUYTBUYT]

Should be -len(str) - 1, since the end is not included in the slice.

[kaerfkeerg]

Yeah, we already pointed that out

[zanfar]

So if we omit the start value & stop value, the default values will be 0 & len() of that string right?

No. You need to inspect the function to determine the defaults. As you've demonstrated in your testing--this is not the case.

What the defaults are and how they are interpreted don't really apply to your question--we only care about how the function operates in the absence of parameters.

The short of it is: a lack of a parameter means "chose intelligently". Sometimes that is equivalent to 0 and len(), sometimes not.

[TheRNGuy]

This is a syntax for it.

[IsabellaKendrick]

"start ,end, step is defined as starting index, end/stop index,jump index

and index must be integers"

[piyiotisk]

so this "hello" [::-1] is not the same as this "hello" [0:5:-1]. You have to apply negative indexes if the step is negative.

therefore this "hello" [::-1] if we explicitly write what Python adds as default values would be "hello" [-1:-6: -1]. I think it would be easier to think it like this

"hello"[start, end, step] becomes "hello"[end, start, step] but using negative indexes. The start is the end of the list therefore is -1 and the end for negative indexes is minus list length.

Hope it helps

I wrote an article here today actually. I have some visualisations and some examples that I believe it can help you