repr()

Einleitung

Python kennt zwei Wege, ein Objekt als String darzustellen:

• str(obj) ruft __str__() auf — gedacht für Endnutzer-Anzeige („hübsche" Form).
• repr(obj) ruft __repr__() auf — gedacht für Entwickler/Debugging („präzise" Form).

Wenn __str__ fehlt, fällt str() auf __repr__ zurück. Daher ist __repr__ die wichtigere Methode — eigene Klassen sollten sie immer implementieren.

Eine gute Faustregel: repr() sollte einen String liefern, der idealerweise per eval() zurück in das Originalobjekt umgewandelt werden kann. Wenn das nicht geht, ist die Konvention <ClassName(...)>. Im REPL wird repr() automatisch zur Anzeige genutzt — Strings erscheinen mit Anführungszeichen, Listen mit eckigen Klammern usw.

Syntax

repr(object)

Rückgabewert

Ein str mit der Repräsentation des Objekts. Bei Builtins meist evaluierbar.

Beispiele

repr vs str bei Strings

Der wichtigste Unterschied — repr() zeigt die Anführungszeichen mit, str() nicht. Das macht Whitespace und Sonderzeichen sichtbar:

s = "Hallo\tWelt\n"
print(str(s))     # Tab und Newline werden ausgegeben
print(repr(s))    # Escapes sichtbar, mit Quotes

Hallo	Welt

'Hallo\tWelt\n'

Bei Builtins ist repr evaluierbar

Für die meisten Builtin-Datentypen liefert repr() einen String, der per eval() das Original wiederherstellen würde — sehr nützlich für Logs:

from datetime import date
for x in [42, "hi", [1, 2], {"a": 1}, date(2026, 5, 3), None]:
    print(repr(x))

42
'hi'
[1, 2]
{'a': 1}
datetime.date(2026, 5, 3)
None

Custom-Klasse mit repr

Eine ordentliche __repr__-Implementierung macht die Klasse auf einen Blick verständlich — perfekt für Logs und Debugger:

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"User(name={self.name!r}, age={self.age!r})"

u = User("Michael", 34)
print(repr(u))
print(u)        # Fallback auf __repr__, da kein __str__ definiert

User(name='Michael', age=34)
User(name='Michael', age=34)

!r in f-Strings

Das !r-Format-Flag in f-Strings ruft repr() auf den Wert auf — ein eleganter Shortcut für Debug-Outputs:

name = "Alice"
print(f"Hallo, {name}!")        # str
print(f"Hallo, {name!r}!")       # repr

Hallo, Alice!
Hallo, 'Alice'!

Praktische Beispiele

Debug-Output für Tests

In Tests oder beim Debugging zeigt repr() exakt, was im Wert steckt — ohne Whitespace zu verschlucken:

actual = "hello "
expected = "hello"
if actual != expected:
    print(f"Mismatch: actual={actual!r}, expected={expected!r}")

Mismatch: actual='hello ', expected='hello'

Roundtrip mit eval (nur für vertrauenswürdige Daten!)

Wenn repr() evaluierbar ist, ist eval(repr(x)) == x — eine Eigenschaft, die für simple Datentypen praktisch ist (NICHT für externe Daten verwenden, eval ist gefährlich):

data = {"a": 1, "b": [2, 3], "c": "hi"}
s = repr(data)
back = eval(s)
print(back == data)

True

Sammlung von Objekten loggen

Beim Loggen von Listen oder Dicts werden ihre Elemente automatisch per repr() dargestellt — das ist genau der gewünschte Detailgrad:

users = [User("Alice", 17), User("Bob", 24)]
print(users)

[User(name='Alice', age=17), User(name='Bob', age=24)]

Praktische Hinweise

• Eigene Klassen: __repr__ immer implementieren. __str__ nur, wenn das User-Output anders aussehen soll als die Debug-Form.
• Konvention: repr() liefert idealerweise f"ClassName({...})" — ein evaluierbarer Konstruktor-Aufruf.
• !r-Flag in f-Strings ist die kürzeste Form, um repr() zu nutzen: f"{x!r}".
• reprlib-Modul kürzt riesige Repräsentationen ab — nützlich für sehr große Datenstrukturen.
• Verwandte Funktionen: str() (User-Form), pprint.pformat() (mehrzeilig formatiert), dir() (Attribute).