Skip to content

Python f-strings : le guide complet des littéraux de chaînes formatées

Soren Atelier
Name
Soren Atelier

Updated on

Le formatage de chaînes en Python a évolué au fil des années à travers plusieurs approches, chacune avec ses problèmes de verbosité et de lisibilité. L’ancien formatage au style % mène à une syntaxe cryptique, tandis que .format() produit du code inutilement long avec des placeholders numérotés. Ces approches transforment une simple interpolation de chaîne en un casse-tête plutôt qu’en du code clair et maintenable.

La frustration s’amplifie quand vous devez formater des nombres avec une précision spécifique, aligner du texte dans des tableaux, ou déboguer des valeurs de variables directement en ligne. Les méthodes traditionnelles dispersent votre logique entre chaînes de format et listes d’arguments, ce qui rend difficile d’anticiper le rendu final. Dans les tâches d’analyse de données et de reporting, vous passez plus de temps à lutter contre la syntaxe de formatage qu’à vous concentrer sur votre analyse.

Python 3.6 a introduit les f-strings (formatted string literals) comme solution moderne et élégante au formatage de chaînes. En préfixant les chaînes avec 'f' et en intégrant des expressions directement entre accolades, les f-strings offrent l’approche la plus lisible et la plus performante pour l’interpolation de chaînes en Python. Ce guide couvre tout, de l’usage de base aux techniques avancées de formatage qui transformeront votre manière de travailler avec les chaînes.

📚

    Syntaxe de base des f-strings

    Les f-strings utilisent une notation simple : vous ajoutez 'f' ou 'F' avant le guillemet d’ouverture d’une chaîne. À l’intérieur de la chaîne, toute expression entourée d’accolades est évaluée et insérée dans la sortie finale.

    name = "Alice"
age = 30
 
# Basic f-string
message = f"My name is {name} and I am {age} years old"
print(message)
# Output: My name is Alice and I am 30 years old
 
# Using uppercase F
greeting = F"Hello, {name}!"
print(greeting)
# Output: Hello, Alice!

    La puissance des f-strings devient évidente lorsqu’on les compare aux approches plus anciennes :

    name = "Bob"
score = 95.5
 
# Old style % formatting
old_way = "Student: %s, Score: %.1f" % (name, score)
 
# str.format() method
format_way = "Student: {}, Score: {:.1f}".format(name, score)
 
# Modern f-string
f_string_way = f"Student: {name}, Score: {score:.1f}"
 
print(f_string_way)
# Output: Student: Bob, Score: 95.5

    Interpolation de variables et expressions

    Les f-strings ne gèrent pas seulement des variables : elles évaluent toute expression Python valide à l’intérieur des accolades. Cela inclut des opérations arithmétiques, des appels de méthodes, des compréhensions de listes et des appels de fonctions.

    # Arithmetic expressions
x = 10
y = 5
result = f"{x} + {y} = {x + y}"
print(result)
# Output: 10 + 5 = 15
 
# String methods
text = "python"
formatted = f"Language: {text.upper()}, Length: {len(text)}"
print(formatted)
# Output: Language: PYTHON, Length: 6
 
# Dictionary and list access
user = {"name": "Charlie", "role": "developer"}
scores = [88, 92, 95]
info = f"{user['name']} is a {user['role']} with average score {sum(scores)/len(scores):.1f}"
print(info)
# Output: Charlie is a developer with average score 91.7

    Vous pouvez appeler des fonctions directement dans des f-strings, rendant des opérations de formatage complexes remarquablement concises :

    def calculate_discount(price, discount_percent):
    return price * (1 - discount_percent / 100)
 
price = 100
discount = 20
 
message = f"Original: ${price}, Final: ${calculate_discount(price, discount):.2f}"
print(message)
# Output: Original: $100, Final: $80.00
 
# List comprehension inside f-string
numbers = [1, 2, 3, 4, 5]
result = f"Squares: {[n**2 for n in numbers]}"
print(result)
# Output: Squares: [1, 4, 9, 16, 25]

    Techniques de formatage des nombres

    Les f-strings offrent de nombreuses options de formatage pour les nombres via des spécificateurs de format qui suivent un deux-points à l’intérieur des accolades. La syntaxe générale est {value:format_spec}.

    Décimales et précision

    pi = 3.14159265359
 
