Bien utiliser print() en Python : guide débutant complet

La fonction print() est l’un des premiers outils à connaître en Python. Elle sert à envoyer des informations vers la sortie standard, qui correspond le plus souvent à la console ou au terminal dans lequel le programme est exécuté. Au début, elle permet d’afficher un message simple. Très vite, elle devient aussi un moyen pratique de montrer le contenu d’une variable, de vérifier le déroulement d’un calcul ou de présenter un résultat à une personne qui utilise le programme.

Bien utiliser print() ne consiste donc pas uniquement à écrire un texte entre guillemets. Il faut distinguer un texte littéral d’une variable, comprendre ce que fait la virgule entre plusieurs valeurs, savoir modifier le séparateur avec sep, changer le comportement de fin de ligne avec end et insérer des retours à la ligne volontairement. Ces notions sont petites, mais elles sont très utiles dans tous les premiers programmes Python.

Ce tutoriel se concentre sur l’affichage en console avec print(). Vous apprendrez à produire une sortie claire, à éviter les erreurs classiques de syntaxe et à choisir une écriture lisible. Les exemples peuvent être saisis dans un fichier Python ou exécutés dans l’interpréteur interactif.

Prérequis

Avoir accès à une installation de Python et à un terminal, ou à un environnement permettant d’exécuter du Python.
Savoir créer et lancer un fichier portant l’extension .py, même si le détail dépend de votre système ou de votre éditeur.
Connaître les notions très élémentaires de chaîne de caractères et de variable est utile, mais elles sont rappelées dans les exemples.

Aucune bibliothèque externe n’est nécessaire : print() est disponible directement en Python.

Matériel nécessaire

Python installé
Terminal ou console Python
Éditeur de texte ou environnement de développement

Étapes

1
Comprendre le rôle de print()

En Python, print() est une fonction. Dans sa forme la plus simple, elle reçoit une valeur entre parenthèses et l’affiche :
python
```
print("Bonjour")
```
Lors de l’exécution, la console affiche :
python
```
Bonjour
```
Le mot Bonjour est placé entre guillemets : c’est une chaîne de caractères, c’est-à-dire du texte. Python doit savoir qu’il s’agit de texte à afficher, et non du nom d’une variable ou d’une instruction. Des guillemets doubles ou simples peuvent être employés pour délimiter une chaîne :
python
```
print("Bonjour")
print('Au revoir')
```
Les deux lignes affichent du texte. Dans un même programme, il est généralement préférable de conserver une convention cohérente, par exemple les guillemets doubles, sauf lorsqu’un autre choix rend la chaîne plus lisible.
Après chaque appel ordinaire à print(), Python place le curseur sur une nouvelle ligne. C’est pourquoi les deux appels précédents donnent deux lignes distinctes. Ce retour à la ligne automatique est un comportement par défaut ; nous verrons plus loin comment le modifier.
Vous pouvez également afficher d’autres types de valeurs simples :
python
```
print(42)
print(3.14)
print(True)
```
Ici, le nombre entier, le nombre décimal et la valeur booléenne ne sont pas entourés de guillemets. Python les traite comme des valeurs, puis les représente sous forme de texte pour l’affichage. Cette différence est importante : print(42) affiche un nombre, tandis que print("42") affiche une chaîne contenant les caractères 4 et 2. Le résultat visible est semblable, mais la nature de la valeur n’est pas la même dans le programme.
Pour vos premiers essais, créez un fichier nommé par exemple affichage.py, ajoutez une ligne print("Mon premier affichage"), enregistrez-le puis exécutez-le. L’objectif est de relier clairement le code écrit à la ligne observée dans la console.
2
Afficher du texte : guillemets, apostrophes et caractères spéciaux

