Python F-Strings : Le Guide Complet du Formatage de Chaînes

Q: Qu'est-ce que le spécificateur = des f-strings et comment aide-t-il au débogage ?

Le spécificateur = a été ajouté dans Python 3.8 et affiche à la fois le texte de l'expression et sa valeur. Écrire f"{variable=}" affiche variable=valeur. Cela élimine le besoin de taper le nom de variable deux fois lors du débogage. Cela fonctionne avec n'importe quelle expression et peut être combiné avec des spécifications de format comme f"{price=:.2f}".

Q: Puis-je utiliser les f-strings avec des chaînes multilignes ?

Oui. Utilisez des guillemets triples (f\"\"\"...\"\"\" ou f'''...''') pour les f-strings multilignes. Chaque ligne peut contenir des placeholders {expression}. Alternativement, concaténez plusieurs f-strings en utilisant une concaténation de chaînes implicite en les plaçant côte à côte dans des parenthèses.

Q: Comment inclure des accolades littérales dans une f-string ?

Doublez les accolades. Utilisez {{ pour une accolade littérale { et }} pour une accolade littérale }. Par exemple, f\"{{value}}\" affiche {value} comme texte brut. Pour envelopper une valeur interpolée dans des accolades, utilisez f\"{{{variable}}}\" -- les accolades doublées extérieures produisent des accolades littérales tandis que les accolades simples intérieures déclenchent l'interpolation.

Name: Soren Atelier

Updated on 13/02/2026

Le formatage de chaînes est l'une des opérations les plus courantes en Python, et pourtant cela a été source de frustration pendant des années. L'opérateur % utilise des codes de format cryptiques empruntés au C. La méthode .format() disperse les valeurs loin de leur emplacement dans le modèle. La concaténation de chaînes avec + vous force à convertir manuellement les types et produit un code confus et difficile à lire. Chaque approche semble ajouter de la friction à ce qui devrait être une tâche simple : insérer une valeur dans une chaîne.

Le problème s'aggrave dans les projets réels. Vous devez formater des devises avec deux décimales, aligner des colonnes dans un rapport, remplir des nombres avec des zéros non significatifs, afficher des pourcentages et formater des horodatages -- tout en gardant le code lisible. Avec les anciennes méthodes de formatage, vous vous retrouvez à maintenir deux structures parallèles : la chaîne modèle et la liste d'arguments. Une simple erreur de réorganisation casse tout silencieusement, produisant une sortie incorrecte au lieu d'une erreur.

Python 3.6 a introduit les f-strings (littéraux de chaînes formatées), et elles ont changé le formatage de chaînes de manière permanente. En préfixant une chaîne avec f et en intégrant des expressions directement à l'intérieur des {accolades}, les f-strings gardent les valeurs à côté de leur emplacement. Elles sont plus rapides que toutes les autres méthodes de formatage. Elles supportent la gamme complète des spécifications de formatage. Et dans Python 3.8, elles ont gagné une fonctionnalité de débogage intégrée avec le spécificateur =. Ce guide couvre toutes les capacités des f-strings avec des exemples pratiques et exécutables.

Que Sont les F-Strings ?

Les f-strings, formellement appelées "littéraux de chaînes formatées", ont été introduites dans la PEP 498 (opens in a new tab) et livrées avec Python 3.6. Le concept est simple : préfixez n'importe quelle chaîne avec f (ou F), et Python évalue toute expression à l'intérieur des accolades {} au moment de l'exécution, convertissant le résultat en chaîne et l'insérant dans la sortie.

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

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

single = f'Hello, {name}'
double = f"Hello, {name}"
triple_double = f"""Hello, {name}"""
triple_single = f'''Hello, {name}'''

En interne, Python compile les f-strings en une série de concaténations de chaînes et d'opérations format() au moment de l'analyse. C'est pourquoi les f-strings sont plus rapides que d'appeler vous-même .format() -- l'interpréteur optimise l'opération directement.

Syntaxe de Base des F-Strings

La syntaxe de base est simple : écrivez f"texte {expression} plus de texte". Python évalue l'expression, appelle str() sur le résultat et l'insère dans la chaîne.

# Variables
city = "Tokyo"
population = 13960000
 
print(f"{city} has a population of {population}.")
# Output: Tokyo has a population of 13960000.
 
# Vous pouvez utiliser f ou F
print(F"Welcome to {city}!")
# Output: Welcome to Tokyo!

Vous pouvez placer n'importe quel nombre d'expressions à l'intérieur d'une seule f-string :

first = "Grace"
last = "Hopper"
title = "Rear Admiral"
year = 1906
 
bio = f"{title} {first} {last}, born {year}, lived to {1992 - year} years."
print(bio)
# Output: Rear Admiral Grace Hopper, born 1906, lived to 86 years.

Expressions à l'Intérieur des F-Strings

Les f-strings n'insèrent pas seulement des variables. Elles évaluent toute expression Python valide entre les accolades. Cela inclut l'arithmétique, les appels de méthodes, les appels de fonctions, les expressions ternaires, l'indexation de listes, l'accès aux dictionnaires, et plus encore.

Arithmétique et Mathématiques

x = 15
y = 4
 
print(f"{x} + {y} = {x + y}")
print(f"{x} / {y} = {x / y:.2f}")
print(f"{x} ** {y} = {x ** y}")
print(f"{x} % {y} = {x % y}")
# Output:
# 15 + 4 = 19
# 15 / 4 = 3.75
# 15 ** 4 = 50625
# 15 % 4 = 3

Appels de Méthodes

text = "  hello, python world  "
 
print(f"Stripped: '{text.strip()}'")
print(f"Title case: '{text.strip().title()}'")
print(f"Upper: '{text.strip().upper()}'")
print(f"Replace: '{text.strip().replace('python', 'f-string')}'")
# Output:
# Stripped: 'hello, python world'
# Title case: 'Hello, Python World'
# Upper: 'HELLO, PYTHON WORLD'
# Replace: 'hello, f-string world'

Appels de Fonctions

def calculate_bmi(weight_kg, height_m):
    return weight_kg / (height_m ** 2)
 
weight = 70
height = 1.75
 
print(f"BMI: {calculate_bmi(weight, height):.1f}")
# Output: BMI: 22.9
 
# Fonctions intégrées
items = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"Items: {items}")
print(f"Count: {len(items)}, Sum: {sum(items)}, Min: {min(items)}, Max: {max(items)}")
# Output:
# Items: [3, 1, 4, 1, 5, 9, 2, 6]
# Count: 8, Sum: 31, Min: 1, Max: 9

