Les f-Strings en Python

Les f-strings (littéraux de chaînes formatées) ont été introduits dans Python 3.6 et constituent désormais la méthode recommandée pour intégrer des valeurs dans des chaînes. Ils sont plus rapides que le formatage % et str.format(), et bien plus lisibles, car le nom de la variable se trouve directement à l'intérieur de la chaîne là où elle apparaîtra.

Ce chapitre couvre :

• La syntaxe de base des f-strings et comment intégrer des variables
• L'évaluation d'expressions, d'appels de méthodes et d'appels de fonctions en ligne
• Les spécificateurs de format : alignement, largeur, précision et bases numériques
• Le formatage des dates et l'utilisation des spécificateurs de signe et de remplissage par zéro
• Le spécificateur de débogage = (Python 3.8+)
• Les f-strings multilignes et les modèles réutilisables dans les fonctions
• Les pièges courants et comment les éviter

Chapitres associés : Format Strings · Python String Formatting · Python Strings · Python Dates · Python Regex

Syntaxe de base

Un f-string est tout littéral de chaîne qui commence par la lettre f (ou F) immédiatement avant le guillemet ouvrant. Toute expression Python placée entre accolades {} est évaluée à l'exécution, et sa valeur est convertie en chaîne puis insérée dans le résultat.

name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")

My name is Alice and I am 30 years old.

Le préfixe f fonctionne avec les guillemets simples, les guillemets doubles et les guillemets triples :

language = "Python"
print(f'I love {language}!')          # single quotes
print(f"""I love {language}!""")      # triple quotes

I love Python!
I love Python!

Intégration d'expressions

Le marqueur {} accepte toute expression Python valide — pas seulement des noms de variables. Vous pouvez effectuer des opérations arithmétiques, des comparaisons, appeler des méthodes, appeler des fonctions et accéder aux clés de dictionnaire.

Arithmétique et comparaisons

x = 10
y = 3
print(f"{x} divided by {y} is {x / y:.2f}")
print(f"The square of {x} is {x ** 2}")
print(f"Is {x} greater than {y}? {x > y}")

10 divided by 3 is 3.33
The square of 10 is 100
Is 10 greater than 3? True

Appels de méthodes

name = "alice smith"
print(f"Hello, {name.title()}!")
print(f"Uppercase: {name.upper()}")

Hello, Alice Smith!
Uppercase: ALICE SMITH

Appels de fonctions et fonctions intégrées

items = ["apples", "bananas", "cherries"]
print(f"You have {len(items)} items in the list.")

You have 3 items in the list.

Accès aux dictionnaires

Utilisez des guillemets simples à l'intérieur des accolades pour accéder aux clés de dictionnaire (la chaîne extérieure est entre guillemets doubles, donc il n'y a pas de conflit) :

person = {"name": "Bob", "age": 25}
print(f"Name: {person['name']}, Age: {person['age']}")

Name: Bob, Age: 25

Expressions conditionnelles

score = 72
print(f"Score: {score} => {'Pass' if score >= 60 else 'Fail'}")

Score: 72 => Pass

Spécificateurs de format

Après l'expression, ajoutez un deux-points : suivi d'une spécification de format pour contrôler l'aspect de la valeur. La syntaxe complète du mini-langage est :

{expression:[fill][align][sign][width][grouping][.precision][type]}

Vous n'avez pas besoin d'utiliser chaque partie — combinez uniquement les éléments dont vous avez besoin.

Alignement et largeur

Utilisez < (gauche), > (droite) ou ^ (centré) avec un nombre pour définir la largeur du champ :

name = "Alice"
print(f"|{name:<10}|")   # left-align in a field of width 10
print(f"|{name:>10}|")   # right-align
print(f"|{name:^10}|")   # center

|Alice     |
|     Alice|
|  Alice   |

Spécifiez un caractère de remplissage avant le symbole d'alignement pour rembourrer avec autre chose que des espaces :

print(f"|{'hello':*^15}|")  # fill with * and center

|*****hello*****|

Précision décimale

pi = 3.14159265
print(f"Pi is approximately {pi:.2f}")   # 2 decimal places
print(f"Pi is approximately {pi:.4f}")   # 4 decimal places

Pi is approximately 3.14
Pi is approximately 3.1416

Formatage des nombres

price = 1234567.89
print(f"{price:,.2f}")   # comma as thousands separator
print(f"{price:e}")      # scientific notation

1,234,567.89
1.234568e+06

Affichez une valeur sous forme de pourcentage directement — Python la multiplie par 100 pour vous :

ratio = 0.853
print(f"{ratio:.1%}")

85.3%

Spécificateur de signe

