Formater une chaîne en Python : f-strings, format et %

En Python, la façon moderne de formater une chaîne est la f-string : on préfixe la chaîne par f et on insère variables et expressions entre accolades, comme f"Bonjour {nom}". Ce guide couvre tout le formatage de chaînes : les f-strings (variables, expressions, débogage avec {x=}), le formatage numérique (.2f, séparateurs, pourcentages, alignement), les dates, les anciennes méthodes .format() et %, et les nouvelles t-strings arrivées avec Python 3.14.

Il s'adresse aux débutants qui veulent afficher proprement des messages et des nombres, comme aux personnes qui génèrent des rapports ou des logs. Les f-strings, introduites en Python 3.6, rendent le code plus compact et lisible que les méthodes historiques. Les exemples ont été exécutés avec Python 3.12 et 3.14.

Ce que vous allez apprendre

• Écrire une f-string avec variables, expressions et appels de fonction.
• Formater des nombres : décimales (.2f), milliers, pourcentages, alignement.
• Formater des dates avec le module datetime.
• Déboguer rapidement avec la syntaxe f"{variable=}".
• Quand préférer .format() ou %, et à quoi servent les t-strings.

Historique du formatage des chaînes en Python

La méthode .format().

Introduite en Python 2.7 et améliorée en version 3, la méthode .format() a apporté une meilleure lisibilité et une plus grande flexibilité par rapport à l’opérateur %. Elle permet d’insérer des valeurs dans des chaînes de manière plus explicite en utilisant des accolades {} comme des "espaces réservés". Par exemple :

nom = "Alice"
age = 25
message = "Je m'appelle {} et j'ai {} ans".format(nom, age)
print(message)

L’approche avec .format() est plus lisible et plus puissante. Elle permet aussi d'indiquer explicitement l'ordre des variables et de formater des nombres plus facilement. Par exemple, je peux formater un nombre avec deux chiffres après la virgule :

valeur = 123.456
message = "La valeur est {:.2f}".format(valeur)
print(message)

Cependant, malgré ces améliorations, la méthode .format() peut devenir verbeuse, surtout lorsque les variables sont nombreuses ou que les expressions sont complexes. C'est dans ce contexte que les f-strings ont vu le jour.

L’opérateur %.

L'une des premières méthodes pour formater des chaînes était l’opérateur %. Elle s’inspire du langage C et permet d’insérer des variables dans une chaîne en utilisant des spécificateurs de format. Par exemple, pour insérer une chaîne et un nombre dans une autre chaîne, j'écrirais :

nom = "Alice"
age = 25
message = "Je m'appelle %s et j'ai %d ans" % (nom, age)
print(message)

Ici, %s est utilisé pour les chaînes et %d pour les entiers. Cette méthode a été largement utilisée, mais elle est parfois difficile à lire, surtout lorsqu'il faut gérer plusieurs variables ou des formats complexes.

Présentation des f-strings

Les f-strings, ou formatted string literals, ont été introduites avec Python 3.6 pour simplifier la façon dont on formate des chaînes de caractères. La syntaxe est simple : il suffit de préfixer la chaîne par un f (ou un F), puis d’insérer les variables ou les expressions à l’intérieur d’accolades {}. Cela permet d'intégrer directement des valeurs dans une chaîne, sans avoir à recourir à des méthodes comme .format() ou à l’opérateur %. Voici comment cela fonctionne.

Syntaxe de base des f-strings

La structure d’une f-string est très intuitive. Je peux intégrer des variables et des expressions à l’intérieur des accolades {}. Par exemple :

nom = "Alice"
age = 25
message = f"Je m'appelle {nom} et j'ai {age} ans"
print(message)

Dans cet exemple, la variable nom et la variable age sont directement insérées dans la chaîne de caractères. Inutile d’utiliser une méthode externe ou d’écrire du code additionnel pour formater cette chaîne.

