Get professional AI headshots with the best AI headshot generator. Save hundreds of dollars and hours of your time.


In Python, the reversed() function is a built-in function that allows you to reverse the elements of an iterable, such as a list, tuple, string, or range. It returns a reverse iterator, which means you can traverse the elements in reverse order without actually modifying the original iterable. This can be incredibly useful when you need to iterate over elements in reverse or when you want to create a reversed version of an iterable.

In this tutorial, we will explore the reversed() function in detail. We will cover its syntax, how it works, and provide multiple examples to demonstrate its usage. By the end of this tutorial, you should have a clear understanding of how to use the reversed() function effectively in your Python code.

Table of Contents

  1. Syntax of reversed()
  2. How reversed() Works
  3. Examples of Using reversed()
  4. Reversed Iteration vs. Reversed Copy
  5. Custom Objects and __reversed__()
  6. Performance Considerations
  7. Conclusion

1. Syntax of reversed()

The syntax of the reversed() function is quite simple:

  • iterable: The iterable (list, tuple, string, range, etc.) whose elements you want to reverse.

The reversed() function takes a single argument, which is the iterable you want to reverse. It returns a reverse iterator that allows you to traverse the elements of the iterable in reverse order.

2. How reversed() Works

The reversed() function works by returning a reverse iterator object. This iterator object can be used in a for loop or converted to other iterable types (such as a list) using the list() constructor.

When you use the reversed() function, it does not modify the original iterable. Instead, it provides a way to access the elements of the iterable in reverse order, without altering the original order of the elements.

3. Examples of Using reversed()

Example 1: Reversing a List

Let’s start with a simple example of reversing a list using the reversed() function:

numbers = [1, 2, 3, 4, 5]
reversed_numbers = reversed(numbers)

for num in reversed_numbers:



In this example, we have a list of numbers from 1 to 5. We use the reversed() function to create a reverse iterator for the numbers list. Then, we iterate through the reversed_numbers iterator using a for loop and print each number in reverse order.

Example 2: Reversing a String

You can also use the reversed() function to reverse the characters in a string:

text = "hello"
reversed_text = reversed(text)

reversed_string = ''.join(reversed_text)



In this example, we have a string “hello”. We use the reversed() function to create a reverse iterator for the characters in the string. Then, we use the join() method to concatenate the reversed characters and create the reversed string.

4. Reversed Iteration vs. Reversed Copy

It’s important to note that the reversed() function does not return a new list or iterable with reversed elements. Instead, it returns a reverse iterator that provides access to the elements in reverse order. This means that the original iterable remains unchanged.

If you need to create a new list or other iterable with reversed elements, you can convert the reverse iterator into the desired type. For example:

numbers = [1, 2, 3, 4, 5]
reversed_numbers = list(reversed(numbers))

In this example, the reversed_numbers list will contain the elements of the numbers list in reverse order.

5. Custom Objects and __reversed__()

The reversed() function can also be used with custom objects, provided the object defines a __reversed__() method. This method should return an iterator that produces the elements of the object in reverse order.

Here’s a basic example:

class CustomList:
    def __init__(self, items):
        self.items = items

    def __reversed__(self):
        return reversed(self.items)

custom_list = CustomList([10, 20, 30, 40, 50])
reversed_custom_list = reversed(custom_list)

for item in reversed_custom_list:



In this example, the CustomList class defines a __reversed__() method that returns a reversed iterator of the items list.

6. Performance Considerations

While the reversed() function is convenient for iterating over elements in reverse, it’s important to be aware of its performance implications, especially with large iterables. The reversed() function has a time complexity of O(1) for accessing individual elements, but creating the reverse iterator takes O(n) time and memory, where n is the number of elements in the iterable.

If memory usage is a concern, you might consider using other techniques, such as using the index to access elements in reverse or using slicing ([::-1]) for lists.

7. Conclusion

The reversed() function is a powerful tool in Python for iterating over elements in reverse order without modifying the original iterable. It provides a convenient way to work with reversed sequences, whether they are lists, strings, tuples, or custom objects.

In this tutorial, we covered the syntax and usage of the reversed() function, including examples of reversing lists and strings. We also discussed the difference between reversed iteration and creating a reversed copy. Additionally, we explored how to work with custom objects using the __reversed__() method and touched upon performance considerations.

By incorporating the reversed() function into your Python code, you can easily handle scenarios where iterating in reverse order is necessary, enhancing the flexibility and readability of your programs.

Leave a Reply

Your email address will not be published. Required fields are marked *