# Different decimal places
print(f"2 decimals: {pi:.2f}")
print(f"4 decimals: {pi:.4f}")
print(f"0 decimals: {pi:.0f}")
 
# Output:
# 2 decimals: 3.14
# 4 decimals: 3.1416
# 0 decimals: 3

    Séparateur de milliers

    large_number = 1234567890
 
# Comma separator
print(f"With commas: {large_number:,}")
# Output: With commas: 1,234,567,890
 
# Underscore separator (Python 3.6+)
print(f"With underscores: {large_number:_}")
# Output: With underscores: 1_234_567_890
 
# Combining separators with decimal places
revenue = 1234567.89
print(f"Revenue: ${revenue:,.2f}")
# Output: Revenue: $1,234,567.89

    Pourcentages et notation scientifique

    ratio = 0.456
 
# Percentage formatting
print(f"Completion: {ratio:.1%}")
# Output: Completion: 45.6%
 
# Scientific notation
big_num = 1234567890
print(f"Scientific: {big_num:.2e}")
# Output: Scientific: 1.23e+09
 
# Precision with scientific notation
small_num = 0.000000123
print(f"Small: {small_num:.2e}")
# Output: Small: 1.23e-07

    Binaire, octal et hexadécimal

    number = 255
 
# Binary
print(f"Binary: {number:b}")
# Output: Binary: 11111111
 
# Octal
print(f"Octal: {number:o}")
# Output: Octal: 377
 
# Hexadecimal (lowercase)
print(f"Hex: {number:x}")
# Output: Hex: ff
 
# Hexadecimal (uppercase)
print(f"Hex: {number:X}")
# Output: Hex: FF
 
# With prefix
print(f"Binary: {number:#b}, Hex: {number:#x}")
# Output: Binary: 0b11111111, Hex: 0xff

    Alignement et remplissage des chaînes

    Les f-strings offrent de puissantes options d’alignement pour créer des tableaux et des rapports formatés. La syntaxe est {value:fill_char align width} où align peut être '<' (gauche), '>' (droite) ou '^' (centré).

    # Basic alignment
name = "Python"
 
# Left align (default for strings)
print(f"|{name:<15}|")
# Output: |Python         |
 
# Right align
print(f"|{name:>15}|")
# Output: |         Python|
 
# Center align
print(f"|{name:^15}|")
# Output: |    Python     |
 
# Custom fill character
print(f"|{name:*<15}|")
print(f"|{name:*>15}|")
print(f"|{name:*^15}|")
# Output:
# |Python*********|
# |*********Python|
# |****Python*****|

    Pour les nombres, l’alignement à droite est le comportement par défaut, ce qui est idéal pour créer des colonnes alignées :

    # Creating aligned tables
products = [
    ("Apple", 1.50, 10),
    ("Banana", 0.75, 25),
    ("Orange", 2.00, 15)
]
 
print(f"{'Product':<12} {'Price':>8} {'Qty':>6}")
print("-" * 28)
for product, price, qty in products:
    print(f"{product:<12} ${price:>7.2f} {qty:>6}")
 
# Output:
# Product         Price    Qty
# ----------------------------
# Apple          $   1.50     10
# Banana         $   0.75     25
# Orange         $   2.00     15

    Vous pouvez combiner l’alignement avec le formatage des nombres pour un rendu professionnel :

    # Financial report formatting
transactions = [
    ("Sales", 12500.50),
    ("Returns", -350.25),
    ("Shipping", -125.00),
    ("Tax", 1200.00)
]
 
print(f"{'Category':<15} {'Amount':>12}")
print("=" * 29)
total = 0
for category, amount in transactions:
    total += amount
    sign = "+" if amount >= 0 else ""
    print(f"{category:<15} {sign}{amount:>11,.2f}")
print("=" * 29)
print(f"{'Total':<15} {total:>12,.2f}")
 
# Output:
# Category             Amount
# =============================
# Sales              +12,500.50
# Returns               -350.25
# Shipping              -125.00
# Tax                 +1,200.00
# =============================
# Total               13,225.25

    Formatage des dates et heures

    Les f-strings fonctionnent parfaitement avec les objets datetime, vous permettant de formater dates et heures via les directives strftime standard.

    from datetime import datetime, timedelta
 
