Python reversed() Function

Spread the love

The reversed( ) is a built-in function that returns a reversed iterator object. It provides a way to access the elements of a sequence in the reverse order without modifying the original data structure.




The reversed() function takes a single parameter.

sequence: The sequence to be reversed. This can be a list, tuple, string, or any other object that implements the __reversed__() or __getitem__() and __len__() methods.

Return Value:

The reversed() function returns an iterator that accesses the given sequence in the reverse order. Since it is an iterator, you can use it in loops or convert it into a list or other sequence types if needed.

Using reversed( ) with Different Data Types

The reversed() function in Python is a flexible tool that can be used with several built-in data types that are sequences. In this section, I’ll explain how reversed() interacts with different sequence data types in Python: lists, strings, tuples, and custom sequences.


Lists in Python are mutable sequences of elements. When reversed() is applied to a list, it returns an iterator that accesses the elements of the list in reverse order.

Here’s an example of how to use reversed() with a list:

my_list = [1, 2, 3, 4, 5]
for item in reversed(my_list):



If you wish to get a reversed list as a result, you can convert the iterator to a list:

reversed_list = list(reversed(my_list))


[5, 4, 3, 2, 1]


Strings in Python are immutable sequences of characters. Using reversed() on a string returns an iterator over the characters in the string, but in reverse order.

Example of reversing a string:

my_string = "hello"
for char in reversed(my_string):



To get a reversed string, you can join the iterator with an empty string:

reversed_string = ''.join(reversed(my_string))




Tuples are similar to lists in that they are ordered sequences, but they are immutable. reversed() works on tuples just like it does on lists, returning an iterator that goes through the tuple’s elements in reverse.

Reversing a tuple:

my_tuple = (1, 2, 3, 4, 5)
for item in reversed(my_tuple):



And to convert the iterator to a tuple:

reversed_tuple = tuple(reversed(my_tuple))


(5, 4, 3, 2, 1)

Custom Sequences

For custom objects that you would like to be reversible with the reversed() function, you need to ensure that they implement the sequence protocol. This means that the custom object must either have the __reversed__() method or both the __len__() and __getitem__() methods.

Here’s a simple custom sequence class with the necessary methods:

class MySequence:
    def __init__(self, data): = data
    def __len__(self):
        return len(
    def __getitem__(self, index):

custom_sequence = MySequence([1, 'two', 3.0, 'four', 5])
for item in reversed(custom_sequence):



By providing the __getitem__() and __len__() methods, the MySequence class can be reversed with reversed(), as the function will know how to access its elements and the size of the sequence.

To summarize, the reversed() function can be applied to various sequence data types in Python, allowing for iteration over the elements in reverse without modifying the original sequence. It’s particularly useful when you need to go through a sequence backward efficiently and conveniently.

Practical Examples:

The reversed() function has a multitude of practical applications. In this section, I will delve into a few practical examples that illustrate how reversed() can be utilized effectively in different scenarios.

Reversing to Create a Copy

One common use case for reversed() is to create a reversed copy of a sequence. Since reversed() returns an iterator, you can pass it to the constructor of the sequence type you want to create a reversed copy of.

original_list = [1, 2, 3, 4, 5]
reversed_list = list(reversed(original_list))
print(reversed_list)  # Output: [5, 4, 3, 2, 1]

This code snippet reverses a list. First, we define original_list. Then we create reversed_list by passing the iterator returned by reversed(original_list) to the list constructor. The print statement confirms that reversed_list is indeed a reversed copy of original_list.

Palindrome Check

A palindrome is a word, phrase, number, or other sequences of characters that reads the same forward and backward (ignoring spaces, punctuation, and capitalization). The reversed() function can be used to determine if a string is a palindrome.

def is_palindrome(sequence):
    return list(sequence) == list(reversed(sequence))

print(is_palindrome("radar"))  # Output: True
print(is_palindrome("hello"))  # Output: False

Here, the is_palindrome function converts both the original sequence and the reversed iterator to lists and compares them. If they are the same, the sequence is a palindrome.

Looping in Reverse Order

Sometimes it’s necessary to loop through a sequence in reverse order. This can be done neatly with reversed(), especially when you want to iterate over a range of numbers in reverse.

for i in reversed(range(10)):



In this example, range(10) generates a sequence of numbers from 0 to 9. The reversed() function then allows us to loop over this range backward.

Displaying Elements in Reverse

You may want to display elements in reverse without altering their original structure, which is another situation where reversed() is useful.

names = ["Alice", "Bob", "Charlie", "Dana"]
for name in reversed(names):



This could be handy, for example, in a situation where you’re showing a user their most recent actions (stored in a list where the most recent action is the last element) and want to show the most recent action first.

Processing Data in Reverse Order

Consider a situation where you’re processing a stack represented by a list (where the last element is the top of the stack), and you need to process from the bottom of the stack.

stack = [1, 2, 3, 4, 5]  # Imagine 5 is the top of the stack
for item in reversed(stack):
    # Process items from the bottom of the stack
    print(f"Processing item: {item}")


Processing item: 5
Processing item: 4
Processing item: 3
Processing item: 2
Processing item: 1

This approach respects the original stack structure and processes the items in the required order.

Inverting a Mapping

Sometimes you might have a mapping where you want to invert the keys and values. Using reversed() can be part of such a solution when dealing with Python’s dictionary items, which are view objects that can be reversed.

mapping = {'a': 1, 'b': 2, 'c': 3}
inverted_mapping = {value: key for key, value in reversed(mapping.items())}


{3: 'c', 2: 'b', 1: 'a'}

These practical examples demonstrate the versatility of the reversed() function in Python. Whether dealing with simple data structures like lists and strings or more complex custom objects, reversed() offers a straightforward and efficient means to access elements in reverse order without modifying the original data structures.

reversed( ) vs [: : -1]

The [::-1] slicing method can also be used to reverse a sequence. However, unlike reversed(), the slicing method returns a new reversed instance of the sequence instead of an iterator. This can be memory inefficient if the sequence is very large.

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

Common Pitfalls and FAQs

Can I reverse a dictionary using reversed( ) ?

Dictionaries before Python 3.8 do not maintain order; hence reversing does not make sense. From Python 3.8 onwards, dictionaries are insertion ordered, so you can reverse the order of keys.

Does reversed( ) modify the original sequence?

No, reversed() does not modify the original sequence. It creates a new iterator that can be used to iterate over the sequence in reverse order.

How can I reverse a sequence in-place?

For in-place reversal, you can use the reverse() method of list objects.


The reversed() function is a flexible and memory-efficient tool to reverse sequences in Python. By returning an iterator, it allows for reversed iteration without creating a copy of the sequence, which can be invaluable for memory management with large sequences.

Leave a Reply