Une chaîne peut contenir des espaces, des chiffres et la plupart des caractères usuels. Les espaces situés à l’intérieur des guillemets font partie du texte affiché :
python
```
print("Python est agréable à apprendre")
```
Les guillemets qui ouvrent la chaîne doivent correspondre à ceux qui la ferment. Cette ligne est incorrecte :
python
```
print("Bonjour')
```
Python ne peut pas déterminer où le texte se termine. Utilisez une paire identique :
python
```
print("Bonjour")
print('Bonjour')
```
Le choix entre guillemets simples et doubles est particulièrement pratique lorsqu’une phrase contient une apostrophe. Avec des guillemets doubles autour de la chaîne, l’apostrophe n’a pas besoin de traitement spécial :
python
```
print("Aujourd'hui, j'apprends Python.")
```
Si vous voulez afficher des guillemets doubles dans une chaîne elle-même délimitée par des guillemets doubles, vous pouvez les protéger avec une barre oblique inverse, appelée backslash :
python
```
print("Il a dit : \"Bonjour\"")
```
La console affiche alors les guillemets autour du mot Bonjour. La séquence \" indique que le guillemet fait partie du texte et ne ferme pas la chaîne. De la même manière, \\ permet d’afficher une barre oblique inverse.
Il est conseillé de garder les messages simples et explicites. Un affichage comme print("Calcul terminé") est plus utile qu’un message imprécis tel que print("OK") lorsque votre programme commence à comporter plusieurs étapes. Lors du débogage, précisez aussi le contexte : print("Valeur lue :", valeur) permet de comprendre immédiatement ce que représente le nombre affiché.
Évitez de confondre les parenthèses de la fonction avec les guillemets du texte. Les parenthèses sont nécessaires pour appeler print en Python actuel ; les guillemets ne sont nécessaires que si l’élément à afficher est du texte littéral.
3
Afficher la valeur d’une variable

Une variable est un nom qui référence une valeur. Pour afficher son contenu, écrivez son nom sans guillemets dans print() :
python
```
prenom = "Lina"
print(prenom)
```
La sortie est :
python
```
Lina
```
Dans cet exemple, prenom désigne la chaîne "Lina". Si vous écriviez print("prenom"), Python afficherait le mot prenom, car ce mot serait alors du texte littéral. C’est une erreur très fréquente au début : les guillemets changent complètement ce qui est affiché.
Voici le même principe avec un entier :
python
```
age = 18
print(age)
```
Vous pouvez ensuite modifier la variable puis afficher sa nouvelle valeur :
python
```
score = 10
print(score)
score = 15
print(score)
```
Les deux affichages correspondent à l’état de la variable au moment où chaque ligne est exécutée. print() ne mémorise pas une valeur pour plus tard : il affiche ce qui lui est fourni à l’instant de l’appel.
Pour rendre le résultat compréhensible, associez souvent un libellé et la variable :
python
```
produit = "cahier"
quantite = 3
print("Produit :", produit)
print("Quantité :", quantite)
```
La virgule est importante ici. Elle transmet deux arguments distincts à print() : le texte "Produit :" et la valeur contenue dans produit. Par défaut, Python place un espace entre les arguments. Le résultat est donc naturellement lisible :
python
```
Produit : cahier
Quantité : 3
```
Cette écriture évite une conversion manuelle du nombre en texte dans de nombreux cas simples. Elle accepte sans difficulté des valeurs de types différents :
python
```
nom = "Maya"
points = 27
print("Joueuse :", nom, "— points :", points)
```
Le tiret long présenté ici est simplement un caractère de texte. Vous pouvez le remplacer par un deux-points, un tiret classique ou toute ponctuation adaptée à votre message.
4
Passer plusieurs valeurs à print()