now = datetime.now()
 
# Basic date formatting
print(f"Date: {now:%Y-%m-%d}")
# Output: Date: 2026-02-11
 
# Full datetime
print(f"DateTime: {now:%Y-%m-%d %H:%M:%S}")
# Output: DateTime: 2026-02-11 14:30:45
 
# Custom formats
print(f"Formatted: {now:%B %d, %Y at %I:%M %p}")
# Output: Formatted: February 11, 2026 at 02:30 PM
 
# Day of week
print(f"Today is {now:%A}")
# Output: Today is Tuesday
 
# Combining with other formatting
duration = timedelta(hours=2, minutes=30)
start_time = datetime(2026, 2, 11, 14, 0)
end_time = start_time + duration
 
print(f"Meeting: {start_time:%I:%M %p} - {end_time:%I:%M %p} ({duration.total_seconds()/3600:.1f} hours)")
# Output: Meeting: 02:00 PM - 04:30 PM (2.5 hours)

    f-strings multilignes

    Les f-strings prennent en charge les chaînes multilignes via les triple guillemets, ce qui les rend parfaites pour générer des rapports formatés, des requêtes SQL ou du texte structuré.

    # Multiline f-string
name = "Data Science Team"
members = 12
budget = 150000
 
report = f"""
Project Report
{'=' * 40}
Team Name: {name}
Members: {members}
Budget: ${budget:,}
Per Member: ${budget/members:,.2f}
"""
 
print(report)
# Output:
# Project Report
# ========================================
# Team Name: Data Science Team
# Members: 12
# Budget: $150,000
# Per Member: $12,500.00

    C’est particulièrement utile pour générer des requêtes SQL ou des fichiers de configuration, même si vous devez toujours utiliser des requêtes paramétrées pour de vraies opérations en base de données :

    # Template generation (for display, not execution)
table_name = "users"
columns = ["id", "name", "email"]
conditions = {"status": "active", "age": 25}
 
query = f"""
SELECT {', '.join(columns)}
FROM {table_name}
WHERE status = '{conditions['status']}'
  AND age >= {conditions['age']}
ORDER BY name;
"""
 
print(query)
# Output:
# SELECT id, name, email
# FROM users
# WHERE status = 'active'
#   AND age >= 25
# ORDER BY name;

    Débogage avec le spécificateur = dans les f-strings

    Python 3.8 a introduit le spécificateur '=' pour les f-strings, qui affiche à la fois l’expression et sa valeur. C’est extrêmement utile pour le débogage et le logging.

    # Basic debugging
x = 10
y = 20
 
print(f"{x=}, {y=}, {x+y=}")
# Output: x=10, y=20, x+y=30
 
# With formatting
pi = 3.14159
print(f"{pi=:.2f}")
# Output: pi=3.14
 
# Function calls
def calculate_total(items):
    return sum(items)
 
prices = [10.99, 25.50, 8.75]
print(f"{calculate_total(prices)=:.2f}")
# Output: calculate_total(prices)=45.24
 
# Complex expressions
data = [1, 2, 3, 4, 5]
print(f"{len(data)=}, {sum(data)=}, {sum(data)/len(data)=:.2f}")
# Output: len(data)=5, sum(data)=15, sum(data)/len(data)=3.00

    Cette fonctionnalité est particulièrement utile dans des workflows d’analyse de données lorsque vous devez inspecter rapidement des résultats intermédiaires :

    # Data analysis debugging
dataset = [45, 52, 48, 61, 55, 49, 58]
 
mean = sum(dataset) / len(dataset)
variance = sum((x - mean) ** 2 for x in dataset) / len(dataset)
std_dev = variance ** 0.5
 
print(f"""
Statistics:
{len(dataset)=}
{mean=:.2f}
{variance=:.2f}
{std_dev=:.2f}
""")
# Output:
# Statistics:
# len(dataset)=7
# mean=52.57
# variance=28.53
# std_dev=5.34

    f-strings imbriquées

    Vous pouvez imbriquer des f-strings dans des f-strings pour un formatage dynamique, même s’il faut l’utiliser avec parcimonie pour préserver la lisibilité.

    # Dynamic precision
