Skip to content

str vs repr en Python : Expliqué

Dans le domaine de la programmation Python, __str__ et __repr__ sont des méthodes sous-double-tiret (double underscore), également connues sous le nom de méthodes magiques ou méthodes spéciales. Elles servent de base à la programmation orientée objet en Python. Ce guide exhaustif vise à éclairer les fonctionnalités distinctives de ces deux méthodes, leur signification en Python et les exemples appropriés pour leur utilisation. De plus, ce guide présentera de nombreux exemples de code pour consolider les concepts sous-jacents.

Voulez-vous créer rapidement une visualisation de données à partir d'un dataframe Pandas avec aucun code ?

PyGWalker est une bibliothèque Python pour l'analyse exploratoire de données avec visualisation. PyGWalker (opens in a new tab) peut simplifier votre flux de travail d'analyse de données et de visualisation de données dans Jupyter Notebook, en transformant votre dataframe pandas (et votre dataframe polars) en une interface utilisateur de type Tableau pour l'exploration visuelle.

PyGWalker pour la visualisation des données (opens in a new tab)

Définition des termes : __str__ vs __repr__

Avant de plonger dans le vif du sujet, commençons par définir ces deux méthodes importantes :

La méthode __str__

En Python, __str__ est la méthode utilisée pour calculer la représentation de chaîne « informelle » ou imprimable d'un objet. Elle vise à fournir une sortie lisible par l'homme. Ainsi, la lisibilité est un aspect clé lors de la mise en œuvre de cette méthode.

Voici un exemple simple :

class Personne:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age
 
    def __str__(self):
        return f'{self.nom} a {self.age} ans.'
 
john = Personne('John Doe', 30)
print(str(john))  # Sortie : John Doe a 30 ans.

La méthode __repr__

En revanche, __repr__ est une méthode utilisée pour calculer la représentation de chaîne « officielle » d'un objet. Son but est de fournir une représentation détaillée qui pourrait être utilisée pour recréer l'objet si on l'injecte dans la fonction eval(). Elle est particulièrement utile pour le débogage et le journalisation, car elle fournit une description complète de l'objet.

Considérez la même classe Personne, mais avec une méthode __repr__ :

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

La sortie de la méthode __repr__ est beaucoup plus détaillée et technique par rapport à la méthode __str__. Ce niveau de détail est précisément ce dont un développeur a besoin pour un débogage ou une journalisation efficace.

Quand utiliser __str__ vs __repr__

Maintenant que nous avons une compréhension de base de ces méthodes, explorons quand utiliser chacune d'entre elles.

Implémenter __str__ pour une représentation de chaîne conviviale pour l'utilisateur

La méthode __str__ est principalement destinée aux utilisateurs finaux. Elle fournit une description informelle, plus lisible de l'objet. On peut la considérer comme un moyen d'afficher des objets de manière à ce qu'ils aient un sens pour les utilisateurs qui ne sont pas nécessairement des programmeurs.

Lors de la mise en œuvre de cette méthode dans vos classes Python, concentrez-vous sur la fourniture d'informations les plus pertinentes et bénéfiques pour l'utilisateur final.

class Produit:
    def __init__(self, nom, prix):
        self.nom = nom
        self.prix = prix
 
    def __str__(self):
        return f'{self.nom} coûte {self.prix} $.'
 
iPhone = Produit('iPhone', 999)
print(str(iPhone))  # Sortie : iPhone coûte 999 $.

Dans l'exemple ci-dessus, la méthode __str__ fournit une description simple et lisible par l'homme de l'objet Produit. La sortie de str(iPhone) pourrait être affichée directement aux utilisateurs sur un site web ou dans une application.

Implémenter __repr__ pour le débogage et le développement

En revanche, la méthode __repr__ est principalement destinée aux développeurs. Elle fournit une représentation complète et non ambiguë de l'objet, ce qui peut être très utile pour le débogage et la journalisation.