La fonction print() peut recevoir plusieurs arguments, séparés par des virgules. C’est la manière la plus directe d’afficher plusieurs informations sur une ligne :
python
```
ville = "Lyon"
pays = "France"
print("Ville", ville, "Pays", pays)
```
Par défaut, chaque argument est séparé du suivant par un espace. La sortie est donc :
python
```
Ville Lyon Pays France
```
Les virgules ne sont pas affichées. Elles appartiennent à la syntaxe Python qui sépare les arguments de la fonction. Si vous souhaitez une virgule visible dans le résultat, placez-la dans une chaîne :
python
```
print("Ville :", ville, ", pays :", pays)
```
Cette version donne une phrase plus structurée. Remarquez qu’il n’est pas indispensable d’ajouter des espaces au début des chaînes ", pays :" : le séparateur par défaut ajoute déjà un espace entre les arguments. Toutefois, dans cet exemple, la chaîne commence par une virgule, et l’espace qui la suit est un choix de ponctuation lisible.
Comparez les deux écritures suivantes :
python
```
nom = "Noé"
age = 12
print("Nom : " + nom)
print("Âge :", age)
```
La première utilise l’opérateur + pour concaténer deux chaînes. La seconde transmet deux arguments à print(). Avec +, toutes les parties doivent être des chaînes. Ainsi, cette ligne provoquerait une erreur :
python
```
print("Âge : " + age)
```
En effet, age contient ici un entier. Pour utiliser la concaténation, il faudrait le convertir explicitement :
python
```
print("Âge : " + str(age))
```
À l’inverse, print("Âge :", age) est souvent plus simple pour débuter, car print() affiche les arguments fournis sans vous demander de convertir manuellement cet entier dans ce cas. La concaténation reste utile lorsque vous construisez une chaîne destinée à être réutilisée, stockée ou transmise à une autre partie du programme. Mais pour un affichage immédiat, les arguments séparés par des virgules constituent une solution claire.
Vous pouvez aussi afficher le résultat d’une expression :
python
```
largeur = 8
hauteur = 5
print("Aire :", largeur * hauteur)
```
Python calcule d’abord largeur * hauteur, puis print() affiche le libellé et le résultat.
5
Contrôler l’espace avec le paramètre sep

Le comportement qui ajoute un espace entre plusieurs arguments est contrôlé par le paramètre nommé sep, abréviation de separator. Par défaut, sa valeur est un espace. Vous pouvez la remplacer par une autre chaîne.
Par exemple, pour construire une date avec des tirets :
python
```
jour = 7
mois = 4
annee = 2025
print(jour, mois, annee, sep="-")
```
La sortie est :
python
```
7-4-2025
```
La fonction reçoit ici trois valeurs à afficher et un paramètre nommé. La syntaxe sep="-" signifie que le tiret doit être inséré entre chaque paire d’arguments successifs. Il ne place pas de tiret avant le premier élément ni après le dernier.
Vous pouvez utiliser d’autres séparateurs :
python
```
print("rouge", "vert", "bleu", sep=" | ")
print("a", "b", "c", sep="")
print("un", "deux", "trois", sep=" / ")
```
La première ligne utilise une barre verticale entourée d’espaces. La deuxième emploie une chaîne vide : aucun caractère n’est ajouté entre les valeurs, ce qui produit abc. La troisième utilise une barre oblique entourée d’espaces.
Le paramètre sep n’a d’effet que lorsqu’il y a plusieurs arguments à séparer. Dans l’appel suivant, le séparateur ne peut pas s’insérer, car il n’y a qu’une valeur :
python
```
print("seul", sep="-")
```
Il est particulièrement utile pour afficher des données structurées sans multiplier les concaténations. Voici un exemple de coordonnées :
python
```
x = 12
y = 9
print(x, y, sep=",")
```
Le résultat est 12,9. Si vous préférez une présentation plus descriptive pour une personne, utilisez plutôt des libellés :
python
```
print("x =", x, "y =", y, sep=" ; ")
```
Le choix du séparateur dépend du résultat attendu. Un espace convient à une phrase simple, une virgule peut convenir à une liste courte et un tiret à une date. Gardez toutefois à l’esprit que le format affiché dans la console n’est pas automatiquement un fichier de données : print() sert ici à présenter une ligne, pas à garantir un format d’échange particulier.
6
Maîtriser la fin de ligne avec le paramètre end