Expressions Ternaires (Conditionnelles)

score = 85
status = f"Result: {'PASS' if score >= 60 else 'FAIL'}"
print(status)
# Output: Result: PASS
 
temperature = -5
print(f"Water is {'frozen' if temperature <= 0 else 'liquid' if temperature < 100 else 'steam'}.")
# Output: Water is frozen.

Accès aux Dictionnaires et Listes

user = {"name": "Bob", "role": "engineer", "level": 3}
scores = [88, 92, 76, 95, 81]
 
print(f"{user['name']} is a level {user['level']} {user['role']}.")
# Output: Bob is a level 3 engineer.
 
print(f"First score: {scores[0]}, Last score: {scores[-1]}")
# Output: First score: 88, Last score: 81

Spécifications de Formatage : Nombres, Alignement et Remplissage

La véritable puissance des f-strings se révèle dans les spécifications de formatage. Après l'expression, ajoutez deux-points : suivis d'une spécification de format. La syntaxe générale est :

{expression:[[fill]align][sign][#][0][width][grouping_option][.precision][type]}

Cela semble dense, mais chaque élément est optionnel. Décomposons-le avec des exemples.

Décimales et Précision en Virgule Flottante

Le spécificateur .Nf contrôle le nombre de décimales affichées pour un flottant :

pi = 3.141592653589793
 
print(f"Default:    {pi}")
print(f"2 decimals: {pi:.2f}")
print(f"4 decimals: {pi:.4f}")
print(f"0 decimals: {pi:.0f}")
print(f"8 decimals: {pi:.8f}")
# Output:
# Default:    3.141592653589793
# 2 decimals: 3.14
# 4 decimals: 3.1416
# 0 decimals: 3
# 8 decimals: 3.14159265

Séparateurs de Milliers

Les grands nombres deviennent instantanément lisibles avec le regroupement par virgules ou tirets bas :

revenue = 1234567890
small_amount = 1234.5
 
print(f"Revenue: {revenue:,}")
print(f"Revenue: {revenue:_}")
print(f"Amount: ${small_amount:,.2f}")
# Output:
# Revenue: 1,234,567,890
# Revenue: 1_234_567_890
# Amount: $1,234.50

Formatage de Pourcentage

Le type % multiplie la valeur par 100 et ajoute un signe de pourcentage :

completion = 0.876
error_rate = 0.034
growth = 1.25
 
print(f"Completion: {completion:.1%}")
print(f"Error rate: {error_rate:.2%}")
print(f"Growth: {growth:.0%}")
# Output:
# Completion: 87.6%
# Error rate: 3.40%
# Growth: 125%

Notation Scientifique

avogadro = 6.022e23
planck = 6.626e-34
 
print(f"Avogadro: {avogadro:.3e}")
print(f"Planck: {planck:.4E}")
# Output:
# Avogadro: 6.022e+23
# Planck: 6.6260E-34

Bases Entières : Binaire, Octale, Hexadécimale

value = 255
 
print(f"Decimal:     {value:d}")
print(f"Binary:      {value:b}")
print(f"Octal:       {value:o}")
print(f"Hex (lower): {value:x}")
print(f"Hex (upper): {value:X}")
print(f"With prefix: {value:#b}  {value:#o}  {value:#x}")
# Output:
# Decimal:     255
# Binary:      11111111
# Octal:       377
# Hex (lower): ff
# Hex (upper): FF
# With prefix: 0b11111111  0o377  0xff

Alignement et Remplissage

Les spécificateurs d'alignement contrôlent comment les valeurs se positionnent dans une largeur donnée. Utilisez < pour la gauche, > pour la droite, et ^ pour le centre :

label = "Python"
 
print(f"|{label:<20}|")   # Alignement à gauche sur 20 caractères
print(f"|{label:>20}|")   # Alignement à droite
print(f"|{label:^20}|")   # Centré
print(f"|{label:*^20}|")  # Centré avec remplissage *
print(f"|{label:->20}|")  # Droite avec remplissage -
# Output:
# |Python              |
# |              Python|
# |       Python       |
# |*******Python*******|
# |--------------Python|

Le remplissage par zéros pour les nombres est courant dans le formatage de rapports :

for i in [1, 42, 100, 7, 999]:
    print(f"ID: {i:05d}")
# Output:
# ID: 00001
# ID: 00042
# ID: 00100
# ID: 00007
# ID: 00999

Construction de Tableaux Alignés

La combinaison de l'alignement avec les spécifications de format produit des tableaux propres :

products = [
    ("Laptop Pro", 1299.99, 45),
    ("Wireless Mouse", 29.50, 230),
    ("USB-C Hub", 54.95, 120),
    ("Monitor 27in", 449.00, 67),
]
 
print(f"{'Product':<18} {'Price':>10} {'Stock':>7}")
print("-" * 37)
for name, price, stock in products:
    print(f"{name:<18} ${price:>9.2f} {stock:>7,}")
print("-" * 37)
 
total_value = sum(p * s for _, p, s in products)
print(f"{'Total Value':<18} ${total_value:>9,.2f}")
 
# Output:
# Product               Price   Stock
# -------------------------------------
# Laptop Pro         $ 1,299.99      45
# Wireless Mouse     $    29.50     230
# USB-C Hub          $    54.95     120
# Monitor 27in       $   449.00      67
# -------------------------------------
# Total Value        $91,498.05

Formatage de Dates et Heures avec les F-Strings

Les f-strings acceptent directement les codes de format strftime, ce qui signifie que vous pouvez formater des objets datetime sans appeler .strftime() :

from datetime import datetime, date, timedelta
 
now = datetime.now()
 
print(f"ISO format:  {now:%Y-%m-%d %H:%M:%S}")
print(f"US format:   {now:%m/%d/%Y}")
print(f"Long format: {now:%B %d, %Y at %I:%M %p}")
print(f"Day of week: {now:%A}")
print(f"Short month: {now:%b %d}")
# Output (varies by current time):
# ISO format:  2026-02-13 14:30:00
# US format:   02/13/2026
# Long format: February 13, 2026 at 02:30 PM
# Day of week: Friday
# Short month: Feb 13

Cela fonctionne aussi avec les objets date :

from datetime import date
 
birthday = date(1995, 8, 15)
today = date.today()
age_days = (today - birthday).days
 
print(f"Birthday: {birthday:%B %d, %Y}")
print(f"Days alive: {age_days:,}")
print(f"Years (approx): {age_days / 365.25:.1f}")
# Output:
# Birthday: August 15, 1995
# Days alive: 11,139
# Years (approx): 30.5

F-Strings Multilignes

Les f-strings avec guillemets triples vous permettent de construire des blocs de texte formatés. Chaque ligne dans une f-string avec guillemets triples peut contenir des expressions {} :

project = "Data Pipeline"
owner = "Engineering Team"
status = "In Progress"
completion = 0.73
budget = 250000
spent = 182500
 
report = f"""
========================================
  Project Status Report
========================================
  Project:    {project}
  Owner:      {owner}
  Status:     {status}
  Completion: {completion:.0%}
  Budget:     ${budget:>12,}
  Spent:      ${spent:>12,}
  Remaining:  ${budget - spent:>12,}
========================================
"""
 
print(report)

Vous pouvez aussi construire des f-strings multilignes en concaténant plusieurs f-strings avec une concaténation de chaînes implicite (en les plaçant côte à côte sans opérateur) :

name = "Alice"
role = "Data Scientist"
years = 5
 
bio = (
    f"Name: {name}\n"
    f"Role: {role}\n"
    f"Experience: {years} years\n"
    f"Seniority: {'Senior' if years >= 5 else 'Mid-level'}"
)
 
print(bio)
# Output:
# Name: Alice
# Role: Data Scientist
# Experience: 5 years
# Seniority: Senior

Cette deuxième approche évite le saut de ligne initial et les problèmes d'indentation qui viennent parfois avec les chaînes à guillemets triples.

Le Spécificateur = pour le Débogage (Python 3.8+)

Python 3.8 a ajouté le spécificateur = aux f-strings, et c'est l'une des fonctionnalités de débogage les plus utiles du langage. Quand vous écrivez f"{expression=}", Python affiche à la fois le texte de l'expression et sa valeur.

x = 42
y = 17
 
print(f"{x=}")
print(f"{y=}")
print(f"{x + y=}")
print(f"{x * y=}")
# Output:
# x=42
# y=17
# x + y=59
# x * y=714

Vous pouvez combiner = avec des spécificateurs de format :

price = 49.99
tax_rate = 0.0825
total = price * (1 + tax_rate)
 
print(f"{price=:.2f}")
print(f"{tax_rate=:.1%}")
print(f"{total=:.2f}")
# Output:
# price=49.99
# tax_rate=8.2%
# total=54.12

Le spécificateur = préserve les espaces autour de lui. Ajouter des espaces avant = formate la sortie :

name = "Alice"
score = 95
 
print(f"{name = }")
print(f"{score = }")
# Output:
# name = 'Alice'
# score = 95

Notez que pour les chaînes, = utilise repr() par défaut (montrant les guillemets). Pour les nombres, il utilise str().

Débogage d'Expressions Complexes

Le spécificateur = fonctionne avec n'importe quelle expression, ce qui en fait un moyen rapide d'inspecter les valeurs intermédiaires :

data = [23, 45, 12, 67, 34, 89, 56]
 
print(f"{len(data)=}")
print(f"{sum(data)=}")
print(f"{sum(data)/len(data)=:.2f}")
print(f"{sorted(data)=}")
print(f"{max(data) - min(data)=}")
# Output:
# len(data)=7
# sum(data)=326
# sum(data)/len(data)=46.57
# sorted(data)=[12, 23, 34, 45, 56, 67, 89]
# max(data) - min(data)=77

Si vous travaillez dans des notebooks Jupyter et que vous vous retrouvez à ajouter constamment des appels print(f"{variable=}") pendant le débogage, envisagez RunCell (opens in a new tab), un agent IA qui s'exécute directement dans Jupyter. RunCell comprend les variables dans la mémoire de votre notebook et peut inspecter, expliquer et suggérer des corrections sans que vous ayez à écrire manuellement des instructions de débogage. Il est particulièrement utile lors du passage à travers des transformations de données où vous devez vérifier des valeurs intermédiaires sur plusieurs cellules.

F-Strings Imbriquées

Vous pouvez imbriquer des f-strings à l'intérieur d'autres f-strings. Le cas d'usage le plus courant est les spécifications de format dynamiques, où la largeur ou la précision provient d'une variable :

# Précision dynamique
value = 3.14159265
for precision in range(1, 6):
    print(f"  {precision} decimals: {value:.{precision}f}")
# Output:
#   1 decimals: 3.1
#   2 decimals: 3.14
#   3 decimals: 3.142
#   4 decimals: 3.1416
#   5 decimals: 3.14159

# Largeur dynamique
header = "Report"
for width in [20, 30, 40]:
    print(f"|{header:^{width}}|")
# Output:
# |       Report       |
# |            Report            |
# |                 Report                 |

# F-string imbriquée pour formater une liste
values = [1.234, 56.789, 0.001, 999.999]
decimals = 2
formatted = f"Results: {', '.join(f'{v:.{decimals}f}' for v in values)}"
print(formatted)
# Output: Results: 1.23, 56.79, 0.00, 1000.00

Utilisez l'imbrication avec parcimonie. Si une f-string nécessite plus d'un niveau d'imbrication, extrayez la logique interne dans une variable ou une fonction pour la lisibilité.

F-Strings vs Autres Méthodes de Formatage de Chaînes

Python a quatre approches principales pour le formatage de chaînes. Voici une comparaison directe :

Fonctionnalité	f-string `f"...{x}..."`	`.format()` `"...{}...".format(x)`	Opérateur `%` `"...%s..." % x`	`Template` `Template("...$x...")`
Version Python	3.6+	2.6+	Toutes	Toutes
Lisibilité	Excellente -- valeurs en ligne	Bonne -- placeholders numérotés/nommés	Correcte -- codes positionnels	Bonne -- placeholders nommés
Performance	La plus rapide	~1.5-2x plus lent	~1.3-1.8x plus lent	La plus lente
Expressions Arbitraires	Oui	Limité	Non	Non
Spécificateur de Débogage (=)	Oui (3.8+)	Non	Non	Non
Modèles Réutilisables	Non	Oui	Oui	Oui
Sûr pour Entrée Utilisateur	Non	Non	Non	Oui (safe_substitute)
Formatage de Type	Complet	Complet	Partiel	Aucun

name = "Charlie"
balance = 1234.56
 
# f-string (recommandé)
print(f"{name} has ${balance:,.2f}")
 
# .format()
print("{} has ${:,.2f}".format(name, balance))
 
# % formatting
print("%s has $%,.2f" % (name, balance))  # Note: % ne supporte pas le regroupement par virgules
 
# Template (du module string)
from string import Template
t = Template("$name has $balance")
print(t.substitute(name=name, balance=f"${balance:,.2f}"))

Quand utiliser chacun :

F-strings : Choix par défaut pour le nouveau code. À utiliser dès que vous exécutez Python 3.6+.
.format() : À utiliser quand vous avez besoin de modèles réutilisables stockés dans des variables ou des fichiers de configuration.
% formatting : Code legacy uniquement. Aucune raison de l'utiliser dans les nouveaux projets.
Template : À utiliser quand la chaîne de formatage provient d'une entrée utilisateur non fiable (elle ne peut pas exécuter d'expressions arbitraires).

Comparaison de Performance

Les f-strings sont plus rapides car Python les compile en bytecode optimisé au moment de l'analyse, évitant le surcoût des appels de méthodes et de l'analyse d'arguments que nécessitent .format() et %.

import timeit
 
name = "Alice"
age = 30
score = 95.5
 
# Benchmark de chaque méthode avec 1 million d'itérations
fstring_time = timeit.timeit(
    'f"{name} scored {score:.1f} at age {age}"',
    globals={"name": name, "age": age, "score": score},
    number=1_000_000
)
 
format_time = timeit.timeit(
    '"{} scored {:.1f} at age {}".format(name, score, age)',
    globals={"name": name, "age": age, "score": score},
    number=1_000_000
)
 
percent_time = timeit.timeit(
    '"%s scored %.1f at age %d" % (name, score, age)',
    globals={"name": name, "age": age, "score": score},
    number=1_000_000
)
 
concat_time = timeit.timeit(
    'name + " scored " + str(score) + " at age " + str(age)',
    globals={"name": name, "age": age, "score": score},
    number=1_000_000
)
 
print(f"f-string:      {fstring_time:.4f}s (baseline)")
print(f"str.format():  {format_time:.4f}s ({format_time/fstring_time:.2f}x slower)")
print(f"% formatting:  {percent_time:.4f}s ({percent_time/fstring_time:.2f}x slower)")
print(f"concatenation: {concat_time:.4f}s ({concat_time/fstring_time:.2f}x slower)")
 
# Résultats typiques :
# f-string:      0.0850s (baseline)
# str.format():  0.1450s (1.71x slower)
# % formatting:  0.1100s (1.29x slower)
# concatenation: 0.1200s (1.41x slower)

L'écart de performance se creuse à mesure que les expressions deviennent plus complexes. Dans les boucles serrées traitant des milliers d'enregistrements, les f-strings font une différence mesurable.

Erreurs Courantes et Pièges

Échappement des Accolades

Pour inclure une accolade littérale { ou } dans une f-string, doublez-la :

value = 42
 
# Accolades littérales autour d'une valeur
print(f"{{{value}}}")
# Output: {42}
 
# Sortie de type JSON
key = "name"
val = "Alice"
print(f'{{"{key}": "{val}"}}')
# Output: {"name": "Alice"}
 
# Juste des accolades littérales, sans interpolation
print(f"Use {{variable}} syntax in f-strings")
# Output: Use {variable} syntax in f-strings

Antislashs à l'Intérieur des Expressions

Vous ne pouvez pas utiliser de caractères antislash à l'intérieur de la partie expression {} d'une f-string. C'est un choix de conception délibéré pour la lisibilité :

items = ["apple", "banana", "cherry"]
 
# Cela provoque une SyntaxError :
# print(f"{'\\n'.join(items)}")
 
# Solution 1 : assigner à une variable d'abord
newline = "\n"
print(f"{newline.join(items)}")
 
# Solution 2 : utiliser une opération séparée
joined = "\n".join(items)
print(f"Items:\n{joined}")
 
# Solution 3 : utiliser chr()
print(f"{chr(10).join(items)}")

Conflits de Guillemets

Quand votre f-string utilise des guillemets doubles, les expressions à l'intérieur doivent utiliser des guillemets simples (ou vice versa) :

data = {"name": "Alice", "age": 30}
 
# Utilisez des guillemets simples à l'intérieur quand la f-string utilise des doubles
print(f"Name: {data['name']}, Age: {data['age']}")
 
# Ou utilisez des guillemets doubles à l'intérieur quand la f-string utilise des simples
print(f'Name: {data["name"]}, Age: {data["age"]}')
 
# Avec des guillemets triples, vous avez plus de flexibilité
print(f"""Name: {data["name"]}, Age: {data["age"]}""")

Les F-Strings Ne Sont Pas des Constantes

Les f-strings sont évaluées au moment de l'exécution, ce qui signifie que vous ne pouvez pas les utiliser comme valeurs d'arguments par défaut ou constantes au niveau du module qui dépendent de l'état d'exécution :

# Cela fonctionne mais s'évalue au moment de l'appel, pas de la définition
def greet(name, template=None):
    if template is None:
        template = f"Hello, {name}!"  # Évalué ici
    return template
 
# Pour de vrais modèles, utilisez str.format()
TEMPLATE = "Hello, {name}! You have {count} messages."
print(TEMPLATE.format(name="Alice", count=5))

Attention aux Expressions Trop Larges

Ce n'est pas parce que vous pouvez mettre n'importe quelle expression dans une f-string que vous devriez le faire. Gardez les expressions des f-strings simples :

# Difficile à lire -- trop de logique à l'intérieur de la f-string
result = f"{'%.2f' % (sum(x**2 for x in range(100)) / 100)}"
 
# Bien mieux -- calculer d'abord, puis formater
mean_square = sum(x**2 for x in range(100)) / 100
result = f"{mean_square:.2f}"

F-Strings Brutes (Raw)

La combinaison des préfixes r (brut) et f crée une f-string brute où les antislashs sont traités littéralement (pas de séquences d'échappement) tout en évaluant les expressions :

user = "admin"
folder = "projects"
 
# F-string brute pour les chemins Windows
path = rf"C:\Users\{user}\{folder}\data.csv"
print(path)
# Output: C:\Users\admin\projects\data.csv
 
# Utile pour les patterns regex avec parties dynamiques
import re
prefix = "user"
pattern = rf"\b{prefix}_\d+\b"
text = "Found user_123 and user_456 in the log"
matches = re.findall(pattern, text)
print(f"Matches: {matches}")
# Output: Matches: ['user_123', 'user_456']

À la fois rf"..." et fr"..." sont valides -- l'ordre des préfixes n'a pas d'importance.

F-Strings avec les Flux de Travail Data Science

Les f-strings sont inestimables en data science pour formater les sorties, construire des étiquettes dynamiques et créer des résumés lisibles à partir de résultats numériques.

Formatage de Sorties Numériques

import statistics
 
data = [23.4, 45.1, 31.8, 52.3, 41.7, 38.9, 29.6, 47.2]
 
mean = statistics.mean(data)
median = statistics.median(data)
stdev = statistics.stdev(data)
cv = stdev / mean  # coefficient de variation
 
print(f"Sample size:    {len(data)}")
print(f"Mean:           {mean:.2f}")
print(f"Median:         {median:.2f}")
print(f"Std deviation:  {stdev:.2f}")
print(f"CV:             {cv:.1%}")
print(f"Range:          {min(data):.1f} - {max(data):.1f}")
# Output:
# Sample size:    8
# Mean:           38.75
# Median:         40.30
# Std deviation:  9.87
# CV:             25.5%
# Range:          23.4 - 52.3

Travail avec les DataFrames Pandas

import pandas as pd
 
df = pd.DataFrame({
    "product": ["Widget A", "Widget B", "Widget C", "Widget D"],
    "revenue": [125000, 89000, 234000, 67000],
    "units": [1250, 2100, 980, 3400],
})
 
# Statistiques récapitulatives avec f-strings
total_rev = df["revenue"].sum()
avg_price = (df["revenue"] / df["units"]).mean()
 
print(f"Total Revenue:  ${total_rev:>12,}")
print(f"Avg Unit Price: ${avg_price:>12,.2f}")
print(f"Products:       {len(df):>12,}")
 
# Formatage dynamique des colonnes
for _, row in df.iterrows():
    unit_price = row["revenue"] / row["units"]
    print(f"  {row['product']:<12} | Revenue: ${row['revenue']:>9,} | Units: {row['units']:>5,} | $/unit: ${unit_price:.2f}")
 
# Output:
# Total Revenue:  $     515,000
# Avg Unit Price: $       56.00
# Products:              4
#   Widget A     | Revenue: $  125,000 | Units: 1,250 | $/unit: $100.00
#   Widget B     | Revenue: $   89,000 | Units: 2,100 | $/unit: $42.38
#   Widget C     | Revenue: $  234,000 | Units:   980 | $/unit: $238.78
#   Widget D     | Revenue: $   67,000 | Units: 3,400 | $/unit: $19.71

Quand votre analyse de données va au-delà des résumés textuels et que vous avez besoin d'une exploration interactive, PyGWalker (opens in a new tab) peut transformer n'importe quel DataFrame pandas en une visualisation interactive de type Tableau avec une seule ligne de code. Au lieu de formater manuellement des nombres pour des rapports statiques, vous pouvez glisser-déposer des colonnes pour construire des graphiques, appliquer des filtres et explorer les patterns visuellement -- tout cela dans votre notebook Jupyter.

import pandas as pd
import pygwalker as pyg
 
# Après avoir préparé votre DataFrame avec des colonnes bien formatées
df = pd.DataFrame({
    "Month": ["Jan", "Feb", "Mar", "Apr", "May", "Jun"],
    "Revenue": [125000, 134000, 158000, 142000, 167000, 189000],
    "Growth": [0.05, 0.072, 0.179, -0.101, 0.176, 0.132],
})
 
# Ajouter des colonnes formatées pour l'affichage
df["Revenue_Display"] = df["Revenue"].apply(lambda x: f"${x:,.0f}")
df["Growth_Display"] = df["Growth"].apply(lambda x: f"{x:+.1%}")
 
# Lancer la visualisation interactive
# pyg.walk(df)

Formatage des Résultats de Modèles

# Formatage des résultats de machine learning
metrics = {
    "accuracy": 0.9234,
    "precision": 0.8891,
    "recall": 0.9456,
    "f1_score": 0.9164,
    "auc_roc": 0.9678,
}
 
print("Model Evaluation Results")
print("=" * 35)
for metric, value in metrics.items():
    bar_length = int(value * 20)
    bar = "#" * bar_length + "-" * (20 - bar_length)
    print(f"  {metric:<12} {value:.4f}  [{bar}]")
# Output:
# Model Evaluation Results
# ===================================
#   accuracy     0.9234  [##################--]
#   precision    0.8891  [#################---]
#   recall       0.9456  [##################--]
#   f1_score     0.9164  [##################--]
#   auc_roc      0.9678  [###################-]

Drapeaux de Conversion : !s, !r, et !a

Les f-strings supportent trois drapeaux de conversion qui contrôlent comment la valeur de l'expression est convertie avant le formatage :

!s appelle str() sur la valeur (comportement par défaut)
!r appelle repr() sur la valeur
!a appelle ascii() sur la valeur

text = "Hello\tWorld"
name = "Caf\u00e9"
 
print(f"str:   {text!s}")
print(f"repr:  {text!r}")
print(f"ascii: {name!a}")
# Output:
# str:   Hello	World
# repr:  'Hello\tWorld'
# ascii: 'Caf\xe9'

Le drapeau !r est particulièrement utile pour le débogage, car il montre la représentation brute incluant les guillemets et les caractères d'échappement. Il fonctionne bien avec le spécificateur =.

Questions Fréquemment Posées

Que sont les f-strings Python et quand ont-elles été introduites ?

Les f-strings (littéraux de chaînes formatées) sont un mécanisme de formatage de chaînes introduit dans Python 3.6 via la PEP 498. Elles vous permettent d'intégrer des expressions Python directement à l'intérieur des littéraux de chaînes en préfixant la chaîne avec f et en plaçant les expressions à l'intérieur des accolades. Les f-strings sont évaluées au moment de l'exécution, offrent la meilleure lisibilité parmi toutes les options de formatage Python, et sont plus rapides que str.format() et le formatage % car elles se compilent en bytecode optimisé au moment de l'analyse.

Comment formater des nombres avec des virgules et des décimales dans les f-strings ?

Utilisez la spécification de format après un deux-points à l'intérieur des accolades. Pour les virgules comme séparateurs de milliers, utilisez :, -- par exemple, f"{1234567:,}" produit "1,234,567". Pour les décimales, utilisez :.Nf où N est le nombre de chiffres -- par exemple, f"{3.14159:.2f}" donne "3.14". Combinez les deux : f"{1234.5:,.2f}" affiche "1,234.50". Pour les pourcentages, utilisez :.N% qui multiplie par 100 et ajoute un signe de pourcentage : f"{0.85:.1%}" produit "85.0%".

Qu'est-ce que le spécificateur = des f-strings et comment aide-t-il au débogage ?

Le spécificateur = a été ajouté dans Python 3.8 et affiche à la fois le texte de l'expression et sa valeur. Écrire f"{variable=}" affiche variable=valeur. Cela élimine le besoin de taper le nom de variable deux fois lors du débogage. Cela fonctionne avec n'importe quelle expression : f"{len(data)=}" affiche len(data)=42. Vous pouvez le combiner avec des spécifications de format comme f"{price=:.2f}".

Puis-je utiliser les f-strings avec des chaînes multilignes ?

Oui. Utilisez des guillemets triples (f"""...""" ou f'''...''') pour les f-strings multilignes. Chaque ligne peut contenir des placeholders {expression}. Alternativement, concaténez plusieurs f-strings en utilisant une concaténation de chaînes implicite en les plaçant côte à côte dans des parenthèses.

Les f-strings sont-elles plus rapides que str.format() et le formatage % ?

Oui. Les f-strings sont systématiquement la méthode de formatage de chaînes la plus rapide en Python. Elles s'exécutent généralement 1,5 à 2 fois plus vite que str.format() et 1,3 à 1,8 fois plus vite que le formatage %. L'avage de performance vient de l'optimisation au moment de la compilation où Python convertit les f-strings directement en bytecode efficace.

Comment inclure des accolades littérales dans une f-string ?

Doublez les accolades. Utilisez {{ pour une accolade littérale { et }} pour une accolade littérale }. Par exemple, f"{{value}}" affiche {value} comme texte brut. Pour envelopper une valeur interpolée dans des accolades, utilisez f"{{{variable}}}" -- les accolades doublées extérieures produisent des accolades littérales, tandis que les accolades simples intérieures déclenchent l'interpolation.

Conclusion

Les f-strings sont la méthode standard pour formater les chaînes en Python moderne. Elles combinent la meilleure lisibilité de toute approche de formatage avec les meilleures performances, et elles supportent la gamme complète des spécifications de formatage : précision décimale, séparateurs de milliers, pourcentages, notation scientifique, alignement, remplissage, formatage de dates et conversions de bases.

Les points clés à retenir :

Préfixez avec f et placez les expressions à l'intérieur des {accolades}.
Utilisez : suivi d'une spécification de format pour un contrôle précis de la sortie (:.2f, :,, :.1%, :<20).
Utilisez = après l'expression pour le débogage (f"{variable=}"). Nécessite Python 3.8+.
Échappez les accolades littérales en les doublant : {{ et }}.
Ne mettez pas d'antislashs à l'intérieur des expressions {}. Assignez à une variable d'abord.
Gardez les expressions simples. Si la logique à l'intérieur de {} est difficile à lire, extrayez-la.
N'utilisez .format() que lorsque vous avez besoin de modèles réutilisables stockés comme variables.

Les f-strings gèrent tout, du débogage rapide avec print() à la génération de rapports de production. Une fois que vous les avez adoptées, il n'y a aucune raison de retourner aux anciennes méthodes de formatage. Que vous construisiez des pipelines de données, formatiez des sorties de modèles ML ou génériez des rapports financiers, les f-strings offrent un code propre, rapide et lisible.

📚