Skip to content

str vs repr in Python: Erklärt

Im Bereich der Python-Programmierung sind __str__ und __repr__ sogenannte "dunder" (double underscore) Methoden, auch bekannt als Magie- oder Spezialmethoden. Sie dienen als Grundlage für die objektorientierte Programmierung in Python. Dieser umfassende Leitfaden soll die unterschiedlichen Funktionalitäten dieser beiden Methoden, ihre Bedeutung in Python und die geeigneten Anwendungsfälle erläutern. Darüber hinaus werden zahlreiche Codebeispiele präsentiert, um die zugrunde liegenden Konzepte zu vertiefen.

Möchten Sie Datenauswertung aus einem Python Pandas Dataframe schnell und ohne Code erstellen?

PyGWalker ist eine Python-Bibliothek für die explorative Datenanalyse mit Visualisierung. PyGWalker (opens in a new tab) kann Ihren Workflow für Datenanalyse und Datenvisualisierung in Jupyter Notebook vereinfachen, indem es Ihren Pandas Dataframe (und Polars Dataframe) in eine Tableau-artige Benutzeroberfläche für visuelle Exploration umwandelt.

PyGWalker für Datenvisualisierung (opens in a new tab)

Definition der Begriffe: __str__ vs __repr__

Bevor wir uns ins Detail stürzen, beginnen wir damit, diese beiden wichtigen Methoden zu definieren:

Methode __str__

In Python ist __str__ die Methode, die zur Berechnung der "informellen" oder gut lesbar gedruckten Zeichenkettendarstellung eines Objekts verwendet wird. Sie zielt darauf ab, eine für Menschen lesbare Ausgabe bereitzustellen. Lesbarkeit ist daher ein wichtiger Aspekt bei der Implementierung dieser Methode.

Hier ist ein einfaches Beispiel:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def __str__(self):
        return f'{self.name} ist {self.age} Jahre alt.'
 
john = Person('John Doe', 30)
print(str(john))  # Ausgabe: John Doe ist 30 Jahre alt.

Methode __repr__

Die Methode __repr__ hingegen wird verwendet, um die "offizielle" Zeichenkettenrepräsentation eines Objekts zu berechnen. Ihr Zweck ist es, eine detaillierte Repräsentation bereitzustellen, die verwendet werden kann, um das Objekt mithilfe der Funktion eval() neu zu erstellen. Sie ist besonders nützlich für Debugging und Logging, da sie eine umfassende Beschreibung des Objekts liefert.

Betrachten wir dieselbe Klasse Person, aber mit einer __repr__ Methode:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def __repr__(self):
        return f'Person(name={self.name}, age={self.age})'
 
john = Person('John Doe', 30)
print(repr(john))  # Ausgabe: Person(name=John Doe, age=30)

Wann sollte man __str__ vs __repr__ verwenden?

Nun, da wir ein grundlegendes Verständnis für diese Methoden haben, wollen wir erkunden, wann wir jede einzelne verwenden sollten.

Implementierung von __str__ für eine benutzerfreundliche Zeichenkettenrepräsentation

Die Methode __str__ ist hauptsächlich für Endbenutzer gedacht. Sie liefert eine informelle, leicht lesbare Beschreibung eines Objekts. Man kann sie sich als eine Möglichkeit vorstellen, Objekte so darzustellen, dass sie für Benutzer, die nicht unbedingt Programmierer sind, Sinn ergeben.

Bei der Implementierung dieser Methode in Ihren Python-Klassen konzentrieren Sie sich darauf, Informationen bereitzustellen, die für den Endbenutzer am relevantesten und nützlichsten sind.

class Produkt:
    def __init__(self, name, price):
        self.name = name
        self.price = price
 
    def __str__(self):
        return f'{self.name} kostet ${self.price}.'
 
iPhone = Produkt('iPhone', 999)
print(str(iPhone))  # Ausgabe: iPhone kostet $999.

In dem obigen Beispiel liefert die Methode __str__ eine einfache, für Menschen lesbare Beschreibung des Produkt-Objekts. Die Ausgabe von str(iPhone) könnte direkt Benutzern auf einer Website oder in einer App angezeigt werden.

Implementierung von __repr__ für Debugging und Entwicklung

Die Methode __repr__ hingegen ist hauptsächlich für Entwickler gedacht. Sie liefert eine vollständige und eindeutige Repräsentation des Objekts, die für Debugging und Logging sehr nützlich sein kann.

Eine goldene Regel bei der Implementierung der Methode __repr__ ist, dass sie, wenn möglich, eine Zeichenkette zurückgeben sollte, die die Neuerstellung des Objekts mithilfe der Funktion eval() ermöglicht. Dies ist nicht immer möglich, insbesondere bei komplexen Objekten, aber es ist eine gute Richtlinie, der man folgen kann.