Par défaut, print() termine son affichage par un retour à la ligne. Ce comportement est contrôlé par le paramètre nommé end. Sa valeur par défaut correspond au caractère de nouvelle ligne, noté \n.
Pour observer le comportement standard :
python
```
print("première ligne")
print("deuxième ligne")
```
Chaque appel commence sur une nouvelle ligne. Si vous définissez end comme une chaîne vide, le prochain affichage continue exactement à la suite :
python
```
print("Bonjour", end="")
print(" tout le monde")
```
La console affiche :
python
```
Bonjour tout le monde
```
Dans cet exemple, un espace a été placé au début de la seconde chaîne. Il est nécessaire parce que end="" n’ajoute rien après Bonjour. Vous pourriez aussi mettre l’espace dans end :
python
```
print("Bonjour", end=" ")
print("tout le monde")
```
Cette version affiche le même résultat, mais la responsabilité de l’espace est portée par le premier appel. Les deux approches fonctionnent ; choisissez celle qui vous paraît la plus facile à lire.
Vous pouvez terminer chaque affichage par un symbole particulier :
python
```
print("Chargement", end="...")
print(" terminé")
```
La sortie forme une seule ligne :
python
```
Chargement... terminé
```
Un usage courant consiste à écrire plusieurs éléments sur une même ligne, puis à terminer explicitement par un appel vide :
python
```
for nombre in range(1, 6):
    print(nombre, end=" ")
print()
```
La boucle affiche les nombres de 1 à 5, chacun suivi d’un espace. Le dernier print(), sans argument, produit uniquement le retour à la ligne final. Il est utile pour que l’affichage suivant ne commence pas immédiatement après le dernier nombre.
Le paramètre end ne doit pas être confondu avec sep. sep s’insère entre les arguments d’un même appel. end est ajouté après tout ce que cet appel a affiché. Les deux peuvent être utilisés ensemble :
python
```
print("A", "B", "C", sep="-", end=".")
print(" Fin")
```
Le premier appel produit A-B-C. sans retour à la ligne ; le second commence immédiatement après le point et termine ensuite la ligne normalement.
7
Insérer des retours à la ligne volontairement

Le retour à la ligne automatique de print() est suffisant pour beaucoup de programmes. Il est néanmoins parfois nécessaire de créer plusieurs lignes dans un seul appel. Pour cela, utilisez la séquence \n à l’intérieur d’une chaîne :
python
```
print("Titre\nSous-titre\nFin")
```
La sortie est :
python
```
Titre
Sous-titre
Fin
```
Le caractère \n n’est pas affiché sous la forme d’une barre oblique et de la lettre n : dans une chaîne Python ordinaire, il représente un saut de ligne. Vous pouvez l’utiliser pour composer un message sur plusieurs lignes :
python
```
nom = "Inès"
message = "Bonjour " + nom + "\nVotre inscription est confirmée."
print(message)
```
Cette approche est adaptée lorsqu’une variable contient déjà un texte formaté en plusieurs lignes. Pour un petit affichage fixe, plusieurs appels à print() restent souvent plus faciles à modifier :
python
```
print("Bonjour Inès")
print("Votre inscription est confirmée.")
```
Python permet aussi d’écrire une chaîne sur plusieurs lignes avec des guillemets triples. Utilisez trois guillemets doubles au début et à la fin :
python
```
print("""Liste :
- lire le cours
- essayer les exemples
- enregistrer le fichier""")
```
Les retours à la ligne présents dans la chaîne sont conservés. Cette forme peut être pratique pour un bloc de texte fixe. Attention toutefois à l’indentation : si vous écrivez ce bloc à l’intérieur d’une fonction ou d’une condition avec des espaces devant chaque ligne, ces espaces font également partie de la chaîne et peuvent apparaître à l’écran.
Pour insérer une ligne vide, vous avez deux possibilités simples :
python
```
print()
print("Nouveau paragraphe")
```
ou :
python
```
print("\nNouveau paragraphe")
```
La première forme est généralement plus explicite quand vous voulez séparer deux parties de votre affichage. La seconde est utile quand le saut de ligne appartient réellement au message construit.
8
Combiner texte, variables, sep et end dans un mini-programme