Expressions dans les f-strings

L’un des avantages des f-strings est qu’on peut y insérer non seulement des variables, mais aussi des expressions. Par exemple, je peux effectuer des opérations mathématiques directement dans la chaîne de caractères :

largeur = 5
hauteur = 10
message = f"L'aire du rectangle est {largeur * hauteur}"
print(message)

Ici, l’expression {largeur * hauteur} est évaluée et son résultat est inséré directement dans la chaîne. Cela rend le code plus fluide et évite de devoir créer des variables intermédiaires juste pour afficher une valeur calculée.

Appels de fonctions dans les f-strings

En plus des expressions simples, je peux aussi appeler des fonctions à l’intérieur des accolades d’une f-string. Par exemple, je peux formater du texte en appelant la méthode .upper() pour mettre une chaîne en majuscules :

nom = "Alice"
message = f"Bonjour {nom.upper()}"
print(message)

Dans cet exemple, le résultat de nom.upper() est directement inséré dans la chaîne, transformant le nom en majuscules. Cela montre la flexibilité des f-strings, qui peuvent évaluer n’importe quelle expression Python.

Déboguer avec la syntaxe =

Depuis Python 3.8, ajouter un signe = après une expression dans une f-string affiche à la fois le nom et sa valeur. C'est un raccourci de débogage bien plus pratique qu'un print manuel :

prix = 123.456
print(f"{prix=}")         # prix=123.456
print(f"{prix=:.2f}")     # prix=123.46

Cette forme self-documenting évite de répéter le nom de la variable, et elle respecte le format demandé après les deux-points. Deux conversions complètent l'affichage : !r applique repr() (utile pour voir les guillemets d'une chaîne) et !s force str().

nom = "Alice"
print(f"{nom!r}")         # 'Alice'

Mélanger des types dans une f-string

Les f-strings gèrent automatiquement les conversions de type. Si j'ai un entier ou un float dans ma variable, je n’ai pas besoin de le convertir en chaîne de caractères avant de l'insérer. Par exemple :

age = 25
message = f"J'ai {age} ans"
print(message)

Je n'ai pas besoin d'utiliser str(age) pour convertir l’entier en chaîne, car Python s’en occupe automatiquement à l’intérieur de la f-string. Cela rend le code plus compact et facile à lire.

Formatage de valeurs numériques avec les f-strings

Les f-strings ne se limitent pas à l'insertion simple de variables dans des chaînes de caractères. Elles permettent également de formater des valeurs numériques de manière précise, ce qui est extrêmement utile lorsque je manipule des nombres avec des exigences spécifiques, comme le nombre de décimales, l'alignement des valeurs ou encore l'ajout de symboles comme les pourcentages ou les zéros.

Arrondir des nombres à un certain nombre de décimales

Lorsque je travaille avec des nombres à virgule flottante (les floats), il est souvent nécessaire de contrôler le nombre de décimales affichées. Grâce aux f-strings, je peux facilement le faire en ajoutant un format spécifique après les deux points : à l'intérieur des accolades.

Par exemple, pour afficher un nombre avec deux chiffres après la virgule, j’utiliserais la syntaxe suivante :

pi = 3.14159
message = f"Le nombre pi arrondi à deux décimales est {pi:.2f}"
print(message)

Ici, :.2f indique que je souhaite formater la valeur de pi avec deux chiffres après la virgule. Le résultat sera :

Le nombre pi arrondi à deux décimales est 3.14

Cette méthode est particulièrement pratique pour les rapports financiers ou scientifiques, où il est essentiel de contrôler la précision des nombres affichés.

Ajouter des séparateurs de milliers

Il est également possible d’insérer automatiquement des séparateurs de milliers pour rendre les grands nombres plus lisibles. Cela se fait simplement en ajoutant une virgule dans le format de l’accolade. Par exemple :

nombre = 1234567890
message = f"Le nombre avec des séparateurs de milliers est {nombre:,}"
print(message)