value = 3.14159265
precision = 3
 
result = f"{value:.{precision}f}"
print(result)
# Output: 3.142
 
# Dynamic width and alignment
text = "Python"
width = 12
align = "^"
 
formatted = f"{text:{align}{width}}"
print(f"|{formatted}|")
# Output: |   Python   |
 
# Complex nesting
values = [1.23456, 7.89012, 3.45678]
decimals = 2
 
formatted_values = f"Values: {', '.join([f'{v:.{decimals}f}' for v in values])}"
print(formatted_values)
# Output: Values: 1.23, 7.89, 3.46

    f-strings brutes (raw)

    Les f-strings brutes combinent les préfixes 'r' et 'f' pour créer des chaînes où les backslashes sont traités littéralement tout en permettant l’interpolation d’expressions. L’ordre des préfixes n’a pas d’importance : 'rf' et 'fr' fonctionnent.

    # Regular f-string (backslash escaping active)
path = "Documents"
regular = f"C:\Users\{path}\file.txt"  # Would cause issues with \U and \f
# This might not work as expected due to escape sequences
 
# Raw f-string
raw = rf"C:\Users\{path}\file.txt"
print(raw)
# Output: C:\Users\Documents\file.txt
 
# Useful for regex patterns
import re
 
pattern_part = r"\d+"
full_pattern = rf"User ID: {pattern_part}"
print(full_pattern)
# Output: User ID: \d+
 
# Windows file paths
folder = "Projects"
file = "data.csv"
full_path = rf"C:\Users\Admin\{folder}\{file}"
print(full_path)
# Output: C:\Users\Admin\Projects\data.csv

    Comparaison des performances

    Les f-strings ne sont pas seulement plus lisibles : ce sont aussi la méthode de formatage de chaînes la plus rapide en Python. Voici une comparaison :

    MethodSyntax ExampleRelative SpeedReadability
    f-stringf"{name} is {age}"1.0x (fastest)Excellent
    str.format()"{} is {}".format(name, age)1.5-2x slowerGood
    % formatting"%s is %d" % (name, age)1.3-1.8x slowerFair
    Concatenationname + " is " + str(age)1.2-1.5x slowerPoor

    Voici un benchmark pratique que vous pouvez exécuter :

    import timeit
 
name = "Alice"
age = 30
 
# f-string
fstring_time = timeit.timeit(
    'f"{name} is {age} years old"',
    globals=globals(),
    number=1000000
)
 
# str.format()
format_time = timeit.timeit(
    '"{} is {} years old".format(name, age)',
    globals=globals(),
    number=1000000
)
 
# % formatting
percent_time = timeit.timeit(
    '"%s is %d years old" % (name, age)',
    globals=globals(),
    number=1000000
)
 
# Concatenation
concat_time = timeit.timeit(
    'name + " is " + str(age) + " years old"',
    globals=globals(),
    number=1000000
)
 
print(f"f-string: {fstring_time:.4f}s")
print(f"format(): {format_time:.4f}s ({format_time/fstring_time:.2f}x)")
print(f"% format: {percent_time:.4f}s ({percent_time/fstring_time:.2f}x)")
print(f"concat: {concat_time:.4f}s ({concat_time/fstring_time:.2f}x)")
 
# Typical output:
# f-string: 0.0523s
# format(): 0.0891s (1.70x)
# % format: 0.0734s (1.40x)
# concat: 0.0612s (1.17x)

    L’avantage de performance devient plus significatif avec des opérations de formatage complexes et dans des boucles traitant de grands jeux de données.

    Comparaison : f-strings vs format() vs formatage %

    Comprendre quand utiliser chaque méthode vous aide à écrire un meilleur code Python :

    Featuref-stringstr.format()% Formatting
    Python Version3.6+2.7+All versions
    ReadabilityExcellent - expressions inlineGood - numbered placeholdersFair - separate tuple
    PerformanceFastestSlowerModerate
    Arbitrary ExpressionsYesLimitedNo
    Positional ArgsDirectYesYes
    Named ArgsDirectYesYes
    ReusabilityNoYesYes
    Type SafetyRuntimeRuntimeRuntime
    DebuggingExcellent (with =)FairPoor
    # Same output, different approaches