Mettons les éléments précédents en pratique avec un petit programme qui affiche les informations d’un article. L’exemple utilise des variables, plusieurs arguments, un séparateur personnalisé, un retour à la ligne dans une chaîne et une ligne construite progressivement :
python
```
article = "stylo"
prix = 2.5
stock = 14

print("FICHE ARTICLE")
print("-" * 20)
print("Nom :", article)
print("Prix :", prix, "€")
print("Stock :", stock)
print("Code :", "A", 17, 4, sep="-")
print("État :", end=" ")
print("disponible")
print("\nMerci de votre visite.")
```
La ligne print("-" * 20) affiche vingt tirets. Python évalue d’abord l’expression "-" * 20, qui répète la chaîne, puis transmet le résultat à print(). C’est une manière simple de créer une séparation visuelle.
La ligne relative au prix contient trois arguments : le libellé, la valeur de prix et le symbole euro. Avec le séparateur par défaut, des espaces apparaissent entre eux. Si vous vouliez que le symbole soit collé au nombre, vous pourriez écrire :
python
```
print("Prix :", str(prix) + "€")
```
Cette variante illustre un cas où une conversion avec str() est utile : elle transforme le nombre en chaîne afin de pouvoir le joindre au symbole avec +. Le choix dépend de la sortie souhaitée. Pour un message débutant et lisible, l’espace avant le symbole peut être parfaitement acceptable.
La ligne du code utilise sep="-" pour placer un tiret entre les quatre valeurs. Enfin, les deux appels pour l’état utilisent end=" " : le premier ne retourne pas à la ligne et ajoute un espace, le second complète la phrase.
Exécutez le programme, puis modifiez seulement les valeurs des variables. Vérifiez que le texte affiché se met à jour sans que les appels à print() aient besoin d’être réécrits. C’est précisément l’intérêt d’afficher des variables plutôt que de recopier leurs valeurs dans des chaînes fixes.
9
Lire et corriger les erreurs d’affichage les plus fréquentes

Lorsqu’un appel à print() ne fonctionne pas comme prévu, regardez d’abord la ligne signalée par Python et comparez-la à l’un des cas suivants.
Oublier les guillemets autour d’un texte. Cette instruction cherche une variable nommée Bonjour :
python
```
print(Bonjour)
```
Si aucune variable de ce nom n’existe, Python signale une erreur. Corrigez ainsi :
python
```
print("Bonjour")
```
Mettre les guillemets autour du nom d’une variable. Cette ligne affiche littéralement le mot nom :
python
```
nom = "Samir"
print("nom")
```
Pour afficher le contenu de la variable, retirez les guillemets :
python
```
print(nom)
```
Oublier une parenthèse. Un appel de fonction doit avoir ses parenthèses fermées :
python
```
print("Test"
```
Vérifiez que chaque parenthèse ouvrante possède une parenthèse fermante :
python
```
print("Test")
```
Utiliser + entre un texte et un entier. Le problème a déjà été vu avec l’âge. Cette version est incorrecte si total est un nombre :
python
```
total = 8
print("Total : " + total)
```
Utilisez soit plusieurs arguments, soit une conversion explicite :
python
```
print("Total :", total)
print("Total : " + str(total))
```
Attendre une nouvelle ligne après end="". Lorsque end vaut une chaîne vide, l’appel suivant continue sur la même ligne. Ajoutez un print() vide après votre séquence, ou n’utilisez pas end si un retour à la ligne est souhaité.
Confondre une vraie nouvelle ligne avec les caractères visibles \ et n. Dans une chaîne ordinaire, \n produit un saut de ligne. Si vous observez les deux caractères tels quels, examinez attentivement la chaîne écrite et la manière dont elle a été construite.
Dans tous les cas, réduisez temporairement votre programme à une ou deux lignes. Affichez une variable seule, puis ajoutez le texte, puis le séparateur. Cette progression permet d’identifier précisément l’élément responsable du résultat inattendu.

Erreurs fréquentes & dépannage

Erreurs courantes à éviter