Le résultat affichera le nombre avec des espaces ou des virgules selon la configuration locale, comme ceci :

Le nombre avec des séparateurs de milliers est 1,234,567,890

Cela est utile pour afficher des sommes d'argent ou des statistiques où la lisibilité des nombres est indispensable.

Formatage des nombres avec des zéros de remplissage

Si je dois afficher un nombre en garantissant un certain nombre de chiffres, je peux utiliser les zéros de remplissage. Cela est souvent utilisé dans des cas où l'alignement est important, par exemple dans les numéros de série ou les identifiants. Voici un exemple simple où je souhaite afficher un entier sur 4 chiffres, en complétant avec des zéros à gauche si nécessaire :

numero = 42
message = f"Le numéro avec zéros de remplissage est {numero:04}"
print(message)

Le résultat sera :

Le numéro avec zéros de remplissage est 0042

Cela garantit que le nombre aura toujours au moins quatre chiffres, même si la valeur est plus petite.

Formatage des pourcentages

Les f-strings permettent également de formater des valeurs sous forme de pourcentages. Cela est particulièrement utile dans les rapports où je dois exprimer des ratios ou des proportions. Je peux ajouter le symbole % dans le format après les deux points : pour indiquer que la valeur doit être multipliée par 100 et suivie du symbole pourcentage.

Par exemple, pour afficher une proportion sous forme de pourcentage avec une seule décimale :

proportion = 0.756
message = f"Le pourcentage est {proportion:.1%}"
print(message)

Le résultat sera :

Le pourcentage est 75.6%

Cela permet de convertir directement des fractions en pourcentages tout en contrôlant le nombre de chiffres significatifs.

Alignement et largeur minimale

Les f-strings offrent également des options pour aligner les valeurs dans une chaîne de caractères. C’est utile lorsque je veux générer des tableaux ou des rapports où les nombres doivent être bien alignés. Je peux spécifier une largeur minimale pour les valeurs et les aligner à gauche (<), à droite (>) ou au centre (^).

Par exemple, si je souhaite aligner plusieurs nombres à droite dans une colonne de 10 caractères :

for i in range(1, 6):
    message = f"Le nombre est : {i:>10}"
    print(message)

Le résultat sera :

Le nombre est :          1
Le nombre est :          2
Le nombre est :          3
Le nombre est :          4
Le nombre est :          5

Cela garantit que tous les nombres seront alignés à droite dans un espace de 10 caractères, ce qui est utile pour générer des rapports lisibles et bien structurés.

Gestion des dates et heures avec les f-strings

En Python, la gestion des dates et heures est une tâche courante, que ce soit pour afficher des horodatages, générer des journaux d'activité ou formater des rapports. Les f-strings simplifient considérablement le formatage des dates en permettant d'intégrer directement les objets de type datetime dans une chaîne et de les formater selon mes besoins.

Le module datetime

Avant d’entrer dans les détails du formatage avec les f-strings, je dois d’abord rappeler que la gestion des dates et heures en Python passe par le module datetime. Il me permet de créer des objets représentant des dates et des heures, que je peux ensuite manipuler ou formater.

Voici un exemple basique pour créer une date et une heure avec ce module :

from datetime import datetime

maintenant = datetime.now()
print(maintenant)

Cela affiche la date et l’heure actuelles sous la forme d’un objet datetime, comme 2024-10-05 14:23:45.678912.

Formatage simple avec les f-strings

L’un des grands avantages des f-strings est leur capacité à formater directement les objets datetime en spécifiant le format d'affichage à l’intérieur des accolades {}. Je peux utiliser la syntaxe suivante pour afficher une date dans le format de mon choix :

from datetime import datetime

maintenant = datetime.now()
message = f"Nous sommes le {maintenant:%d/%m/%Y}"
print(message)

Dans cet exemple, je spécifie le format de la date à l’aide de :%d/%m/%Y, ce qui signifie :

