What does [::-1] mean in Python? (How to reverse a sequence)

Python is a versatile and powerful programming language that offers various ways to manipulate data.

One of its key features is indexing, which allows accessing individual elements in sequences like strings, lists, and tuples.

In Python, indexing starts from 0 for the first element and goes up to n-1 for the nth element in a sequence of length n.

However, Python also supports negative indexing, which provides a convenient way to access elements from the end of a sequence.

Let’s start by understanding what the [::-1] notation mean

In Python, [::-1] is a slice notation used for negative indexing, allowing sequence reversal. The syntax consists of three parts: start, stop, and step. When left blank, start and stop default to the beginning and end of the sequence, respectively, while step defaults to -1 for reverse order.

The slice notation [::] with a step value of -1 ([::-1]) is used to reverse sequences like lists, strings, and tuples.

For example, list[::-1] reverses a list, string[::-1] reverses a string, and tuple[::-1] reverses a tuple.

Let’s break down the examples to understand what [::-1] does when used in a Python program.

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

1. Reverses a List

Reversing a list using the [::-1] notation in Python is a concise and efficient way to obtain a reversed copy of the original list.

An example:

my_list = [1, 2, 3, 4, 5]
reversed_list = my_list[::-1]
print(reversed_list)  # Output: [5, 4, 3, 2, 1]

In this example:

1. Slice Notation: The [::] slice notation is used to extract a portion of a sequence. It consists of three components: start, stop, and step. In this case, all three components are left blank, so it defaults to the entire list with a step of -1.
2. Start and Stop Indices: When start and stop are left blank, Python assumes we want to include all elements in the list. So, it takes the entire list.
3. Step Size: The step value of -1 indicates that we want to move through the list in reverse order.

The [::-1] slice notation then creates a new list by traversing the original list in reverse order, effectively producing a reversed copy.

Importantly, it does not modify the original list; it only generates a new list with reversed elements.

Keep in mind that this operation has a time complexity of O(n), where n is the number of elements in the list.

Thus, it performs efficiently for most practical scenarios, especially when readability and conciseness are important.

If, however, you need to reverse the list in-place to save memory or improve performance, you can use the reverse() method of the list, which operates in O(n/2) time complexity.

You can also reverse a string or a tuple like this:

2. Reverses a String

Reversing a string using the [::-1] notation in Python is a straightforward and elegant method to create a reversed version of the original string.

Looking at an example:

my_string = "hello"
reversed_string = my_string[::-1]
print(reversed_string)  # Output: "olleh"

Here’s how we reverse the list

1. Slice Notation: The [::] slice notation is also applicable to strings, and it functions in a similar way as with lists. It consists of three components: start, stop, and step. In this case, all three components are left blank, so it defaults to the entire string with a step of -1.
2. Start and Stop Indices: By leaving the start and stop components blank, Python assumes we want to include all characters of the string. Hence, it considers the entire string.
3. Step Size: With a step value of -1, the slice operation iterates through the string in reverse order.

The [::-1] slice notation then creates a new string by traversing the original string from the end to the beginning, effectively producing the reversed version.

Just like with lists, this operation does not modify the original string but generates a new one with the characters in reverse order.

3. Reverses a Tuple

In Python, tuples are immutable sequences, meaning their elements cannot be modified after creation.

However, you can still reverse a tuple using the [::-1] notation without modifying the original tuple by creating a new one.

Let’s see how it works:

my_tuple = (10, 20, 30, 40, 50)
reversed_tuple = my_tuple[::-1]
print(reversed_tuple)  # Output: (50, 40, 30, 20, 10)

1. Slice Notation: Just like with lists and strings, the [::] slice notation can also be applied to tuples. It consists of three components: start, stop, and step. In this case, all three components are left blank, so it defaults to the entire tuple with a step of -1.
2. Start and Stop Indices: When the start and stop components are omitted, Python considers the entire tuple for the slice operation.
3. Step Size: With a step value of -1, the slice operation iterates through the tuple in reverse order.

The [::-1] slice notation creates a new tuple by traversing the original tuple in reverse, effectively producing a reversed version of the original tuple.

Similar to lists and strings, this operation does not modify the original tuple but creates a new one with elements in reverse order.

As with lists, strings, and tuples, [::-1] is a concise way to access elements in reverse without modifying the original sequence.

Handy for string manipulation, palindrome checks, and looping backward.

Now that you know how it works, you should know the concepts being applied in the [::-1] slice notation to reverse a string, list, or tuple.

The concepts being applied in the [::-1] slice notation are:

