How do I reverse a list or loop over it backwards in Python?

Here are several ways to reverse a list or iterate over it backwards in Python, with explanations and examples:

1. Reverse a List (Permanently)

Use the .reverse() method to modify the original list in-place:

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

2. Create a Reversed Copy

Use slicing [::-1] to create a reversed copy without modifying the original list:

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

3. Loop Backwards with `reversed()`

Iterate over the list in reverse without creating a copy (memory-efficient for large lists):

fruits = ["apple", "banana", "cherry"]
for fruit in reversed(fruits):
    print(fruit)
# Output:
# cherry
# banana
# apple

4. Loop Backwards with Indexes

Use range() to iterate with indexes in reverse order:

numbers = [10, 20, 30, 40]
for i in range(len(numbers)-1, -1, -1):
    print(numbers[i])
# Output:
# 40
# 30
# 20
# 10

5. Create a Reversed Iterator

Convert the reversed iterator to a list using list():

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

6. Reverse a List While Preserving the Original

Use slicing to reverse a copy while keeping the original intact:

original = [True, False, None]
modified = original[::-1]
print(modified)   # Output: [None, False, True]
print(original)   # Output: [True, False, None]

Key Differences

Method	Modifies Original?	Memory Efficiency	Returns
`.reverse()`	Yes	O(1)	`None` (in-place)
`[::-1]` slicing	No	O(n)	New reversed list
`reversed()`	No	O(1)	Iterator
`range()` backward loop	No	O(1)	N/A (iteration)

When to Use Each

.reverse(): When you want to permanently reverse the original list.
[::-1]: When you need a reversed copy of the list.
reversed(): For memory-efficient backward iteration (especially with large lists).
range(): When you need index access during backward iteration.

Edge Cases

Empty List:

empty_list = []
print(empty_list[::-1])  # Output: []

Single-Element List:

single = [42]
print(single[::-1])  # Output: [42]

Performance Notes

For small lists: All methods are equally fast.
For large lists (10,000+ elements):
reversed() is most memory-efficient (doesn’t create a copy).
[::-1] uses twice the memory (creates a full copy).

Full Example with All Methods

# Original list
colors = ["red", "green", "blue"]

# Method 1: Reverse permanently
colors.reverse()
print("Reversed original:", colors)  # ["blue", "green", "red"]

# Method 2: Create reversed copy
original = ["a", "b", "c"]
reversed_copy = original[::-1]
print("Reversed copy:", reversed_copy)  # ["c", "b", "a"]

# Method 3: Iterate backwards
for color in reversed(["cyan", "magenta", "yellow"]):
    print(color)  # yellow → magenta → cyan

# Method 4: Index-based backward loop
nums = [9, 8, 7]
for i in range(len(nums)-1, -1, -1):
    print(nums[i])  # 7 → 8 → 9

Choose the method that best fits your use case! Let me know if you need further clarification.