• %d pour le jour du mois sur deux chiffres,
• %m pour le mois sur deux chiffres,
• %Y pour l'année sur quatre chiffres.

Le résultat sera quelque chose comme :

Nous sommes le 05/10/2024

Formatage complet : date et heure

Je peux également formater une date avec l'heure en utilisant des spécificateurs supplémentaires. Par exemple, pour afficher la date avec l'heure complète en heures, minutes et secondes, je peux écrire :

message = f"La date et l'heure actuelles sont {maintenant:%d/%m/%Y %H:%M:%S}"
print(message)

Ici, les spécificateurs :%H:%M:%S ajoutent respectivement l’heure (%H), les minutes (%M) et les secondes (%S). Le résultat serait :

La date et l'heure actuelles sont 05/10/2024 14:23:45

Cela est extrêmement pratique pour générer des horodatages dans des journaux ou des rapports.

Formats personnalisés

L’un des grands avantages du formatage avec les f-strings est la flexibilité offerte par les spécificateurs de format de datetime. Je peux créer des formats très personnalisés selon mes besoins. Par exemple, si je veux afficher la date sous la forme « Samedi, 05 Octobre 2024 », je peux le faire ainsi :

message = f"Aujourd'hui, c'est {maintenant:%A, %d %B %Y}"
print(message)

• %A affiche le nom complet du jour de la semaine,
• %B affiche le nom complet du mois.

Le résultat sera :

Aujourd'hui, c'est Samedi, 05 Octobre 2024

Je peux ajuster ces spécificateurs selon le besoin, par exemple pour raccourcir les noms des jours ou des mois avec %a pour le jour en version abrégée et %b pour le mois en version abrégée.

Manipuler des objets timedelta

Le module datetime permet aussi de travailler avec des durées, représentées par des objets timedelta. Cela me permet, par exemple, de calculer des intervalles de temps, puis d'afficher le résultat avec une f-string.

Voici comment ajouter un délai de 7 jours à la date actuelle et l'afficher :

from datetime import timedelta

dans_une_semaine = maintenant + timedelta(days=7)
message = f"Dans une semaine, nous serons le {dans_une_semaine:%d/%m/%Y}"
print(message)

Cela permet d'afficher la date d’aujourd’hui plus 7 jours, tout en utilisant le même formatage que précédemment.

Conversion de fuseaux horaires

Si je travaille avec des fuseaux horaires, je peux aussi manipuler les dates et heures avec le module pytz ou la classe timezone de Python. Voici comment afficher l'heure actuelle dans un fuseau horaire différent avec une f-string :

from datetime import timezone

utc = maintenant.astimezone(timezone.utc)
message = f"L'heure actuelle en UTC est {utc:%Y-%m-%d %H:%M:%S %Z}"
print(message)

Le spécificateur %Z permet d'afficher le nom du fuseau horaire (UTC dans ce cas).

Avantages des f-strings

Les f-strings sont rapidement devenues l'outil préféré des développeurs en Python pour le formatage des chaînes de caractères. Elles offrent plusieurs avantages par rapport aux méthodes plus anciennes, comme l’opérateur % ou la méthode .format(). Voici pourquoi elles sont si efficaces :

Syntaxe compacte et simple

L'un des principaux atouts des f-strings est leur simplicité. Au lieu d'utiliser des structures complexes ou de devoir appeler des méthodes externes, je peux simplement insérer des variables ou des expressions à l'intérieur des accolades {}. Cela réduit considérablement le nombre de lignes de code et améliore la lisibilité.

Par exemple :

nom = "Alice"
age = 25
message = f"Je m'appelle {nom} et j'ai {age} ans"

Cette syntaxe concise réduit les risques d’erreurs et permet une écriture plus rapide.

Lisibilité accrue

