What does [::-1] do in Python?

Slicing in Python allows you to extract portions of sequences like strings, lists, and other data structures. The slice notation uses the format [start:stop:step], where [::-1] is a special case that reverses the entire sequence.

Understanding [::-1] Syntax

The slice notation [::-1] means:

• start: empty (defaults to the end)
• stop: empty (defaults to the beginning)
• step: -1 (move backwards one element at a time)

Here's how different slicing patterns work ?

text = "Hello"

# Different slicing patterns
print("Original:", text)
print("First 3 chars:", text[:3])
print("From index 1 to end:", text[1:])
print("Every 2nd char:", text[::2])
print("Reversed:", text[::-1])

Original: Hello
First 3 chars: Hel
From index 1 to end: ello
Every 2nd char: Hlo
Reversed: olleH

Reversing Strings

The most common use of [::-1] is to reverse strings ?

myStr = 'Hello! How are you?'
print("String =", myStr)

# Reverse the string
print("Reversed =", myStr[::-1])

String = Hello! How are you?
Reversed = ?uoy era woH !olleH

Reversing Lists

You can also reverse lists and other sequences using [::-1] ?

numbers = [1, 2, 3, 4, 5]
colors = ['red', 'green', 'blue']

print("Original numbers:", numbers)
print("Reversed numbers:", numbers[::-1])
print("Original colors:", colors)
print("Reversed colors:", colors[::-1])

Original numbers: [1, 2, 3, 4, 5]
Reversed numbers: [5, 4, 3, 2, 1]
Original colors: ['red', 'green', 'blue']
Reversed colors: ['blue', 'green', 'red']

Reversing Pandas DataFrame Rows

When working with pandas DataFrames, [::-1] reverses the row order ?

import pandas as pd

# Create a DataFrame
data = {'Rank': [1, 2, 3, 4, 5], 'Points': [100, 87, 80, 70, 50]}
df = pd.DataFrame(data)
print("Original DataFrame:")
print(df)

# Reverse the DataFrame rows
print("\nReversed DataFrame:")
print(df[::-1])

Original DataFrame:
   Rank  Points
0     1     100
1     2      87
2     3      80
3     4      70
4     5      50

Reversed DataFrame:
   Rank  Points
4     5      50
3     4      70
2     3      80
1     2      87
0     1     100

Performance Considerations

Keep in mind that [::-1] creates a new object with reversed elements, which uses additional memory. For large datasets, consider using reversed() function which returns an iterator ?

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

# Creates a new list (uses more memory)
reversed_list = data[::-1]
print("Slice method:", reversed_list)

# Returns an iterator (memory efficient)
reversed_iter = list(reversed(data))
print("reversed() function:", reversed_iter)

Slice method: [5, 4, 3, 2, 1]
reversed() function: [5, 4, 3, 2, 1]

Conclusion

The [::-1] slice notation is a simple and readable way to reverse sequences in Python. It works with strings, lists, tuples, and other sliceable objects by stepping through them backwards.