Utilisez + pour toujours afficher le signe, ou un espace pour réserver une place pour les nombres positifs (afin que les colonnes s'alignent avec les nombres négatifs) :

x = 42
y = -7
print(f"{x:+d}")    # +42
print(f"{y:+d}")    # -7
print(f"{x: d}")    # space before positive
print(f"{y: d}")    # -7

+42
-7
 42
-7

Remplissage par zéro

Rembourrez un entier à une largeur fixe avec des zéros non significatifs en utilisant 0 avant le nombre de largeur :

print(f"{42:010d}")   # zero-pad to 10 digits

0000000042

Combinez signe et remplissage par zéro — le signe occupe la première position :

x = 42
print(f"{x:+010d}")   # +000000042

+000000042

Bases entières

x = 255
print(f"{x:d}")    # decimal   -> 255
print(f"{x:x}")    # hex lower -> ff
print(f"{x:X}")    # hex upper -> FF
print(f"{x:o}")    # octal     -> 377
print(f"{x:b}")    # binary    -> 11111111

255
ff
FF
377
11111111

Formatage des dates

Lorsque vous placez un objet datetime ou date dans un f-string, vous pouvez faire suivre le deux-points de codes de format strftime pour contrôler la sortie directement — aucun appel à .strftime() n'est nécessaire :

from datetime import date
today = date(2024, 6, 19)
print(f"Today is {today:%B %d, %Y}")
print(f"ISO format: {today:%Y-%m-%d}")

Today is June 19, 2024
ISO format: 2024-06-19

Consultez le chapitre Python Dates pour la liste complète des codes de format strftime.

Le spécificateur de débogage = (Python 3.8+)

Ajouter = après le nom de l'expression affiche à la fois le texte de l'expression et sa valeur. Cela vous évite de taper le nom de la variable deux fois et est très utile pour un débogage rapide :

val = 42
result = val * 2
print(f"{val=}, {result=}")

val=42, result=84

Les valeurs de type string reçoivent le traitement repr() pour que vous puissiez voir les guillemets :

name = "Alice"
print(f"{name=}")

name='Alice'

Vous pouvez combiner = avec un spécificateur de format — placez la spécification après = :

pi = 3.14159265
print(f"{pi=:.3f}")

pi=3.142

F-strings multilignes

Pour un texte plus long, vous pouvez répartir un f-string sur plusieurs lignes. Deux approches fonctionnent bien.

Concaténation implicite de chaînes (pas de barre oblique inverse nécessaire à l'intérieur des parenthèses) :

name = "Alice"
age = 30
city = "London"
profile = (
    f"Name : {name}\n"
    f"Age  : {age}\n"
    f"City : {city}"
)
print(profile)

Name : Alice
Age  : 30
City : London

F-string à guillemets triples — les sauts de ligne sont littéraux, donc aucun \n n'est nécessaire :

name = "Alice"
age = 30
report = f"""
Name : {name}
Age  : {age}
""".strip()
print(report)

Name : Alice
Age  : 30

Modèles réutilisables

Les f-strings sont évalués immédiatement, vous ne pouvez donc pas les stocker comme variable de modèle et les remplir ultérieurement. Utilisez plutôt une fonction :

def greet(name, role):
    return f"Hello, {name}! Your role is {role}."

print(greet("Alice", "admin"))
print(greet("Bob", "editor"))

Hello, Alice! Your role is admin.
Hello, Bob! Your role is editor.

Si vous avez réellement besoin d'un modèle différé, utilisez str.format() — voir Format Strings.

Accolades littérales dans la sortie

Pour inclure un caractère { ou } littéral dans la sortie, doublez-le :

value = 42
print(f"The answer is {{value}} = {value}")

The answer is {value} = 42

Pièges courants

Barres obliques inverses à l'intérieur de l'expression (Python < 3.12)

Avant Python 3.12, une barre oblique inverse n'est pas autorisée à l'intérieur de l'expression {} d'un f-string. La solution de contournement consiste à calculer la valeur dans une variable d'abord :

items = ["a", "b", "c"]

# This raises SyntaxError on Python < 3.12:
# print(f"{'\n'.join(items)}")

# Workaround — pre-compute:
joined = "\n".join(items)
print(f"Items:\n{joined}")

Items:
a
b
c

Python 3.12 a levé cette restriction, donc les barres obliques inverses sont désormais valides à l'intérieur des expressions de f-strings.

Utiliser le même type de guillemets à l'intérieur de l'expression

Si le f-string externe utilise des guillemets doubles, utilisez des guillemets simples pour les clés de dictionnaire à l'intérieur de {}. Si vous avez besoin du même type de guillemets, changez les guillemets externes ou utilisez une variable :

person = {"name": "Bob"}

# Works — single quotes inside double-quoted f-string
print(f"Name: {person['name']}")

# Also works — pre-assign the key
key = "name"
print(f"Name: {person[key]}")

Name: Bob
Name: Bob

Les f-strings ne sont pas paresseux

Un f-string évalue chaque expression au moment où la ligne s'exécute. Si vous assignez un f-string à une variable, il capture les valeurs actuelles — modifier les variables ultérieurement n'a aucun effet sur la chaîne déjà évaluée :

x = 5
msg = f"x is {x}"
x = 99
print(msg)   # still shows 5, not 99

x is 5

Utilisez une fonction (comme indiqué ci-dessus) lorsque vous avez besoin d'un modèle qui s'évalue ultérieurement.

Référence rapide

Pratique