name = "Bob"
score = 95.5
rank = 3
 
# f-string (modern, recommended)
f_result = f"{name} scored {score:.1f} and ranked #{rank}"
 
# str.format() (good for templates)
format_result = "{} scored {:.1f} and ranked #{}".format(name, score, rank)
 
# % formatting (legacy)
percent_result = "%s scored %.1f and ranked #%d" % (name, score, rank)
 
# All produce: "Bob scored 95.5 and ranked #3"
 
# Where format() excels: reusable templates
template = "Student: {name}, Score: {score:.1f}, Rank: {rank}"
result1 = template.format(name="Alice", score=92.3, rank=5)
result2 = template.format(name="Charlie", score=88.7, rank=8)

    Erreurs courantes et pièges

    Échapper les accolades

    Pour inclure des accolades littérales dans des f-strings, doublez-les :

    # Wrong - causes SyntaxError
# result = f"Use {curly braces} in f-strings"
 
# Correct - double the braces
result = f"Use {{curly braces}} in f-strings"
print(result)
# Output: Use {curly braces} in f-strings
 
# Mixing escaped and interpolated
value = 42
formatted = f"Set value: {{{value}}}"
print(formatted)
# Output: Set value: {42}

    Backslashes dans les expressions

    Vous ne pouvez pas utiliser de backslashes dans la partie expression des f-strings :

    # Wrong - causes SyntaxError
# result = f"{'\n'.join(items)}"
 
# Correct - use a variable
newline = '\n'
items = ["apple", "banana", "orange"]
result = f"{newline.join(items)}"
print(result)
 
# Or use a function/method outside the f-string
result = '\n'.join(items)
final = f"Items:\n{result}"

    Correspondance des guillemets

    Faites attention aux guillemets imbriqués :

    # Wrong - quote mismatch
# message = f"{"key": "value"}"
 
# Correct - use different quote types
message = f'{{"key": "value"}}'
print(message)
# Output: {"key": "value"}
 
# Or escape inner quotes
message = f"{\"key\": \"value\"}"
print(message)
# Output: "key": "value"

    Accès aux dictionnaires dans les f-strings

    Quand vous accédez à des clés de dictionnaire, utilisez des guillemets différents de ceux de la f-string :

    data = {"name": "Alice", "score": 95}
 
# Wrong - quote conflict
# result = f"{data["name"]}"
 
# Correct - use different quotes
result = f"{data['name']} scored {data['score']}"
print(result)
# Output: Alice scored 95
 
# Alternative - use get() method
result = f"{data.get('name')} scored {data.get('score')}"

    Exemples concrets

    Messages de logging

    Les f-strings rendent le logging plus lisible et plus maintenable :

    import logging
from datetime import datetime
 
logging.basicConfig(level=logging.INFO)
 
def process_data(filename, records):
    start_time = datetime.now()
 
    logging.info(f"Starting processing: {filename}")
 
    # Simulate processing
    success = records * 0.95
    failed = records - success
 
    duration = (datetime.now() - start_time).total_seconds()
 
    logging.info(
        f"Completed {filename}: "
        f"{success:.0f} successful, {failed:.0f} failed "
        f"in {duration:.2f}s "
        f"({records/duration:.0f} records/sec)"
    )
 
process_data("data.csv", 10000)
# Output: INFO:root:Completed data.csv: 9500 successful, 500 failed in 0.05s (200000 records/sec)

    Construction de chemins de fichiers

    import os
 
def create_report_path(base_dir, project, date, extension="csv"):
    filename = f"{project}_{date:%Y%m%d}_report.{extension}"
    return os.path.join(base_dir, filename)
 
from datetime import date
 
path = create_report_path(
    "/data/reports",
    "sales",
    date.today()
)
print(path)
# Output: /data/reports/sales_20260211_report.csv

    Visualisation de données avec PyGWalker

    Lorsqu’on travaille en analyse de données, les f-strings sont essentielles pour créer des noms de colonnes et des libellés dynamiques. PyGWalker, une bibliothèque Python open-source qui transforme des dataframes en visualisations interactives de type Tableau, bénéficie grandement du formatage via f-strings :

    import pandas as pd
import pygwalker as pyg
 