Betrachten wir die Klasse Produkt mit einer __repr__ Methode:

class Produkt:
    def __init__(self, name, price):
        self.name = name
        self.price = price
 
    def __repr__(self):
        return f'Produkt(name={self.name}, price={self.price})'
 
iPhone = Produkt('iPhone', 999)
print(repr(iPhone))  # Ausgabe: Produkt(name=iPhone, price=999)

Die Ausgabe der Methode __repr__ ist im Vergleich zur Methode __str__ viel detaillierter und technischer. Dieses Detailniveau ist genau das, was ein Entwickler für effektives Debugging oder Logging benötigt.

Anpassung von __str__ und __repr__ für Ihre Python-Klassen

Nun, da Sie die Hauptverwendungszwecke beider Methoden verstehen, wollen wir besprechen, wie man sie an Ihre Bedürfnisse anpassen kann. In vielen Fällen möchten Sie beide Methoden in Ihren Klassen definieren, aber ihre Implementierung wird stark von Ihrem spezifischen Anwendungsfall abhängen.

Definition von __str__ für benutzerdefinierte informelle Zeichenkettenrepräsentation

Bei der Definition der Methode __str__ sollten Sie darüber nachdenken, mit welchen Personen Ihr Objekt interagieren wird und was sie wissen müssen. Die Methode sollte eine Zeichenkette zurückgeben, die eine prägnante, für Menschen lesbare Zusammenfassung des Objekts liefert.

Nehmen wir an, wir haben eine Film-Klasse in einer Anwendung zur Buchung von Kinokarten:

class Film:
    def __init__(self, title, director, rating):
        self.title = title
        self.director = director
        self.rating = rating
 
def __str__(self):
    return f'{self.title} von {self.director}, bewertet mit {self.rating}/10.'

inception = Movie('Inception', 'Christopher Nolan', 8.8)
print(str(inception))  # Ausgabe: Inception von Christopher Nolan, bewertet mit 8.8/10.

Erstellung von __repr__ für detaillierte Objektbeschreibung

Bei der Implementierung der __repr__-Methode sollte darüber nachgedacht werden, was für das Debuggen des Codes oder das Protokollieren des Zustands eines Objekts nützlich wäre. Der String sollte alle Informationen enthalten, die erforderlich sind, um das Objekt auf den ersten Blick zu verstehen.

Im Falle der Movie-Klasse könnte die __repr__-Methode wie folgt aussehen:

class Movie:
    def __init__(self, title, director, rating):
        self.title = title
        self.director = director
        self.rating = rating
 
    def __repr__(self):
        return f'Movie(title={self.title}, director={self.director}, rating={self.rating})'
 
inception = Movie('Inception', 'Christopher Nolan', 8.8)
print(repr(inception))  # Ausgabe: Movie(title=Inception, director=Christopher Nolan, rating=8.8)

FAQs: Verständnis von __str__ und __repr__ in Python

Wir haben nun die Grundkonzepte von __str__ und __repr__ in Python erkundet. Allerdings gibt es immer noch Fragen zu diesen Dunder-Methoden. Lassen Sie uns einige häufig gestellte Fragen klären.

  1. Was passiert, wenn ich __str__ und __repr__ nicht in meiner Python-Klasse definiere?

    Wenn Sie __str__ oder __repr__ in Ihrer Klasse nicht definieren, verwendet Python die standardmäßigen Implementierungen. Die Standard-__str__-Methode gibt einen String zurück, der den Klassennamen und seine Speicheradresse enthält, während __repr__ dasselbe tut.

  2. Sollte ich immer sowohl __str__ als auch __repr__-Methoden in meinen Klassen implementieren?

    Es ist eine gute Praxis, mindestens __repr__ zu implementieren, da es verwendet wird, wenn __str__ nicht definiert ist. Ob Sie beide implementieren sollten, hängt jedoch von Ihren spezifischen Bedürfnissen ab. Wenn die Objekte Ihrer Klasse eine benutzerfreundliche Zeichenfolgendarstellung benötigen, lohnt sich auch die Implementierung von __str__.

  3. Können __str__ und __repr__ beliebige Zeichenketten zurückgeben?

    Obwohl __str__ und __repr__ technisch gesehen beliebige Zeichenketten zurückgeben können, ist es am besten, den Konventionen zu folgen: __str__ sollte lesbar und prägnant sein, während __repr__ detailliert sein und es nach Möglichkeit ermöglichen sollte, das Objekt mit eval() zu reproduzieren.