Le Guide Définitif des Triples Guillemets en Python : Multiligne, Guillemets Internes et Docstring

Les triples guillemets (""" ou ''') en Python sont d’une simplicité trompeuse — mais d’une puissance incroyable. Ils permettent :

• D’écrire des chaînes de caractères sur plusieurs lignes avec de vrais sauts de ligne
• D’intégrer naturellement à la fois des apostrophes (') et des guillemets (")
• De créer des docstrings pour les fonctions, classes et modules
• De les combiner avec les f-strings pour produire un texte clair et dynamique

Voyons comment les utiliser efficacement à travers des exemples concrets.

​

1. Écrire des chaînes multilignes

​

Méthode traditionnelle : \n et concaténation

Vous pouvez insérer des sauts de ligne avec \n :

1text = "Bonjour ! Je m'appelle Python.\nJ'ai été conçu pour la lisibilité.\nCe code, en revanche, ne l'est pas."
2print(text)

Mais cela devient vite illisible pour des chaînes plus longues. On peut alors découper et concaténer :

1text = "Ceci est la première ligne.\n" + \
2       "Ceci est la deuxième.\n" + \
3       "Et voici la troisième."

Lisible ? On a vu mieux.

​

Les triples guillemets à la rescousse

Les triples guillemets simplifient tout cela :

1text = """Bonjour, je suis une chaîne multilignes.
2Je capture automatiquement
3tous les sauts de ligne,
4
5y compris la ligne vide ci-dessus."""
6print(text)

La sortie conserve les retours à la ligne — aucun \n manuel requis.

Cependant, l’indentation dans une fonction ajoute des espaces à votre texte :

1def show_message():
2    msg = """Ligne A
3    Ligne B
4    Ligne C"""
5    return msg
6
7print(show_message())

Sortie :

Ligne A
    Ligne B
    Ligne C

Pour contrôler l’indentation, vous pouvez :

• Ajouter un antislash (\) juste après les triples guillemets ouvrants pour ignorer la ligne vide initiale.
• Ou utiliser textwrap.dedent() pour nettoyer les espaces en début de ligne :

1import textwrap
2
3text = """\
4    Ligne propre 1
5    Ligne propre 2
6"""
7print(textwrap.dedent(text))

Sortie :

Ligne propre 1
Ligne propre 2

​

2. Intégrer des guillemets sans échapper

Quand une chaîne contient à la fois ' et ", les caractères d’échappement deviennent pénibles :

1s = "Il a dit : \"N'est-ce pas amusant ?\""

Avec les triples guillemets, tout est clair et net :

1s = """Il a dit : "N'est-ce pas amusant ?""""

Les triples guillemets simples comme doubles fonctionnent :

1s2 = '''Elle a demandé : "N'est-ce pas amusant ?"'''

​

Chaînes brutes avec triples guillemets

Les triples guillemets ne sont pas des chaînes brutes par défaut. Les séquences d’échappement comme \n ou \t sont toujours interprétées.

Pour obtenir un texte littéral, utilisez une chaîne brute à triple guillemet :

1s = r"""Ceci affiche \n et \\ littéralement.
2Les sauts de ligne aussi."""
3print(s)

Sortie :

Ceci affiche \n et \\ littéralement.
Les sauts de ligne aussi.

​

3. Combiner triples guillemets et f-strings

Vous n’avez pas à choisir entre les deux ! On peut combiner le meilleur du Python moderne : les f-strings (chaînes formatées) et la souplesse des triples guillemets.

Il suffit de placer un f avant les guillemets ouvrants :

 1user_name = "Alex"
 2login_count = 14
 3role = "Admin"
 4
 5# F-string multilignes
 6welcome_message = f"""
 7Bonjour, **{user_name}** !
 8Vous vous êtes connecté {login_count} fois avec succès.
 9Votre rôle actuel est : **{role}**.
10
11Merci d'utiliser notre service.
12"""
13print(welcome_message)

Sortie :

Bonjour, **Alex** !
Vous vous êtes connecté 14 fois avec succès.
Votre rôle actuel est : **Admin**.

Merci d'utiliser notre service.

Cette technique est idéale pour les e-mails, modèles ou messages CLI — partout où vous souhaitez du texte structuré avec interpolation de variables.

​

4. Docstrings : les triples guillemets pour la documentation

​

Qu’est-ce qu’un docstring ?

Un docstring est une chaîne placée immédiatement après la définition d’une fonction, d’une classe ou d’un module.

Elle documente ce que fait l’objet — et contrairement à un commentaire, elle est conservée à l’exécution.

Exemple :

1def add(a, b):
2    """Retourne la somme de a et b."""
3    return a + b

Vous pouvez y accéder ainsi :

1print(add.__doc__)
2# Sortie : Retourne la somme de a et b.

Ou utiliser la fonction intégrée help() :

1help(add)

​

Règles de style (PEP 257)

Selon PEP 257 – Conventions de docstrings :

• Utilisez des triples guillemets doubles (""") pour tous les docstrings.
• Commencez par un résumé sur une seule ligne.
• Laissez une ligne vide avant toute description détaillée.
• Respectez l’indentation du bloc de code.

Exemple :

 1def multiply(a, b):
 2    """
 3    Multiplie deux nombres a et b.
 4
 5    Parameters:
 6        a (int ou float): premier opérande
 7        b (int ou float): second opérande
 8
 9    Returns:
10        int ou float : produit de a et b
11    """
12    return a * b

​

Docstrings vs commentaires

Docstrings ≠ commentaires. Les chaînes à triple guillemet dans le code sont exécutées comme des littéraux de chaîne, pas ignorées comme les # :

1def foo():
2    """Docstring valide."""
3    """Ceci n'est pas un commentaire — juste une chaîne inutilisée."""
4    return 42

Seule la première chaîne ("""Docstring valide.""") est considérée comme le docstring de la fonction. La seconde est simplement une chaîne littérale non utilisée ; Python l’évalue, puis la jette, mais elle augmente légèrement la taille du bytecode.

Pour les commentaires, utilisez toujours #.

​

5. Conseils et bonnes pratiques

​

Concaténation implicite

Python concatène automatiquement les littéraux adjacents :

1s = ("Ligne 1\n"
2     "Ligne 2\n"
3     "Ligne 3")

Pratique pour un formatage contrôlé sans triples guillemets.

​

Attention au saut de ligne final

Si une chaîne à triple guillemet se termine par une ligne vide, elle inclut un \n final. Utilisez repr() pour vérifier :

1s = """Ligne un
2Ligne deux
3"""
4print(repr(s))

Sortie :

'Ligne un\nLigne deux\n'

​

Docstrings de module et de classe

Les triples guillemets fonctionnent aussi au niveau des modules et des classes :

1"""Ce module gère l'authentification utilisateur."""
2
3class Auth:
4    """Gestion de l'authentification et des sessions."""

​

6. Fiche mémo rapide

​

Conclusion

Les triples guillemets comptent parmi les fonctionnalités les plus élégantes de Python — ils rendent votre code plus lisible, maintenable et expressif.

Fondamentalement, les chaînes de caractères entre guillemets triples sont sémantiquement identiques aux chaînes entre guillemets simples ou doubles, avec cette différence cruciale qu’elles autorisent des sauts de ligne et des guillemets internes littéraux, sans échappement.

• Utilisez-les pour les chaînes multilignes, les chaînes contenant des guillemets, et les docstrings.
• Combinez-les avec les f-strings pour du contenu dynamique.
• Faites attention à l’indentation et aux sauts de ligne finaux.

Une fois maîtrisés, ils vous permettront d’écrire un code plus clair, plus Pythonique — comme il se doit.