# Create sample data with formatted column names
categories = ["Electronics", "Clothing", "Food"]
months = ["Jan", "Feb", "Mar"]
 
data = []
for category in categories:
    for month in months:
        revenue = __import__('random').randint(1000, 5000)
        data.append({
            f"{month}_Revenue": revenue,
            f"{month}_Category": category,
            f"{month}_Growth": f"{__import__('random').uniform(-10, 30):.1f}%"
        })
 
df = pd.DataFrame(data)
 
# Generate dynamic summary
total_revenue = sum([df[f"{m}_Revenue"].sum() for m in months])
summary = f"""
Sales Dashboard Summary
{'=' * 40}
Period: {months[0]} - {months[-1]} 2026
Categories: {len(categories)}
Total Revenue: ${total_revenue:,}
Average per Category: ${total_revenue/len(categories):,.2f}
"""
 
print(summary)
 
# PyGWalker can then visualize this formatted data
# pyg.walk(df)

    Génération de rapports

    def generate_performance_report(team_data):
    report_lines = [
        "Team Performance Report",
        "=" * 50,
        ""
    ]
 
    total_score = 0
    for member in team_data:
        name = member["name"]
        score = member["score"]
        tasks = member["tasks_completed"]
        total_score += score
 
        status = "Outstanding" if score >= 90 else "Good" if score >= 75 else "Needs Improvement"
 
        report_lines.append(
            f"{name:<20} | Score: {score:>5.1f} | Tasks: {tasks:>3} | {status}"
        )
 
    avg_score = total_score / len(team_data)
 
    report_lines.extend([
        "",
        "=" * 50,
        f"Team Average: {avg_score:.1f} | Total Members: {len(team_data)}"
    ])
 
    return "\n".join(report_lines)
 
team = [
    {"name": "Alice Johnson", "score": 94.5, "tasks_completed": 28},
    {"name": "Bob Smith", "score": 87.2, "tasks_completed": 25},
    {"name": "Charlie Davis", "score": 78.9, "tasks_completed": 22},
]
 
print(generate_performance_report(team))
 
# Output:
# Team Performance Report
# ==================================================
#
# Alice Johnson        | Score:  94.5 | Tasks:  28 | Outstanding
# Bob Smith            | Score:  87.2 | Tasks:  25 | Good
# Charlie Davis        | Score:  78.9 | Tasks:  22 | Good
#
# ==================================================
# Team Average: 86.9 | Total Members: 3

    Formatage de réponses API

    def format_api_response(endpoint, status_code, response_time, data_size):
    status_emoji = "✓" if status_code == 200 else "✗"
 
    message = f"""
API Call Summary:
  Endpoint: {endpoint}
  Status: {status_code} {status_emoji}
  Response Time: {response_time*1000:.0f}ms
  Data Size: {data_size:,} bytes ({data_size/1024:.1f} KB)
  Throughput: {data_size/response_time/1024:.2f} KB/s
"""
    return message
 
print(format_api_response(
    "/api/v2/users",
    200,
    0.245,
    15680
))
 