Une règle d'or lors de la mise en œuvre de la méthode __repr__ est qu'elle devrait, si possible, renvoyer une chaîne qui permet de recréer l'objet en utilisant la fonction eval(). Cela n'est pas toujours réalisable, surtout pour des objets complexes, mais c'est une bonne ligne directrice à suivre.

Considérez la classe Produit avec une méthode __repr__ :

class Produit:
    def __init__(self, nom, prix):
        self.nom = nom
        self.prix = prix
 
    def __repr__(self):
        return f'Produit(nom={self.nom}, prix={self.prix})'
 
iPhone = Produit('iPhone', 999)
print(repr(iPhone))  # Sortie : Produit(nom=iPhone, prix=999)

La sortie de la méthode __repr__ est beaucoup plus détaillée et technique que la méthode __str__. Ce niveau de détail est exactement ce dont un développeur a besoin pour un débogage ou une journalisation efficace.

Adapter __str__ et __repr__ pour vos classes Python

Maintenant que vous comprenez les cas d'utilisation principaux des deux méthodes, parlons de comment les adapter à vos besoins. Dans de nombreux cas, vous voudrez définir les deux méthodes dans vos classes, mais leur implémentation dépendra fortement de votre cas d'utilisation spécifique.

Concevoir __str__ pour une représentation informelle personnalisée

Lors de la définition de la méthode __str__, pensez aux personnes qui interagiront avec votre objet et à ce qu'elles doivent savoir. La méthode devrait renvoyer une chaîne qui donne un résumé concis et lisible par l'homme de l'objet.

Supposons que nous ayons une classe Film dans une application de réservation de billets de cinéma :

class Film:
    def __init__(self, titre, réalisateur, notation):
        self.titre = titre
        self.réalisateur = réalisateur
        self.notation = notation
 

Voici la traduction française du fichier Markdown sans traduire le code intégré :

def __str__(self):
    return f'{self.title} par {self.director}, noté {self.rating}/10.'
 
inception = Movie('Inception', 'Christopher Nolan', 8.8)
print(str(inception))  # Résultat : Inception par Christopher Nolan, noté 8.8/10.

Elaboration de __repr__ pour une description détaillée de l'objet

Lors de l'implémentation de la méthode __repr__, il est important de réfléchir à ce qui serait utile pour déboguer le code ou enregistrer l'état d'un objet. La chaîne de caractères doit inclure toutes les informations nécessaires pour comprendre rapidement l'objet.

Poursuivant avec la classe Movie, une méthode __repr__ pourrait ressembler à ceci :

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))  # Résultat : Movie(title=Inception, director=Christopher Nolan, rating=8.8)

FAQ : Comprendre __str__ et __repr__ de Python

Nous avons maintenant exploré les concepts fondamentaux des méthodes __str__ et __repr__ de Python. Cependant, vous pourriez encore avoir des questions à propos de ces méthodes spéciales. Examinons quelques questions fréquemment posées.

  1. Que se passe-t-il si je ne définis pas __str__ et __repr__ dans ma classe Python ?

    Si vous ne définissez pas __str__ ou __repr__ dans votre classe, Python utilise ses implémentations par défaut. La méthode __str__ par défaut renvoie une chaîne de caractères contenant le nom de la classe et son adresse en mémoire, tout comme la méthode __repr__ par défaut.

  2. Dois-je toujours implémenter à la fois __str__ et __repr__ dans mes classes ?

    Il est recommandé d'implémenter au moins __repr__, car elle est utilisée en tant que solution de secours si __str__ n'est pas définie. Cependant, la décision d'implémenter les deux dépend de vos besoins spécifiques. Si les objets de votre classe doivent avoir une représentation sous forme de chaîne conviviale pour l'utilisateur, il est également intéressant d'implémenter __str__.

  3. Est-ce que __str__ et __repr__ peuvent retourner n'importe quel type de chaîne de caractères ?

    Bien que __str__ et __repr__ puissent théoriquement retourner n'importe quelle chaîne de caractères, il est préférable de suivre les conventions : __str__ doit être lisible et concis, tandis que __repr__ doit être détaillé et, si possible, permettre à l'objet d'être reproduit à l'aide de eval().