Traverse a list in reverse order in Python

Let's get tricky: Advanced Iteration

When it's not just about looping, but also about the indexes, reversed() and enumerate() join forces:

Efficient index tracking:

for index, item in reversed(list(enumerate(my_list))): # CSI Index. 😎
    print(index, item)


Now, enumerate() adds a count to your iterable and reversed() backwards iterates through it because sadly, enumerate() isn't a fan of doing reverse runs by default.

Back to future: Negative Indices

In Python, you can access list items using negative indices. -1 gets you the last item, -2 the second last, you get the idea:

Negative index access:

for i in range(1, len(my_list) + 1): # Back to the index! 🚀
    print(my_list[-i])


Optimizing with range: Performance Matters

If performance is your thing, reverse iterating with range() is your answer:

Efficient loop with range():

for i in range(len(my_list) - 1, -1, -1): # I thought ‘i’ was imaginary? 🧐
    print(my_list[i])


This technique speeds up your iterator from the last to the first index, making it a memory champion.

Beyond Basics: Reverse Iteration

Simple methods cover a ton of ground, but there's more depth to explore for those looking to tug at the loose ends.

peek under range()

Dive deep with help(range) to uncover how range() can be leveraged for reverse iteration, far beyond the everyday usage.

Space-saving iteration

Memory got you down? Well, that’s what generator expressions are for. They enable you to iterate over elements in reverse, saving you from having to clone your list:

Better space utilization:

for index in reversed(range(len(my_list))):
    print(index, my_list[index])  # I’m in space! 🚀


Python 3's got your back

Python 3 has made many functions more user and performance-friendly. Take care to use functions like print() in a way that’s agreeable with Python 3’s compatibility streak.

Keeping an eye on time complexity

Remember, reversing a list has a time complexity of O(n). Longer running times can occur when working with large datasets, so make sure your chosen method is a good fit for your data structure and size.

Choosing the right technique

Every method here has its own sweet spot. It all depends on:

• Data size
• Memory availability
• Need for indexing
• Code readability
• Execution speed

So while slice notation has got your back for brief use or within comprehensions, reversed() is the one to call when you need an iterator or value clarity of code.