Les f-strings rendent le lien entre les variables et leur place dans la chaîne clair et direct. Contrairement à .format() ou %, elles permettent d'insérer des expressions directement dans la chaîne, ce qui simplifie la compréhension du code.

Performance améliorée

Les f-strings sont évaluées au moment de la compilation, ce qui les rend légèrement plus performantes que .format() ou %. Cela est particulièrement utile dans des boucles ou des traitements à grande échelle.

Prise en charge des types complexes

Les f-strings gèrent automatiquement les conversions de types, qu'il s'agisse d’un entier, d’un float ou même d’un objet plus complexe. Par exemple :

age = 25
pi = 3.14159
message = f"J'ai {age} ans et pi vaut {pi:.2f}"

Flexibilité et dynamisme

Les f-strings permettent d'insérer des expressions dynamiques ou des appels de fonctions directement dans les accolades, offrant une grande flexibilité pour manipuler les données en temps réel.

Limites des f-strings

Bien que les f-strings en Python soient un outil puissant et flexible pour formater les chaînes de caractères, elles ont aussi certaines limites. Les connaître évite des erreurs et indique dans quels cas une autre méthode de formatage est plus adaptée. Bonne nouvelle : plusieurs de ces limites ont été levées par la suite, et les t-strings de Python 3.14 répondent aux plus gênantes.

Pas d'évaluation différée

Les f-strings sont évaluées au moment de la compilation, ce qui signifie qu'elles ne peuvent pas être modifiées après leur création. Contrairement à d’autres méthodes de formatage, comme les templates ou les chaînes de substitution classiques, je ne peux pas retarder l’évaluation des valeurs à insérer dans une f-string.

Voici un exemple qui ne fonctionne pas :

nom = "Alice"
# Ceci provoque une erreur, car f"..." est évalué directement à la création
template = f"Bonjour {nom}"
nom = "Bob"
print(template)

Le résultat sera toujours Bonjour Alice, même si nom a été modifié après la création de la f-string. L’évaluation est immédiate et je ne peux pas la retarder, contrairement à l’opérateur % ou à .format(), qui évaluent au moment où je les appelle.

Incompatibilité avec certaines bibliothèques

Certains environnements ou bibliothèques ne permettent pas l’utilisation directe des f-strings, surtout dans des contextes où des chaînes de formatage doivent être générées dynamiquement. Par exemple, certaines bibliothèques de traduction ou de localisation nécessitent des chaînes de format spécifiques avec des clés ou des variables, ce qui peut poser problème avec les f-strings.

Prenons un exemple avec une chaîne traduite :

# Imaginons une bibliothèque de traduction où les variables sont définies dans les chaînes
message = f"Hello, {nom}"

Dans ce cas, je ne peux pas utiliser directement des f-strings car la variable doit être remplacée plus tard, après que la traduction a été générée. Les f-strings ne permettent pas de conserver un "gabarit" de chaîne pour une évaluation ultérieure.

Impossible de contenir des accolades non échappées

Les f-strings utilisent les accolades {} pour insérer des expressions ou des variables dans une chaîne. Cela signifie que si je veux afficher des accolades littérales dans une f-string, je dois les échapper en doublant les accolades. Cela peut être source de confusion, surtout si je travaille avec des langages de programmation ou des formats de données qui utilisent aussi les accolades, comme le JSON ou d’autres formats de configuration.

Par exemple :

# Si je veux afficher des accolades, je dois les doubler
message = f"Voici une accolade {{}}"
print(message)

Le résultat sera :

Voici une accolade {}

Si je ne double pas les accolades, Python tentera d’évaluer ce qui se trouve à l’intérieur, ce qui provoquera une erreur si ce n’est pas une expression valide.

Pas de formatage avancé des chaînes multilignes

Les f-strings fonctionnent très bien pour formater des chaînes simples, mais dès que j’essaie de manipuler des chaînes multilignes ou des blocs de texte complexes, elles peuvent devenir peu pratiques. Je peux toujours utiliser des triples guillemets pour gérer plusieurs lignes, mais les f-strings ne gèrent pas nativement des blocs complexes avec indentation.

