image/svg+xml JaaJBlog

Python : Comment utiliser les f-strings

 
  • Pierre Chopinet
  • 09 Feb, 2026

Les f-strings sont la façon la plus moderne et lisible de formater des chaînes en Python (depuis Python 3.6). Plus concises que format() et plus puissantes que %, elles permettent d’intégrer des expressions Python directement dans les chaînes avec une syntaxe simple et élégante.

Dans cet article :

  • Syntaxe de base des f-strings
  • Expressions et appels de fonctions
  • Formatage des nombres (précision, padding, séparateurs)
  • Formatage des dates
  • Alignement et largeur
  • Échappement des accolades
  • Comparaison avec format() et %
  • Astuces et bonnes pratiques

Pré-requis : Python 3.6 ou plus récent.

Syntaxe de base

Intégrer des variables

nom = "Alice"
age = 30

# Ancienne méthode avec %
message = "Bonjour %s, vous avez %d ans." % (nom, age)

# Méthode .format()
message = "Bonjour {}, vous avez {} ans.".format(nom, age)

# f-string (moderne et lisible)
message = f"Bonjour {nom}, vous avez {age} ans."
print(message)  # Bonjour Alice, vous avez 30 ans.

Avantages :

  • Plus court et plus lisible
  • Les variables sont insérées directement
  • Pas besoin de répéter les variables à la fin

Expressions dans les f-strings

Vous pouvez évaluer des expressions Python directement dans les accolades :

x = 10
y = 5

print(f"La somme de {x} et {y} est {x + y}")
# La somme de 10 et 5 est 15

print(f"Le produit est {x * y}")
# Le produit est 50

print(f"{x} est {'pair' if x % 2 == 0 else 'impair'}")
# 10 est pair

Appeler des fonctions

def prix_ttc(prix_ht, tva=0.20):
    return prix_ht * (1 + tva)

prix = 100
print(f"Prix TTC : {prix_ttc(prix):.2f}€")
# Prix TTC : 120.00€

Accéder aux attributs et méthodes

texte = "python"
print(f"Majuscule : {texte.upper()}")
# Majuscule : PYTHON

print(f"Longueur : {len(texte)} caractères")
# Longueur : 6 caractères

Formatage des nombres

Les f-strings offrent une syntaxe puissante pour formater les nombres : précision décimale, séparateurs de milliers, pourcentages, notation scientifique et bases numériques.

Arrondir à n décimales

pi = 3.141592653589793

print(f"{pi:.2f}")  # 3.14 (2 décimales)
print(f"{pi:.4f}")  # 3.1416 (4 décimales)
print(f"{pi:.0f}")  # 3 (entier)

Séparateurs de milliers

nombre = 1234567.89

print(f"{nombre:,.2f}")     # 1,234,567.89 (virgule US)
print(f"{nombre:_.2f}")     # 1_234_567.89 (underscore)

Seuls deux séparateurs de milliers existent : , et _. Attention au faux ami {nombre: .2f} : l’espace n’est pas un séparateur de milliers mais une option de signe (elle réserve un espace devant les nombres positifs).

Pour le format français (espace comme séparateur), on passe par un replace :

print(f"{nombre:,.2f}".replace(",", " "))  # 1 234 567.89

Autre possibilité, le format n qui utilise la locale du système :

import locale
locale.setlocale(locale.LC_ALL, 'fr_FR.UTF-8')

nombre_entier = 1234567
print(f"{nombre_entier:n}")  # 1 234 567

Le format n n’insère les séparateurs de la locale que pour les entiers : sur un float, il se comporte comme g (6 chiffres significatifs) et afficherait 1,23457e+06.

Note : selon la version de Windows, la locale fr_FR.UTF-8 peut ne pas être disponible ; utilisez alors 'French_France.1252'.

Pourcentages

taux = 0.1547

print(f"Taux : {taux:.2%}")  # Taux : 15.47%
print(f"Taux : {taux:.1%}")  # Taux : 15.5%

Notation scientifique

grand_nombre = 1234567890

print(f"{grand_nombre:e}")   # 1.234568e+09
print(f"{grand_nombre:.2e}") # 1.23e+09

Nombres binaires, hexadécimaux, octaux

nombre = 42

print(f"Binaire : {nombre:b}")    # 101010
print(f"Octal : {nombre:o}")      # 52
print(f"Hexadécimal : {nombre:x}")  # 2a
print(f"Hexadécimal (MAJ) : {nombre:X}")  # 2A
print(f"Hex avec préfixe : {nombre:#x}")   # 0x2a

