Les f-strings, introduites avec Python 3.6, représentent une révolution dans la manière de formater les chaînes de caractères. Elles offrent une syntaxe claire, concise et performante qui a rapidement conquis la communauté Python. Si vous souhaitez maîtriser cette fonctionnalité essentielle et bien d'autres concepts Python, notre formation complète sur Python vous accompagnera dans votre apprentissage.
Définition des f-strings
Une f-string (formatted string literal ou chaîne de caractères formatée) est un type de chaîne de caractères en Python qui permet d'incorporer directement des expressions Python à l'intérieur de la chaîne. Le préfixe f ou F placé avant les guillemets indique à l'interpréteur Python qu'il s'agit d'une f-string.
La syntaxe de base est simple : vous placez vos expressions entre accolades {} directement dans la chaîne de caractères. Python évalue ces expressions au moment de l'exécution et insère leur résultat dans la chaîne finale.
nom = "Alice"
age = 28
message = f"Bonjour, je m'appelle {nom} et j'ai {age} ans."
print(message)
# Résultat : Bonjour, je m'appelle Alice et j'ai 28 ans.Avant l'apparition des f-strings, les développeurs Python utilisaient principalement deux méthodes pour formater les chaînes :
- L'opérateur
%(style printf) - La méthode
.format()
Les f-strings surpassent ces deux approches en termes de lisibilité et de performance.
Syntaxe et utilisation de base
Insertion de variables
L'utilisation la plus courante des f-strings consiste à insérer des variables dans une chaîne de caractères. Vous pouvez utiliser n'importe quelle variable définie dans la portée courante.
prenom = "Marie"
ville = "Paris"
profession = "développeuse"
presentation = f"{prenom} habite à {ville} et travaille comme {profession}."
print(presentation)
# Résultat : Marie habite à Paris et travaille comme développeuse.
Évaluation d'expressions
Les f-strings ne se limitent pas aux simples variables. Vous pouvez y inclure n'importe quelle expression Python valide, y compris des calculs mathématiques, des appels de fonctions ou des méthodes.
# Calculs mathématiques
largeur = 5
hauteur = 3
print(f"L'aire du rectangle est de {largeur * hauteur} m².")
# Résultat : L'aire du rectangle est de 15 m².
# Appels de méthodes
nom = "python"
print(f"Langage : {nom.upper()}")
# Résultat : Langage : PYTHON
# Appels de fonctions
import math
rayon = 4
print(f"Circonférence : {2 * math.pi * rayon:.2f}")
# Résultat : Circonférence : 25.13
Utilisation avec des structures de données
Les f-strings fonctionnent parfaitement avec les structures de données Python comme les list, les dict et les tuple.
# Avec une liste
fruits = ["pomme", "banane", "orange"]
print(f"Mon fruit préféré est la {fruits[0]}.")
# Résultat : Mon fruit préféré est la pomme.
# Avec un dictionnaire
personne = {"nom": "Dupont", "age": 35}
print(f"{personne['nom']} a {personne['age']} ans.")
# Résultat : Dupont a 35 ans.
# Avec un tuple
coordonnees = (48.8566, 2.3522)
print(f"Paris se trouve aux coordonnées {coordonnees[0]}, {coordonnees[1]}.")
# Résultat : Paris se trouve aux coordonnées 48.8566, 2.3522.
Formatage avancé des f-strings
Spécificateurs de format
Les f-strings supportent les spécificateurs de format après le caractère : dans l'expression. Ces spécificateurs vous permettent de contrôler précisément l'apparence de vos données.
# Formatage des nombres décimaux
pi = 3.141592653589793
print(f"Pi arrondi à 2 décimales : {pi:.2f}")
# Résultat : Pi arrondi à 2 décimales : 3.14
print(f"Pi arrondi à 4 décimales : {pi:.4f}")
# Résultat : Pi arrondi à 4 décimales : 3.1416
# Notation scientifique
grand_nombre = 1234567890
print(f"Notation scientifique : {grand_nombre:.2e}")
# Résultat : Notation scientifique : 1.23e+09
Alignement et remplissage
Vous pouvez aligner le texte à gauche, à droite ou au centre, et spécifier un caractère de remplissage.
texte = "Python"
# Alignement à gauche (par défaut pour les chaînes)
print(f"|{texte:<15}|")
# Résultat : |Python |
# Alignement à droite
print(f"|{texte:>15}|")
# Résultat : | Python|
# Alignement au centre
print(f"|{texte:^15}|")
# Résultat : | Python |
# Avec un caractère de remplissage personnalisé
print(f"|{texte:-^15}|")
# Résultat : |----Python-----|
Formatage des nombres
Les f-strings offrent de nombreuses options pour formater les nombres de manière lisible.
# Séparateur de milliers
montant = 1234567
print(f"Montant : {montant:,} €")
# Résultat : Montant : 1,234,567 €
# Avec underscore comme séparateur (Python 3.6+)
print(f"Montant : {montant:_} €")
# Résultat : Montant : 1_234_567 €
# Pourcentage
ratio = 0.756
print(f"Taux de réussite : {ratio:.1%}")
# Résultat : Taux de réussite : 75.6%
# Nombres avec signe
valeur_positive = 42
valeur_negative = -17
print(f"Positif : {valeur_positive:+d}, Négatif : {valeur_negative:+d}")
# Résultat : Positif : +42, Négatif : -17
Formatage des dates
Les f-strings s'intègrent parfaitement avec le module datetime pour formater les dates.
from datetime import datetime
maintenant = datetime.now()
print(f"Date : {maintenant:%d/%m/%Y}")
# Résultat : Date : 15/01/2025 (exemple)
print(f"Heure : {maintenant:%H:%M:%S}")
# Résultat : Heure : 14:30:45 (exemple)
print(f"Date complète : {maintenant:%A %d %B %Y}")
# Résultat : Date complète : Wednesday 15 January 2025 (exemple)
Fonctionnalités avancées
Le flag = pour le débogage (Python 3.8+)
Depuis Python 3.8, vous pouvez utiliser le signe = après une expression pour afficher à la fois l'expression et sa valeur. Cette fonctionnalité est particulièrement utile pour le débogage.
x = 10
y = 20
print(f"{x=}")
# Résultat : x=10
print(f"{x=}, {y=}")
# Résultat : x=10, y=20
print(f"{x + y = }")
# Résultat : x + y = 30
# Combiné avec le formatage
pi = 3.14159
print(f"{pi=:.2f}")
# Résultat : pi=3.14
F-strings multi-lignes
Vous pouvez créer des f-strings sur plusieurs lignes en utilisant les triples guillemets.
nom = "Jean"
age = 30
ville = "Lyon"
fiche = f"""
=============================
FICHE PERSONNELLE
=============================
Nom : {nom}
Âge : {age} ans
Ville : {ville}
=============================
"""
print(fiche)
Échapper les accolades
Si vous avez besoin d'afficher des accolades littérales dans une f-string, vous devez les doubler.
variable = "valeur"
# Pour afficher des accolades littérales
print(f"Voici des accolades : {{}}")
# Résultat : Voici des accolades : {}
print(f"Code JSON : {{\"clé\": \"{variable}\"}}")
# Résultat : Code JSON : {"clé": "valeur"}
Utilisation avec les objets et les classes
Les f-strings fonctionnent avec les objets personnalisés en utilisant les méthodes __str__ et __repr__. Vous pouvez utiliser les spécificateurs !s et !r pour forcer l'utilisation de l'une ou l'autre méthode.
class Personne:
def __init__(self, nom, age):
self.nom = nom
self.age = age
def __str__(self):
return f"{self.nom} ({self.age} ans)"
def __repr__(self):
return f"Personne(nom='{self.nom}', age={self.age})"
p = Personne("Alice", 25)
# Utilisation de __str__ (par défaut)
print(f"Personne : {p}")
# Résultat : Personne : Alice (25 ans)
# Forcer __str__
print(f"Personne : {p!s}")
# Résultat : Personne : Alice (25 ans)
# Forcer __repr__
print(f"Debug : {p!r}")
# Résultat : Debug : Personne(nom='Alice', age=25)
Comparaison avec les autres méthodes de formatage
Voici un tableau comparatif des différentes méthodes de formatage de chaînes en Python :
| Méthode | Syntaxe | Avantages | Inconvénients |
|---|---|---|---|
| f-string | f"Bonjour {nom}" | Lisible, rapide, flexible | Python 3.6+ uniquement |
| .format() | "Bonjour {}".format(nom) | Compatible Python 2.7+ | Plus verbeux |
| % operator | "Bonjour %s" % nom | Style classique | Moins flexible, obsolète |
| Template | Template("Bonjour $nom") | Sécurisé pour entrées utilisateur | Moins de fonctionnalités |
En termes de performance, les f-strings sont généralement plus rapides que les autres méthodes car l'évaluation est effectuée au moment de la compilation plutôt qu'à l'exécution.
import timeit
nom = "Python"
version = 3.12
# Test de performance
temps_fstring = timeit.timeit('f"{nom} {version}"', globals=globals(), number=1000000)
temps_format = timeit.timeit('"{} {}".format(nom, version)', globals=globals(), number=1000000)
temps_percent = timeit.timeit('"%s %s" % (nom, version)', globals=globals(), number=1000000)
print(f"f-string : {temps_fstring:.3f}s")
print(f".format() : {temps_format:.3f}s")
print(f"% operator : {temps_percent:.3f}s")
Bonnes pratiques
Les f-strings sont recommandées par la PEP 498 comme méthode de formatage préférée pour Python 3.6 et versions ultérieures. Elles améliorent la lisibilité du code et réduisent les erreurs.
1. Privilégiez la lisibilité
Évitez les expressions trop complexes dans vos f-strings. Si l'expression devient difficile à lire, assignez-la d'abord à une variable.
# À éviter
print(f"Résultat : {[x**2 for x in range(10) if x % 2 == 0]}")
# Préférez
carres_pairs = [x**2 for x in range(10) if x % 2 == 0]
print(f"Résultat : {carres_pairs}")
2. Utilisez les f-strings pour le débogage
Le flag = est votre allié pour comprendre rapidement l'état de vos variables. Pensez également à utiliser la fonction print de manière stratégique pour afficher vos f-strings de débogage.
# Débogage rapide
def calculer_prix(quantite, prix_unitaire, remise):
print(f"{quantite=}, {prix_unitaire=}, {remise=}") # Debug
total = quantite * prix_unitaire * (1 - remise)
print(f"{total=:.2f}") # Debug
return total
3. Documentez vos fonctions avec des docstrings
Combinez les f-strings avec les docstring pour créer une documentation claire et des messages d'erreur explicites.
def diviser(a, b):
"""Divise a par b et retourne le résultat."""
if b == 0:
raise ValueError(f"Division impossible : {a} / {b} (division par zéro)")
return a / b
4. Attention à la sécurité
N'utilisez jamais les f-strings avec des entrées utilisateur non validées, car elles peuvent exécuter du code arbitraire.
Ne construisez jamais de f-strings à partir de chaînes provenant d'utilisateurs non fiables. Pour ces cas, utilisez plutôt la classe string.Template qui est plus sécurisée.
from string import Template
# Pour des entrées utilisateur, préférez Template
entree_utilisateur = "nom"
template = Template("Bonjour $variable")
resultat = template.safe_substitute(variable=entree_utilisateur)
5. Utilisez des f-strings pour la construction de requêtes SQL (avec précaution)
Ne construisez jamais de requêtes SQL directement avec des f-strings. Utilisez toujours les mécanismes de paramétrage de votre bibliothèque de base de données.
# DANGER - NE JAMAIS FAIRE CELA
nom_utilisateur = "Alice"
requete = f"SELECT * FROM users WHERE nom = '{nom_utilisateur}'" # Vulnérable !
# CORRECT - Utilisez les paramètres
cursor.execute("SELECT * FROM users WHERE nom = ?", (nom_utilisateur,))
Cas d'utilisation courants
Génération de rapports
def generer_rapport(ventes):
total = sum(ventes)
moyenne = total / len(ventes) if ventes else 0
rapport = f"""
╔══════════════════════════════════╗
║ RAPPORT DES VENTES ║
╠══════════════════════════════════╣
║ Nombre de ventes : {len(ventes):>13} ║
║ Total : {total:>13,.2f} € ║
║ Moyenne : {moyenne:>13,.2f} € ║
╚══════════════════════════════════╝
"""
return rapport
ventes = [150.50, 200.00, 89.99, 450.00, 75.25]
print(generer_rapport(ventes))
Logging et messages d'erreur
import logging
logging.basicConfig(level=logging.INFO)
def traiter_commande(commande_id, client, montant):
logging.info(f"Traitement commande #{commande_id} pour {client} - Montant: {montant:.2f}€")
try:
# Traitement...
logging.info(f"Commande #{commande_id} traitée avec succès")
except Exception as e:
logging.error(f"Erreur commande #{commande_id}: {e}")
Construction d'URLs et de chemins
from pathlib import Path
base_url = "https://api.exemple.com"
version = "v2"
ressource = "utilisateurs"
id_utilisateur = 12345
url = f"{base_url}/{version}/{ressource}/{id_utilisateur}"
print(url)
# Résultat : https://api.exemple.com/v2/utilisateurs/12345
# Chemins de fichiers
dossier_base = Path("/home/user")
nom_fichier = "rapport_2025"
extension = "pdf"
chemin = f"{dossier_base}/{nom_fichier}.{extension}"
print(chemin)
# Résultat : /home/user/rapport_2025.pdf
Questions fréquentes
Quelle est la différence entre f-string et la méthode .format() ?
Les f-strings sont plus lisibles et plus rapides que la méthode .format(). Avec les f-strings, vous écrivez directement les variables dans la chaîne (f"Bonjour {nom}"), tandis qu'avec .format(), vous devez les passer en argument ("Bonjour {}".format(nom)). Les f-strings sont également évaluées au moment de la compilation, ce qui les rend plus performantes. Cependant, .format() reste utile pour les templates réutilisables ou pour la compatibilité avec Python 2.7.
Peut-on utiliser des f-strings avec des fonctions lambda ?
Oui, vous pouvez appeler des fonctions lambda dans des f-strings, mais vous devez les entourer de parenthèses pour éviter les erreurs de syntaxe avec le caractère :.
# Correct
carre = lambda x: x ** 2
print(f"Le carré de 5 est {carre(5)}")
# Résultat : Le carré de 5 est 25
# Avec une lambda inline (parenthèses obligatoires)
print(f"Résultat : {(lambda x: x * 2)(10)}")
# Résultat : Résultat : 20
Comment afficher des accolades dans une f-string ?
Pour afficher des accolades littérales { et } dans une f-string, vous devez les doubler. Utilisez {{ pour afficher une accolade ouvrante et }} pour une accolade fermante. Par exemple : f"Voici des accolades : {{valeur}}" affichera Voici des accolades : {valeur} sans interpréter valeur comme une expression.
Comment apprendre à maîtriser les f-strings et Python en général ?
Pour maîtriser les f-strings et l'ensemble du langage Python, nous vous recommandons de suivre notre formation complète Python sur Believemy. Cette formation vous guidera pas à pas à travers tous les concepts essentiels du langage, des bases jusqu'aux fonctionnalités avancées comme les f-strings, les class, les décorateurs et bien plus encore. La pratique régulière avec des exercices concrets est la clé pour devenir un développeur Python efficace.