Par exemple, si j’essaie d'insérer des variables dans un texte multilignes :

nom = "Alice"
message = f"""
Bonjour {nom},
Bienvenue dans notre programme. Nous espérons que vous apprécierez votre expérience.
"""
print(message)

Ce code fonctionne, mais si je dois manipuler des blocs de texte plus complexes, d’autres méthodes comme .format() ou l’utilisation d’un système de template peuvent être plus adaptées pour un meilleur contrôle de l’affichage.

Compatibilité avec les versions de Python antérieures à 3.6

Les f-strings ne sont disponibles qu'à partir de Python 3.6. Si je dois écrire du code compatible avec des versions plus anciennes de Python, je ne pourrai pas utiliser cette fonctionnalité. Dans ce cas, je devrais revenir aux anciennes méthodes comme .format() ou l'opérateur %.

Par exemple, ce code ne fonctionnera pas sous Python 2.7 :

nom = "Alice"
message = f"Bonjour {nom}"

Pour assurer la compatibilité, je devrais écrire :

message = "Bonjour {}".format(nom)

C'est un point important à considérer si je dois maintenir du code qui doit tourner sur des environnements Python plus anciens.

Pas de mise en forme conditionnelle sophistiquée

Les f-strings ne permettent pas de gérer des formatages conditionnels complexes directement dans les accolades. Bien que je puisse écrire des conditions simples dans les f-strings (comme montré précédemment), des scénarios plus avancés nécessitent une préparation plus poussée en dehors de la chaîne.

Par exemple, si je veux changer dynamiquement le format en fonction d’une condition :

condition = True
message = f"Valeur: {10:.2f}" if condition else f"Valeur: {10}"

Ce type de condition fonctionne, mais dès que les règles de formatage deviennent plus complexes, il vaut mieux gérer cela en dehors de la f-string pour ne pas compliquer la lecture du code.

Ce que les versions récentes ont changé

Le formatage de chaînes a continué d'évoluer après Python 3.6. Deux évolutions valent d'être connues.

PEP 701 : des f-strings plus souples (Python 3.12)

Jusqu'à Python 3.11, les f-strings imposaient plusieurs restrictions : impossible de réutiliser à l'intérieur le même type de guillemets que ceux qui délimitent la chaîne, ni d'y placer un antislash. Python 3.12 (PEP 701) a levé ces limites. On peut désormais écrire sans jongler avec les guillemets :

data = {"ville": "Lyon"}
print(f"Ville : {data["ville"]}")   # valide depuis 3.12

Auparavant, il fallait alterner guillemets simples et doubles. Sur du code destiné à des versions plus anciennes, gardez l'ancienne prudence.

t-strings : le formatage différé et sûr (Python 3.14)

La principale limite des f-strings est qu'elles produisent immédiatement une chaîne : impossible de traiter les valeurs avant qu'elles ne soient fusionnées dans le texte. C'est précisément ce que résolvent les t-strings (template strings), introduites par la PEP 750 en Python 3.14.

Une t-string se préfixe par t et produit non pas une str, mais un objet Template :

from string.templatelib import Interpolation

nom = "Alice"
template = t"Bonjour {nom}"
type(template)          # string.templatelib.Template

L'intérêt : on accède séparément aux parties statiques et aux interpolations, pour appliquer un traitement adapté avant le rendu. C'est la base d'un échappement contextuel sûr, par exemple pour neutraliser une injection HTML ou SQL :

from html import escape
from string.templatelib import Interpolation

def rendre_html(template):
    parties = []
    for element in template:
        if isinstance(element, Interpolation):
            parties.append(escape(str(element.value)))   # valeur échappée
        else:
            parties.append(element)                       # texte statique
    return "".join(parties)