1. Slice Notation: The [::] notation is a powerful feature in Python that allows you to extract portions of a sequence (like lists, strings, or tuples) using slicing. It consists of three components: start, stop, and step, separated by colons. These components allow you to control which elements to include in the slice and in what order.
2. Negative Indexing: Python supports negative indexing, allowing you to access elements from the end of a sequence using negative integers. For instance, -1 represents the last element, -2 the second-to-last, and so on. Combining negative indexing with slice notation like [::] enables easy extraction of elements in reverse order.
3. Reversing a Sequence: The [::-1] slice notation uses a step size of -1 to traverse a sequence (list, string, or tuple) in reverse order. This creates a new copy of the sequence with the elements reversed, without modifying the original sequence.

The [::] slice notation

The [::] notation, also known as slice notation, is a versatile and valuable feature in Python that helps you extract specific parts of a sequence, such as lists, strings, or tuples.

In simple terms, here’s what slice notation means:

Imagine a sequence as a series of elements, like characters in a string or numbers in a list.

The slice notation [::] allows you to specify a subset of these elements based on three components: start, stop, and step.

These components are separated by colons and work together to define the slice.

1. Start, Stop, and Step

• Start: This component represents the index of the first element you want to include in the slice. If not specified, it defaults to the beginning of the sequence. The index starts at 0 for the first element, 1 for the second, and so on.
• Stop: The stop component represents the index of the first element you want to exclude from the slice. It defaults to the end of the sequence if not specified. Remember, the stop index is exclusive, meaning the element at this index will not be included in the slice.
• Step: The step component defines the interval between the elements included in the slice. If not specified, it defaults to 1. A positive step means elements are included in increasing order, while a negative step, like -1, means elements are included in reverse order.

2. Controlling the Slice

You can customize the slice according to your needs by providing specific values for the start, stop, and step components.

For example, my_list[1:4] would create a slice including elements at indices 1, 2, and 3, but excluding the element at index 4.

An example slice notation

• my_string = "Hello, World!"
  • my_string[7:] would return "World!", as it includes all elements starting from index 7 to the end of the string.
  • my_string[:5] would return "Hello", as it includes elements from the beginning up to, but not including, index 5.
  • my_string[::2] would return "Hlo ol!", as it includes every second character in the string, starting from the beginning.

We have covered the [::] part.

The next concept you must understand is the negative indexing [::-1] applied to reverse the string, list, or tuple.

Here’s more about indexing in Python.

Understanding the basics of Python indexing

In Python, indexing starts from 0 for the first element in a sequence.

For example, if you have a list my_list = [10, 20, 30, 40, 50], to access the first element, you would use my_list[0], which would give you 10.

Similarly, my_list[1] would give 20, and so on.

A problem arises though.

While positive indexing is intuitive, it might get tricky when you want to access elements from the end of the sequence, especially with a large sequence.

That’s where negative indexing comes in!

Negative indexing in Python

Negative indexing allows you to access elements from the end of a sequence, making it convenient for certain scenarios.

The last element is represented by index -1, the second-to-last by -2, and so on.

Let’s consider the same list my_list = [10, 20, 30, 40, 50].

If we want to access the last element, we can use my_list[-1], which will give 50.

Similarly, my_list[-2] will give 40, and so forth.

Reversing a Sequence: What does [::-1] do in Python?

By combining slice notation [::] and negative indexing with [::-1], Python provides a simple and elegant way to reverse the order of elements in a sequence.

For our list example, its reverse copy would be produced like this:

my_list[::-1]

You can do anything with this reversed copy of your list. For example, use a for loop with the [::-1] slice notation.

for i in my_list[::-1]:
    print(i)

Whether you’re dealing with lists, strings, or tuples, this technique allows you to create a reversed copy of the original sequence without altering the original data.

So,

Slice notation [::] enables you to extract portions of a sequence based on three components: start, stop, and step, separated by colons.

Leaving these components blank defaults to the entire sequence, while a negative step value like -1 traverses the sequence in reverse order.

With the two working together, you are able to reverse sequences, manipulate data efficiently, and iterate backward without modifying the original data.

By combining slice notation [::] and negative indexing with [::-1], Python provides a simple and elegant way to reverse the order of elements in a sequence.

Whether you’re dealing with lists, strings, or tuples, this technique allows you to create a reversed copy of the original sequence without altering the original data.

You can do anything you want with your reversed list, whether it is to create other sequences, sort the elements, iterate through the elements, etc.

That’s it for this article!

Create, inspire, repeat!