Écrire du texte sans guillemets : Python l’interprète comme un nom à rechercher.
Écrire le nom d’une variable entre guillemets : vous affichez le nom, pas sa valeur.
Employer + avec une chaîne et un entier sans conversion : préférez print("Libellé :", valeur) ou utilisez str(valeur).
Oublier que sep agit entre les arguments : il ne modifie pas automatiquement le contenu d’une seule chaîne.
Oublier que end remplace la fin de ligne : avec end="", la ligne suivante s’ajoute à la même ligne.
Masquer une information utile derrière un message vague : pendant les essais, affichez un libellé et la valeur concernée.

Astuces & pour aller plus loin

Bonnes pratiques pour des affichages lisibles

Utilisez un libellé explicite devant une variable : print("Score :", score) est plus parlant que print(score) seul.
Employez les arguments séparés par des virgules pour afficher rapidement du texte et des nombres ensemble.
Réservez sep aux séparateurs répétés dans un même appel, comme les tirets d’une date ou les barres d’une liste.
Ajoutez un print() vide après une série d’affichages avec end pour retrouver une console propre.
Préférez plusieurs appels simples à une expression trop longue lorsque vous débutez : le code sera plus facile à lire et à corriger.
Pour vérifier une variable, affichez à la fois son nom descriptif et sa valeur, par exemple print("prix =", prix).

Questions fréquentes

Quelle est la différence entre print("nom") et print(nom) ?

print("nom") affiche le texte littéral nom. print(nom) affiche la valeur contenue dans la variable appelée nom, à condition que cette variable ait été définie auparavant.

Pourquoi print() ajoute-t-il un espace entre mes variables ?

Lorsque plusieurs arguments sont séparés par des virgules, print() utilise par défaut un espace comme séparateur. Vous pouvez modifier ce comportement avec un paramètre tel que sep="-" ou supprimer cet espace avec sep="".

Comment ne pas aller à la ligne après print() ?

Utilisez le paramètre end. Par exemple, print("Bonjour", end="") n’ajoute pas de retour à la ligne. Vous pouvez aussi choisir un autre suffixe, comme un espace avec end=" ".

Comment afficher une ligne vide en Python ?

Appelez print() sans argument. Cet appel n’affiche aucun texte, mais conserve le retour à la ligne par défaut.

Puis-je utiliser sep et end dans le même print() ?

Oui. sep contrôle ce qui est placé entre les arguments, tandis que end contrôle ce qui est ajouté après l’ensemble de l’affichage. Par exemple : print("1", "2", sep="-", end=".").

Faut-il toujours convertir un nombre avec str() avant de l’afficher ?

Non. print(nombre) et print("Valeur :", nombre) affichent directement un nombre. La conversion str() devient utile lorsque vous voulez joindre ce nombre à une chaîne avec l’opérateur +.

Conclusion

La fonction print() est simple à appeler, mais elle offre déjà des outils précis pour organiser une sortie en console. Retenez la distinction essentielle entre texte entre guillemets et variable sans guillemets. Pour afficher plusieurs informations, passez-les comme arguments séparés par des virgules ; Python ajoute alors un espace par défaut.

Utilisez sep pour choisir ce qui sépare les arguments d’un même appel, et end pour décider de ce qui suit l’affichage, notamment lorsque vous voulez rester sur la même ligne. Enfin, les appels successifs, \n et les chaînes multilignes vous permettent de créer les retours à la ligne dont votre message a besoin.

Dans vos prochains programmes, servez-vous de print() pour présenter les résultats, mais aussi pour vérifier les valeurs intermédiaires pendant vos essais. Un affichage court, explicite et bien séparé vous aidera à comprendre plus vite le comportement de votre code.

Bien utiliser print() en Python : guide débutant complet

Prérequis

Matériel nécessaire

Étapes

Comprendre le rôle de print()

Afficher du texte : guillemets, apostrophes et caractères spéciaux

Afficher la valeur d’une variable

Passer plusieurs valeurs à print()

Contrôler l’espace avec le paramètre sep

Maîtriser la fin de ligne avec le paramètre end

Insérer des retours à la ligne volontairement

Combiner texte, variables, sep et end dans un mini-programme

Lire et corriger les erreurs d’affichage les plus fréquentes