saisie = '<script>alert("xss")</script>'
print(rendre_html(t"<p>{saisie}</p>"))
# <p>&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;</p>

f-string ou t-string ?

Pour afficher une valeur, la f-string reste le bon choix, simple et direct. La t-string vise les cas où l'on doit traiter les valeurs avant le rendu : sécurité (anti-injection), internationalisation, gabarits réutilisables. Elle demande Python 3.14 et une fonction de rendu ; ne l'utilisez pas là où une f-string suffit.

Contrôle de connaissances

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

5 questions

3 min.

80% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

À retenir

• La f-string (f"...", Python 3.6+) est la méthode moderne : on insère variables et expressions entre accolades.
• Le format se place après les deux-points : :.2f (décimales), :, (milliers), :.1% (pourcentage), :>10 (alignement).
• On formate un objet datetime directement dans la f-string avec les codes %d/%m/%Y %H:%M.
• f"{x=}" (Python 3.8) affiche nom et valeur : un raccourci de débogage précieux.
• .format() garde son intérêt quand le gabarit précède les valeurs ; % est l'ancienne méthode, à éviter sur du code neuf.
• Python 3.12 (PEP 701) a assoupli les f-strings ; Python 3.14 ajoute les t-strings pour un formatage différé et sûr.
• Les f-strings sont évaluées immédiatement : elles ne conviennent pas à un gabarit réutilisé ou à l'i18n, où l'on passe aux t-strings.

FAQ : formater une chaîne en Python

Qu'est-ce qu'une f-string en Python ?

Une f-string est une chaîne préfixée par f dans laquelle on insère directement des variables ou expressions entre accolades, par exemple f"Bonjour {nom}". Introduites en Python 3.6, elles remplacent .format() et l'opérateur % : plus lisibles et plus concises.

Comment afficher un nombre avec 2 décimales en Python ?

Ajoutez le format :.2f après la variable dans une f-string : f"{prix:.2f}". Le 2 indique le nombre de décimales et f le type flottant. La même syntaxe fonctionne avec .format() : "{:.2f}".format(prix). On peut combiner avec un séparateur de milliers, par exemple :,.2f.

Quelle différence entre une f-string et .format() ?

Les deux insèrent des valeurs avec la même syntaxe de format. La f-string évalue sur place : plus lisible et plus rapide. .format() sépare le gabarit des valeurs, utile quand la chaîne est définie avant de connaître les valeurs.

Comment déboguer une variable avec une f-string ?

Ajoutez un signe = après le nom dans les accolades : f"{prix=}" affiche prix=123.46. Introduite en Python 3.8, cette syntaxe self-documenting montre à la fois le nom et la valeur, idéale pour le débogage. On peut y ajouter un format : f"{prix=:.2f}".

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

Doublez les accolades : f"{{}}" affiche {}. Une accolade simple est interprétée comme le début d'une expression à évaluer. Le doublage indique à Python d'afficher l'accolade telle quelle, ce qui est utile quand on génère du JSON ou du code contenant des accolades.

Qu'est-ce qu'une t-string (template string) en Python 3.14 ?

Une t-string, préfixée par t, produit un objet Template au lieu d'une chaîne : l'évaluation est différée et on accède séparément aux parties statiques et aux interpolations. Cela permet un échappement contextuel sûr (HTML, SQL) et l'i18n, là où une f-string produit du texte.

Prochaines étapes

Le formatage sert surtout à afficher, journaliser ou produire des fichiers. Voici les sujets qui s'y rattachent directement.

Manipuler des chaînes avec le slicing Découper et extraire des sous-chaînes avec la notation par tranches.

Journaliser avec logging Produire des logs formatés plutôt que des print() éparpillés.

Lire et écrire des fichiers Écrire des rapports et des fichiers texte formatés.

Les expressions régulières Rechercher et extraire des motifs dans du texte.

×

📖 Voir la documentation →