reversed()

reversed() is a built-in Python function that returns a reverse iterator over any sequence or iterable — allowing you to traverse elements backward without modifying the original data. In 2026, reversed() remains one of the most elegant and memory-efficient tools for reverse iteration — essential in data science (time series reversal, ranked results in pandas/Polars/Dask), software engineering (stack-like processing, palindrome checks), and algorithm design (reverse traversal, two-pointer techniques) — working directly on lists, tuples, strings, range objects, NumPy arrays, and custom sequences that implement __reversed__() or __len__ + __getitem__.

Here’s a complete, practical guide to using reversed() in Python: basic reverse iteration, custom sequences, real-world patterns (earthquake time series reversal, ranked results, palindrome validation), and modern best practices with type hints, performance, memory, and integration with NumPy/Dask/Polars/pandas/xarray.

Basic reversed() — reverse any sequence or iterable.


# List
nums = [1, 2, 3, 4, 5]
for n in reversed(nums):
    print(n)  # 5 4 3 2 1

# String
s = "Hello"
print(''.join(reversed(s)))  # olleH

# Tuple
t = (10, 20, 30)
print(list(reversed(t)))     # [30, 20, 10]

# range (efficient, no list creation)
for i in reversed(range(10)):
    print(i)  # 9 8 7 ... 0

# Empty iterable
print(list(reversed([])))     # []

Custom sequences with __reversed__() — efficient reverse iteration.


class Countdown:
    def __init__(self, start):
        self.start = start
    
    def __iter__(self):
        i = self.start
        while i > 0:
            yield i
            i -= 1
    
    def __reversed__(self):
        i = 1
        while i <= self.start:
            yield i
            i += 1

cd = Countdown(5)
print(list(cd))             # [5, 4, 3, 2, 1]
print(list(reversed(cd)))   # [1, 2, 3, 4, 5] (efficient via __reversed__)

Real-world pattern: earthquake time series reversal & ranked results — reverse chronological order.


import pandas as pd

df = pd.read_csv('earthquakes.csv', parse_dates=['time'])
df = df.sort_values('time')  # oldest first

# Reverse to newest first
for event in reversed(df.itertuples()):
    if event.mag >= 7.0:
        print(f"{event.time.date()}: Mag {event.mag:.1f} - {event.place}")
        break  # most recent strong event

# Pandas native reverse
recent_first = df.iloc[::-1]  # same as reversed(df.index) indexing
print(recent_first.head())

# Polars reverse
import polars as pl
pl_df = pl.from_pandas(df)
reversed_pl = pl_df.reverse()
print(reversed_pl.head())

Best practices for reversed() in Python & data workflows. Prefer reversed(seq) — over seq[::-1] when memory matters (no copy for large sequences). Modern tip: use Polars df.reverse() — lazy reverse; Dask ddf.iloc[::-1] (materializes). Use reversed() with for — direct iteration, no list creation. Add type hints — from typing import Iterator; def reverse_iter(seq: Iterable[T]) -> Iterator[T]: return reversed(seq). Use reversed() with zip() — zip(reversed(a), reversed(b)) for parallel reverse. Use reversed(range(n)) — efficient countdown. Use next(reversed(seq)) — get last item without full reversal. Use list(reversed(seq)) — only when you need the reversed list. Use reversed() in generators — yield from reversed(seq). Use reversed() with files — for line in reversed(open('log.txt').readlines()): ... (but memory-heavy; prefer tail). Use reversed() in pandas — df.iloc[::-1] or df.sort_index(ascending=False). Use reversed() in NumPy — arr[::-1] (view, not copy). Use reversed() with custom classes — implement __reversed__() for efficiency. Use reversed() in list comprehensions — [f(x) for x in reversed(seq)]. Use reversed() with enumerate() — for i, v in enumerate(reversed(seq)) (reversed indices). Use reversed() in sorting — sorted(seq, reverse=True) (alternative). Use reversed() in palindrome checks — seq == list(reversed(seq)). Use reversed() in two-pointer — i = 0; j = len(seq)-1; while i < j: ... (but prefer indices).

reversed(seq) returns a reverse iterator over any sequence or iterable — efficient, no-copy for supported types, supports __reversed__ protocol. In 2026, use for reverse traversal, newest-first data, last-item access, and integrate with pandas/Polars/Dask for reversed views and processing. Master reversed(), and you’ll handle backward iteration cleanly and memory-efficiently in any Python workflow.

Next time you need to iterate backward — use reversed(). It’s Python’s cleanest way to say: “Go through this collection — from end to start, without changing anything.”

Generating content...