Largeur, alignement et padding

Pour créer des tableaux ou aligner du texte, les f-strings permettent de contrôler la largeur, l’alignement et le caractère de remplissage.

Largeur minimale

nom = "Alice"
age = 30

print(f"{nom:10} | {age:3}")
# Alice      |  30

Alignement

texte = "Python"

print(f"{texte:<10}")  # Python     (gauche)
print(f"{texte:>10}")  #     Python (droite)
print(f"{texte:^10}")  #   Python   (centré)

Padding avec un caractère personnalisé

nombre = 42

print(f"{nombre:0>5}")  # 00042 (zéros à gauche)
print(f"{nombre:*<5}")  # 42*** (étoiles à droite)
print(f"{nombre:-^7}")  # --42--- (tirets centré)

Combiner largeur et précision

prix = 12.5

print(f"{prix:10.2f}")   #      12.50 (10 caractères, 2 décimales)
print(f"{prix:0>10.2f}") # 0000012.50 (padding zéros)

Formatage des dates

Les objets datetime peuvent être formatés directement dans les f-strings en utilisant les codes de format strftime.

from datetime import datetime

maintenant = datetime.now()

print(f"Date : {maintenant:%Y-%m-%d}")
# Date : 2026-02-09

print(f"Heure : {maintenant:%H:%M:%S}")
# Heure : 14:30:45

print(f"Date complète : {maintenant:%A %d %B %Y}")
# Date complète : Monday 09 February 2026

print(f"Format court : {maintenant:%d/%m/%Y %H:%M}")
# Format court : 09/02/2026 14:30

Format français :

import locale
locale.setlocale(locale.LC_TIME, 'fr_FR.UTF-8')

print(f"{maintenant:%A %d %B %Y}")
# lundi 09 février 2026

Même remarque que plus haut : sous Windows, remplacez au besoin 'fr_FR.UTF-8' par 'French_France.1252'.

Échappement des accolades

Pour afficher des accolades littérales dans une f-string, doublez-les :

x = 10

print(f"La variable x vaut {x}")
# La variable x vaut 10

print(f"Pour afficher {{x}}, écrivez {{{{x}}}}")
# Pour afficher {x}, écrivez {{x}}

Règle :

  • {variable} -> évalue la variable
  • {{ -> affiche {
  • }} -> affiche }

F-strings multiligne

Les f-strings fonctionnent avec les chaînes multiligne (triple guillemets), pratique pour générer des messages longs ou des templates.

nom = "Alice"
age = 30
ville = "Paris"

message = f"""
Bonjour {nom},
Vous avez {age} ans et vous habitez à {ville}.
Bienvenue sur notre plateforme !
"""

print(message)

Debugging avec f-strings (Python 3.8+)

La syntaxe {variable=} affiche le nom de la variable et sa valeur :

x = 10
y = 20

print(f"{x=}, {y=}, {x + y=}")
# x=10, y=20, x + y=30

Très pratique pour le debugging :

def calculer_total(prix, quantite):
    total = prix * quantite
    print(f"{prix=}, {quantite=}, {total=}")
    return total

calculer_total(12.5, 3)
# prix=12.5, quantite=3, total=37.5

F-strings imbriquées

Pour des cas avancés, vous pouvez imbriquer des f-strings pour construire des formats dynamiques :

nombre = 1234.5678
precision = 2

print(f"{nombre:.{precision}f}")
# 1234.57

Exemple avec alignement dynamique :

texte = "Python"
largeur = 15
alignement = "^"  # centré

print(f"{texte:{alignement}{largeur}}")
#     Python

Comparaison avec les autres méthodes

Avant Python 3.6, deux méthodes principales existaient pour formater des chaînes. Voici pourquoi les f-strings sont supérieures.

Ancien style avec %

nom = "Alice"
age = 30

message = "Bonjour %s, vous avez %d ans." % (nom, age)

Inconvénients :

  • Syntaxe peu lisible
  • Types à spécifier (%s, %d, %f)
  • Erreurs si le nombre d’arguments ne correspond pas

Méthode .format()

message = "Bonjour {}, vous avez {} ans.".format(nom, age)

# Avec indices
message = "Bonjour {0}, vous avez {1} ans. {0} est génial !".format(nom, age)

# Avec noms
message = "Bonjour {nom}, vous avez {age} ans.".format(nom=nom, age=age)

Inconvénients :

  • Verbeux (répétition des variables)
  • Moins lisible que les f-strings

