Afficher des données à l'écran (print())

La fonction print() : afficher des valeurs

La fonction intégrée `print()` est la fonction principale pour afficher des données à l'écran en Python (sur la sortie standard, généralement la console).

Syntaxe de base :

print(valeur1, valeur2, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

• `valeur1, valeur2, ...` : Les valeurs à afficher. Vous pouvez afficher autant de valeurs que vous voulez, séparées par des virgules. `print()` peut afficher des valeurs de n'importe quel type (chaînes, nombres, listes, dictionnaires, objets, etc.).
• `sep=' '` : (Optionnel) Le séparateur à utiliser entre les valeurs. Par défaut, c'est un espace (`' '`).
• `end='\n'` : (Optionnel) La chaîne de caractères à afficher après la dernière valeur. Par défaut, c'est un saut de ligne (`'\n'`).
• `file=sys.stdout` : (Optionnel) L'objet fichier où les valeurs doivent être affichées. Par défaut, c'est la sortie standard (`sys.stdout`, généralement la console).
• `flush=False` : (Optionnel) Si `True`, la sortie est immédiatement "vidée" (flushed), ce qui peut être utile dans certains cas (par exemple, si vous voulez afficher du texte avant une opération longue). Par défaut, la sortie est généralement bufferisée (mise en mémoire tampon).

Exemples :

print("Bonjour", "tout", "le", "monde")  # Affiche : Bonjour tout le monde
print("Bonjour", "tout", "le", "monde", sep="-")  # Affiche : Bonjour-tout-le-monde
print("Bonjour", end=" ")  # Affiche : Bonjour (sans saut de ligne)
print("tout le monde")

x = 10
y = 20
print("x =", x, "et y =", y)  # Affiche : x = 10 et y = 20

Afficher des variables et des expressions

Vous pouvez utiliser `print()` pour afficher la valeur de variables, le résultat d'expressions, ou une combinaison des deux.

Exemples :

nom = "Alice"
age = 30
print("Nom :", nom)  # Affiche : Nom : Alice
print("Age :", age)  # Affiche : Age : 30
print(f"{nom} a {age} ans.")

print("Le double de", age, "est", age * 2)  # Affiche : Le double de 30 est 60

liste = [1, 2, 3]
print("Liste :", liste)  # Affiche : Liste : [1, 2, 3]

dictionnaire = {"a": 1, "b": 2}
print("Dictionnaire :", dictionnaire)  # Affiche : Dictionnaire : {'a': 1, 'b': 2}

Python convertit automatiquement les valeurs en chaînes de caractères avant de les afficher.

Formatage de chaînes avec f-strings (recommandé)

Les f-strings (formatted string literals, ou chaînes de caractères formatées littérales) sont un moyen puissant et concis d'intégrer des valeurs de variables et des expressions directement dans des chaînes de caractères.

Une f-string est une chaîne de caractères qui commence par `f` ou `F` (avant le guillemet ouvrant) et qui peut contenir des *expressions* entre accolades `{}`. Ces expressions sont évaluées et leur résultat est inséré dans la chaîne.

Syntaxe :

f"Texte {expression} texte {autre_expression} ..."

Exemples :

nom = "Alice"
age = 30

print(f"Bonjour, je m'appelle {nom} et j'ai {age} ans.")  # Affiche : Bonjour, je m'appelle Alice et j'ai 30 ans.

print(f"Le double de {age} est {age * 2}.")  # Affiche : Le double de 30 est 60.

print(f"Dans 5 ans, {nom} aura {age + 5} ans.") #Affiche : Dans 5 ans, Alice aura 35 ans.

Les f-strings sont généralement plus lisibles et plus efficaces que les autres méthodes de formatage de chaînes (comme l'opérateur `%` ou la méthode `format()`).

Vous pouvez utiliser des spécificateurs de format à l'intérieur des accolades pour contrôler la façon dont les valeurs sont formatées (nombre de décimales, alignement, etc.).

Exemple (formatage) :

nombre = 3.141592653589793

print(f"Nombre avec deux décimales : {nombre:.2f}")  # Affiche : Nombre avec deux décimales : 3.14

print(f"Nombre aligné à droite sur 10 caractères : {nombre:>10}")
# Affiche : Nombre aligné à droite sur 10 caractères :     3.1416

pourcentage = 0.75
print(f"Pourcentage : {pourcentage:.2%}") #Affiche Pourcentage : 75.00%

Autres méthodes de formatage (moins recommandées)

Avant l'introduction des f-strings (en Python 3.6), il existait d'autres méthodes pour formater des chaînes de caractères :

• L'opérateur `%` : C'est une méthode plus ancienne, similaire au formatage `printf` en C. Elle est moins lisible et moins flexible que les f-strings.
• La méthode `format()` : C'est une méthode plus récente que l'opérateur `%`, mais elle est toujours moins concise et moins lisible que les f-strings.

Bien que ces méthodes fonctionnent toujours, il est *fortement recommandé* d'utiliser les f-strings pour le nouveau code, car elles sont plus modernes, plus lisibles et plus performantes.

Exemple (opérateur `%`, *déconseillé*):

nom = "Alice"
age = 30
print("Bonjour, je m'appelle %s et j'ai %d ans." % (nom, age))

Exemple (méthode `format()`, *moins bien que les f-strings*) :

nom = "Alice"
age = 30
print("Bonjour, je m'appelle {} et j'ai {} ans.".format(nom, age))
print("Bonjour, je m'appelle {0} et j'ai {1} ans.".format(nom, age))
print("Bonjour, je m'appelle {nom_var} et j'ai {age_var} ans.".format(nom_var=nom, age_var=age))

Afficher dans un fichier : l'argument file

Par défaut, `print()` affiche les données sur la sortie standard (généralement la console). Vous pouvez spécifier un autre fichier en utilisant l'argument nommé `file`.

Exemple :

with open("mon_fichier.txt", "w", encoding="utf-8") as f:
    print("Ceci est écrit dans le fichier.", file=f)
    print("Ceci aussi.", file=f)

Dans cet exemple, le texte est écrit dans le fichier `mon_fichier.txt` au lieu d'être affiché à l'écran.

L'argument `file` doit être un objet fichier ouvert en mode écriture.

Vider le tampon de sortie : l'argument flush

Normalement, la sortie de `print()` est mise en mémoire tampon (bufferisée). Cela signifie que les données à afficher sont stockées temporairement en mémoire avant d'être réellement écrites sur la sortie (console, fichier, etc.).

Dans la plupart des cas, la bufferisation améliore les performances. Cependant, dans certaines situations, vous pouvez vouloir forcer l'écriture immédiate des données, sans attendre que le tampon soit plein. C'est là que l'argument `flush=True` est utile.

Exemple :

import time

print("Début...")
for i in range(5):
    print(i, end=' ', flush=True)  # Affiche i immédiatement
    time.sleep(1)  # Attend 1 seconde
print("\nFin")

Dans cet exemple, si vous omettez `flush=True`, les nombres de 0 à 4 pourraient ne pas être affichés immédiatement. Ils pourraient être affichés d'un seul coup à la fin, ou après un certain délai. Avec `flush=True`, chaque nombre est affiché immédiatement, avant la pause de 1 seconde.

L'argument `flush=True` est utile lorsque vous voulez vous assurer que les données sont affichées immédiatement, par exemple pour afficher une barre de progression, ou pour afficher des messages importants avant une opération longue ou risquée.