reversed()

Einleitung

Es gibt drei klassische Wege, eine Sequenz in Python rückwärts zu betrachten:

1. reversed(seq) — Iterator, lazy, kein Speicheraufwand.
2. seq[::-1] — neue Liste/String, sofort vollständig im Speicher.
3. for i in range(len(seq) - 1, -1, -1): seq[i] — explizit, unidiomatisch.

reversed() ist die idiomatische Wahl, wenn man iterieren will. seq[::-1] ist besser, wenn man eine umgekehrte Kopie als Wert braucht.

reversed() braucht eine Sequenz (random-access fähig). Dictionaries, Sets und Generatoren werden nicht direkt unterstützt — bei Dicts greift man seit Python 3.8 zu reversed(dict_obj), das die Insertion-Order rückwärts liefert.

Syntax

reversed(seq)

Rückgabewert

Ein Iterator, der die Elemente in umgekehrter Reihenfolge liefert. Mit list() materialisierbar.

Beispiele

Liste rückwärts iterieren

Der häufigste Anwendungsfall — eine for-Schleife, die rückwärts läuft, ohne den Index manuell zu jonglieren:

items = ["a", "b", "c", "d"]
for x in reversed(items):
    print(x)

d
c
b
a

Mit String, Tupel, range, bytes

reversed() funktioniert mit allen Sequenz-Typen — die Rückgabe ist immer ein Iterator, der mit list() oder "".join() materialisiert werden kann:

print("".join(reversed("Hallo")))
print(list(reversed((1, 2, 3))))
print(list(reversed(range(5))))
print(bytes(reversed(b"abc")))

ollaH
[3, 2, 1]
[4, 3, 2, 1, 0]
b'cba'

Dictionary rückwärts (Python 3.8+)

Seit Python 3.8 lassen sich auch Dicts rückwärts iterieren — sie respektieren ihre Einfügereihenfolge:

d = {"a": 1, "b": 2, "c": 3}
for key in reversed(d):
    print(key, d[key])

c 3
b 2
a 1

Custom-Klasse mit reversed

Wer eine eigene Sequenz schreibt, kann __reversed__() implementieren — reversed() ruft sie automatisch auf:

class CountDown:
    def __init__(self, n):
        self.n = n

    def __iter__(self):
        return iter(range(self.n + 1))

    def __reversed__(self):
        return iter(range(self.n, -1, -1))

for i in reversed(CountDown(3)):
    print(i)

3
2
1
0

Praktische Beispiele

Letzte n Elemente iterieren

Mit reversed() und itertools.islice() lassen sich die letzten n Einträge sauber durchlaufen — ohne die ganze Liste zu kopieren:

from itertools import islice
log_entries = [f"event-{i}" for i in range(100)]
for e in islice(reversed(log_entries), 5):
    print(e)

event-99
event-98
event-97
event-96
event-95

Palindrom-Check ohne extra Speicher

Mit zip() und reversed() lässt sich ein Palindrom-Test in einer einzigen Zeile schreiben — ohne den String zu duplizieren:

def is_palindrome(s):
    s = s.lower()
    return all(a == b for a, b in zip(s, reversed(s)))

print(is_palindrome("Anna"))
print(is_palindrome("Reliefpfeiler"))
print(is_palindrome("Python"))

True
True
False

reversed mit enumerate

Wer rückwärts iterieren UND den ursprünglichen Index braucht, kombiniert enumerate() und reversed() über einen materialisierten Zwischenschritt:

items = ["a", "b", "c", "d"]
for i, x in reversed(list(enumerate(items))):
    print(i, x)

3 d
2 c
1 b
0 a

Praktische Hinweise

• reversed(seq) ist lazy und braucht O(1) zusätzlichen Speicher. seq[::-1] erzeugt eine vollständige Kopie.
• Sets und allgemeine Iterables (Generatoren, filter-Objekte) funktionieren nicht — sie haben keine garantierte Reihenfolge oder kein __reversed__.
• Dicts sind seit Python 3.8 unterstützt — Iteration in umgekehrter Einfügereihenfolge.
• Performance: Für sehr lange Listen ist reversed() deutlich schneller als seq[::-1], sobald man nur iteriert (nicht materialisiert).
• Verwandte Funktionen: list.reverse() (in-place, kein Iterator), sorted(seq, reverse=True) (sortieren UND umkehren).