# Output:
# API Call Summary:
#   Endpoint: /api/v2/users
#   Status: 200 ✓
#   Response Time: 245ms
#   Data Size: 15,680 bytes (15.3 KB)
#   Throughput: 62.53 KB/s

    FAQ

    Que sont les f-strings Python et quand devrais-je les utiliser ?

    Les f-strings (formatted string literals) sont un mécanisme de formatage de chaînes introduit dans Python 3.6 qui permet d’intégrer des expressions dans des littéraux de chaîne via des accolades. Vous devriez utiliser les f-strings dès que vous devez interpoler des variables ou des expressions dans des chaînes, car elles offrent le meilleur compromis entre lisibilité, performance et fonctionnalités. Elles sont idéales pour le logging, la génération de rapports, l’affichage de données et tout scénario où vous devez produire du texte formaté dynamiquement. Les f-strings sont plus rapides que les méthodes plus anciennes comme .format() ou le formatage %, et rendent votre code plus maintenable en gardant la logique de formatage au plus près des valeurs formatées.

    Comment formater des nombres avec un nombre précis de décimales dans des f-strings ?

    Pour formater des nombres avec un nombre précis de décimales dans des f-strings, utilisez le spécificateur :.Nf où N est le nombre de décimales souhaité. Par exemple, f"{value:.2f}" formate un nombre avec 2 décimales. Vous pouvez le combiner avec des séparateurs de milliers via des virgules : f"{value:,.2f}" affiche des nombres comme "1,234.56". Pour des pourcentages, utilisez le spécificateur % : f"{ratio:.1%}" convertit 0.456 en "45.6%". La notation scientifique utilise e ou E : f"{large_num:.2e}" produit une sortie comme "1.23e+09".

    Puis-je utiliser des expressions et des appels de fonctions dans des f-strings ?

    Oui, les f-strings peuvent évaluer n’importe quelle expression Python valide à l’intérieur des accolades. Cela inclut des opérations arithmétiques comme f"{x + y}", des appels de méthodes comme f"{text.upper()}", des appels de fonctions comme f"{calculate_total(values):.2f}", des compréhensions de listes, l’accès à des dictionnaires, et bien plus. Vous pouvez même imbriquer plusieurs expressions, même s’il est généralement préférable, pour la lisibilité, de sortir la logique complexe de la f-string et de l’assigner d’abord à une variable. L’expression est évaluée à l’exécution, puis le résultat est converti en chaîne et inséré dans la sortie finale.

    Qu’est-ce que le spécificateur = dans les f-strings et en quoi aide-t-il au débogage ?

    Le spécificateur =, introduit dans Python 3.8, est une fonctionnalité de débogage qui affiche à la fois l’expression et sa valeur. Quand vous écrivez f"{variable=}", la sortie devient "variable=value" au lieu de seulement "value". C’est extrêmement pratique pour le débogage car vous pouvez inspecter rapidement plusieurs variables sans retaper leur nom : f"{x=}, {y=}, {x+y=}" produit "x=10, y=20, x+y=30". Vous pouvez combiner le spécificateur = avec des options de formatage : f"{pi=:.2f}" affiche "pi=3.14". Cette fonctionnalité fait gagner du temps lors du débogage de code d’analyse de données ou de l’inspection de résultats intermédiaires.

    Comment créer des tableaux alignés et des rapports formatés avec des f-strings ?

    Pour créer des tableaux alignés avec des f-strings, utilisez des spécificateurs d’alignement après le deux-points à l’intérieur des accolades. La syntaxe est {value:fill_char align width} où align vaut < (gauche), > (droite) ou ^ (centré). Par exemple, f"{text:<15}" aligne un texte à gauche dans un champ de 15 caractères, tandis que f"{number:>10.2f}" aligne un nombre à droite avec 2 décimales dans un champ de 10 caractères. Vous pouvez utiliser des caractères de remplissage personnalisés comme f"{text:*^20}" pour centrer avec des astérisques. Pour des tableaux, combinez alignement et boucles : itérez sur vos données et formatez chaque ligne avec des largeurs de colonnes cohérentes, en ajoutant séparateurs et en-têtes pour produire des rapports au rendu professionnel avec des colonnes parfaitement alignées.

    Conclusion

    Les f-strings Python représentent le standard moderne du formatage de chaînes, en combinant d’excellentes performances et une lisibilité remarquable. En maîtrisant les techniques couvertes dans ce guide — de l’interpolation de base au formatage avancé, à l’alignement, au débogage et aux cas d’usage concrets — vous pourrez écrire du code Python plus propre, plus rapide et plus maintenable.

    La syntaxe est intuitive : préfixez votre chaîne avec 'f', intégrez des expressions entre accolades, et utilisez des spécificateurs de format pour contrôler la précision et l’alignement. Que vous formatiez des rapports financiers, journalisiez des événements applicatifs, généreriez des requêtes SQL ou affichiez des résultats d’analyse de données, les f-strings offrent la solution la plus élégante.

    Commencez dès aujourd’hui à utiliser les f-strings pour remplacer les anciennes méthodes de formatage dans votre base de code. Votre futur vous et vos coéquipiers apprécieront la clarté accrue, et vos applications bénéficieront des gains de performance. Au fur et à mesure que vous travaillerez avec des outils d’analyse comme PyGWalker ou que vous construirez des systèmes de reporting complexes, les f-strings deviendront une pièce indispensable de votre boîte à outils Python.

    📚