0Pricing
Python Academy · Lektion

Magic Methods: __str__ und __repr__

Implementieren Sie Dunder-Methoden für lesbare Darstellungen von Objekten.

Magic Methods: __str__ und __repr__ ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was sind Magic Methods?

Magic Methods (Dunder-Methoden) sind spezielle Methoden mit doppelten Unterstrichen, die Python in bestimmten Kontexten aufruft, etwa beim Ausgeben oder Vergleichen.

class Foo:
    def __str__(self):
        return "I am Foo"

f = Foo()
print(f)        # I am Foo
print(str(f))   # I am Foo

__repr__: Darstellung für Entwickler

__repr__ sollte einen eindeutigen String zurückgeben, der idealerweise die Neuerstellung des Objekts ermöglicht. Er wird in der REPL angezeigt und von repr() verwendet.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(repr(p))  # Point(3, 4)

__str__: Darstellung für Benutzer

__str__ liefert einen menschenlesbaren String. print() und str() rufen ihn auf. Fehlt er, verwendet Python ersatzweise __repr__.

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    def __str__(self):
        return f"{self.celsius}°C"

    def __repr__(self):
        return f"Temperature({self.celsius})"

t = Temperature(100)
print(t)        # 100°C
print(repr(t))  # Temperature(100)

Wann die Methoden aufgerufen werden

__str__: print(), str(), f-Strings. __repr__: REPL, repr(), Container, die ihre Elemente anzeigen.

class Item:
    def __str__(self): return "str"
    def __repr__(self): return "repr"

x = Item()
print(x)         # str
print([x])       # [repr]  ← list uses repr for elements

__format__ für benutzerdefinierte Formatierung

Definieren Sie __format__, um zu steuern, wie f-Strings mit Formatangaben Ihr Objekt anzeigen.

class Money:
    def __init__(self, amount):
        self.amount = amount

    def __format__(self, spec):
        if spec == "usd":
            return f"${self.amount:.2f}"
        return str(self.amount)

m = Money(9.5)
print(f"{m:usd}")  # $9.50

__bool__ für Wahrheitswerte

__bool__ ermöglicht die Auswertung Ihres Objekts in booleschen Kontexten. Geben Sie True oder False zurück.

class Bag:
    def __init__(self, items):
        self.items = items

    def __bool__(self):
        return len(self.items) > 0

b = Bag([])
if not b:
    print("Bag is empty")  # Bag is empty

__len__ für len()

__len__ ermöglicht die Verwendung von len(obj). Außerdem wird diese Methode für __bool__ verwendet, wenn kein __bool__ definiert ist.

class Stack:
    def __init__(self):
        self.data = []

    def push(self, v): self.data.append(v)

    def __len__(self):
        return len(self.data)

s = Stack()
s.push(1)
print(len(s))  # 1

__eq__ für Gleichheit

Definieren Sie __eq__, um festzulegen, wann zwei Instanzen mit == gleich sind.

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

print(Vector(1,2) == Vector(1,2))  # True

__hash__ in Verbindung mit __eq__

Wenn Sie __eq__ definieren, setzt Python __hash__ auf None, wodurch das Objekt nicht hashbar ist. Definieren Sie zusätzlich __hash__, wenn Sie das Objekt in Sets oder Dictionaries benötigen.

class Point:
    def __init__(self, x, y): self.x, self.y = x, y
    def __eq__(self, o): return (self.x, self.y) == (o.x, o.y)
    def __hash__(self): return hash((self.x, self.y))

pts = {Point(1,2), Point(1,2)}
print(len(pts))  # 1

__add__ und Arithmetik

Arithmetische Operatoren entsprechen Dunder-Methoden: __add__ für +, __sub__ für - usw.

class Vector:
    def __init__(self, x, y): self.x, self.y = x, y
    def __add__(self, o): return Vector(self.x+o.x, self.y+o.y)
    def __repr__(self): return f"Vector({self.x},{self.y})"

print(Vector(1,2) + Vector(3,4))  # Vector(4,6)

__getitem__ für Indizierung

__getitem__ ermöglicht es Ihrer Klasse, eine Indizierung mit eckigen Klammern wie obj[key] zu unterstützen.

class Matrix:
    def __init__(self, data):
        self.data = data

    def __getitem__(self, idx):
        return self.data[idx]

m = Matrix([[1,2],[3,4]])
print(m[0])     # [1, 2]
print(m[1][0])  # 3

Kurzer Test

Welche Dunder-Methode wird aufgerufen, wenn Sie print(obj) verwenden?

Zusammenfassung

Magic Methods verleihen Ihren Klassen Python-typisches Verhalten. __repr__ richtet sich an Entwickler, __str__ an Benutzer. Definieren Sie __eq__, __hash__ und arithmetische Dunder-Methoden, damit Objekte vollständig funktional sind.

Häufig gestellte Fragen

Ist die Lektion „Magic Methods: __str__ und __repr__“ kostenlos?

Ja — der vollständige Text von „Magic Methods: __str__ und __repr__“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Magic Methods: __str__ und __repr__“?

Implementieren Sie Dunder-Methoden für lesbare Darstellungen von Objekten. Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Magic Methods: __str__ und __repr__“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Klassen und die __init__-Methode
  2. Instanz- und Klassenattribute
  3. Instanzmethoden und self
  4. Magic Methods: __str__ und __repr__
← Zurück zu Python Academy