f-strings (recommandé)

message = f"Bonjour {nom}, vous avez {age} ans."

Avantages :

  • Syntaxe concise et lisible
  • Évaluation d’expressions directement
  • Plus rapide (évaluation au moment de l’exécution)
  • Debugging intégré avec {variable=}

Cas d’usage pratiques

Voici quelques exemples concrets d’utilisation des f-strings dans des situations réelles.

Générer un tableau

produits = [
    ("Livre", 12.50, 2),
    ("Stylo", 1.20, 5),
    ("Cahier", 3.00, 4),
]

print(f"{'Produit':<15} {'Prix':>8} {'Qté':>5} {'Total':>8}")
print("-" * 40)
for nom, prix, qte in produits:
    total = prix * qte
    print(f"{nom:<15} {prix:>8.2f} {qte:>5} {total:>8.2f}")

Résultat :

Produit           Prix   Qté    Total
----------------------------------------
Livre              12.50     2    25.00
Stylo               1.20     5     6.00
Cahier              3.00     4    12.00

Générer du SQL dynamiquement

table = "utilisateurs"
colonnes = ["nom", "email", "age"]
valeurs = ["Alice", "alice@example.com", 30]

query = f"""
INSERT INTO {table} ({', '.join(colonnes)})
VALUES ({', '.join(f"'{v}'" for v in valeurs)})
"""

print(query)
# INSERT INTO utilisateurs (nom, email, age)
# VALUES ('Alice', 'alice@example.com', '30')

Attention : pour du vrai code SQL, utilisez des requêtes paramétrées pour éviter les injections SQL.

Logs avec horodatage

from datetime import datetime

def log(message):
    timestamp = datetime.now()
    print(f"[{timestamp:%Y-%m-%d %H:%M:%S}] {message}")

log("Application démarrée")
log("Connexion à la base de données réussie")
# [2026-02-09 14:30:45] Application démarrée
# [2026-02-09 14:30:46] Connexion à la base de données réussie

Pièges à éviter

Certaines erreurs courantes peuvent survenir avec les f-strings. Voici comment les éviter.

Variables non définies

# Erreur : nom n'est pas défini
print(f"Bonjour {nom}")
# NameError: name 'nom' is not defined

F-strings et backslashes

Avant Python 3.12, les backslashes n’étaient pas autorisés dans la partie expression des f-strings :

items = ["pomme", "poire", "cerise"]

# Erreur avant Python 3.12
print(f"Liste : {'\n'.join(items)}")
# SyntaxError: f-string expression part cannot include a backslash

# Solution compatible avec toutes les versions : passer par une variable
saut = "\n"
print(f"Liste : {saut.join(items)}")

Depuis Python 3.12 (PEP 701), cette limite a disparu et le premier exemple fonctionne sans erreur.

Guillemets imbriqués

# Erreur de syntaxe avant Python 3.12
print(f"Message : {"Hello"}")

# Solution : alterner les guillemets
print(f"Message : {'Hello'}")
print(f'Message : {"Hello"}')

Là aussi, la PEP 701 a levé la restriction : depuis Python 3.12, on peut réutiliser le même type de guillemets à l’intérieur de l’expression.

Bonnes pratiques

À faire

  • Utiliser les f-strings par défaut (Python 3.6+)
  • Formater les nombres avec précision : {prix:.2f}
  • Utiliser {variable=} pour le debugging
  • Aligner les tableaux avec <, >, ^
  • Extraire les expressions complexes dans des variables
# Difficile à lire
print(f"Total : {sum([p['prix'] * p['qte'] for p in produits]):.2f}€")

# Plus clair
total = sum(p['prix'] * p['qte'] for p in produits)
print(f"Total : {total:.2f}€")

À éviter

  • Utiliser % ou .format() sans raison (hors compatibilité Python < 3.6)
  • Expressions trop complexes dans les f-strings
  • F-strings dans des boucles intensives si la performance est critique (envisager join)

Conclusion

Les f-strings sont la méthode moderne, performante et lisible pour formater des chaînes en Python. Elles remplacent avantageusement % et .format() dans la quasi-totalité des cas d’usage.

Points clés à retenir :

  • Syntaxe : f"Texte {variable}"
  • Évaluation d’expressions : f"{x + y}"
  • Formatage de nombres : {prix:.2f}, {nombre:,}
  • Alignement : {texte:<10}, {texte:>10}, {texte:^10}
  • Debugging : {variable=} (Python 3.8+)

Pour aller plus loin

Voir aussi

Recherche