Formatage de chaînes Python

Le formatage de chaînes vous permet de construire des chaînes dynamiquement en insérant des variables, des expressions et des valeurs calculées dans un modèle. Python propose trois approches distinctes — l'opérateur % hérité, la méthode polyvalente str.format() et la syntaxe moderne des f-strings — chacune avec ses propres atouts et cas d'utilisation appropriés.

Ce chapitre couvre :

• Quand utiliser chaque méthode de formatage et pourquoi
• L'opérateur % (hérité, encore courant dans les journaux et les bases de code anciennes)
• str.format() avec des espaces réservés positionnels et nommés
• Les f-strings (l'approche moderne recommandée)
• Les spécificateurs de format : largeur, alignement, précision, remplissage, signe et base
• Le formatage des nombres, pourcentages, dates et heures
• Les pièges courants et cas limites

Pour une exploration approfondie des f-strings en particulier — y compris les expressions, la logique conditionnelle et les améliorations de Python 3.12 — consultez le chapitre Python f-Strings.

Quelle méthode devez-vous utiliser ?

Sauf si vous maintenez du code Python 2 ou une ancienne base de code Python 3, utilisez les f-strings. Elles sont évaluées à l'exécution, ne produisent aucune surcharge d'appel supplémentaire et gardent le nom de la variable là où il apparaît dans la chaîne.

L'opérateur % (formatage hérité)

L'opérateur % substitue des valeurs dans une chaîne de format en utilisant des spécificateurs de conversion de style C.

Spécificateurs de conversion courants :

Largeur et précision avec %

Vous pouvez contrôler la largeur du champ et la précision décimale directement dans le spécificateur :

pi = 3.14159265
print("%10.3f" % pi)   # right-aligned in a 10-char field, 3 decimal places
#      3.142
print("%-10.3f|" % pi) # left-aligned
# 3.142     |
print("%010.3f" % pi)  # zero-padded
# 000003.142

Piège : valeur unique ou tuples

Lors de la substitution d'une valeur unique, passer un tuple est l'approche sûre :

value = "hello"
# Risky — if value were itself a tuple, this would fail:
# print("Got: %s" % value)

# Safe:
print("Got: %s" % (value,))
# Got: hello

str.format() — Formatage flexible avec espaces réservés

La méthode str.format() a remplacé l'opérateur % dans Python 2.6+. Elle utilise {} comme espaces réservés et prend en charge les arguments positionnels, indexés et nommés.

Espaces réservés positionnels et indexés

Espaces réservés nommés (par mot-clé)

Les espaces réservés nommés rendent les chaînes de format auto-documentées et sont particulièrement utiles lorsque la même valeur apparaît plusieurs fois ou lorsque la chaîne de format provient d'un fichier de configuration.

Réutilisation des chaînes de format

Comme str.format() prend une chaîne en entrée, vous pouvez stocker le modèle dans une variable et le réutiliser :

template = "Hello, {name}! You have {count} new messages."
print(template.format(name="Alice", count=3))
print(template.format(name="Bob", count=0))
# Hello, Alice! You have 3 new messages.
# Hello, Bob! You have 0 new messages.

f-Strings — Formatage Python moderne

Les f-strings (littéraux de chaîne formatés) préfixent la chaîne avec f ou F et évaluent toute expression à l'intérieur de {} à l'exécution. Disponibles à partir de Python 3.6, elles constituent l'approche recommandée pour le nouveau code.

name = "John"
age = 25
print(f"My name is {name} and I am {age} years old.")
# My name is John and I am 25 years old.

Les f-strings prennent en charge n'importe quelle expression Python valide à l'intérieur des accolades — arithmétique, appels de méthodes, conditions et plus encore :

items = ["apple", "banana", "cherry"]
print(f"Cart has {len(items)} items. First: {items[0].upper()}.")
# Cart has 3 items. First: APPLE.

x = -7
print(f"Absolute value: {abs(x)}")
# Absolute value: 7

Consultez Python f-Strings pour le guide complet, y compris le débogage avec =, les f-strings multilignes et les améliorations de Python 3.12.

Spécificateurs de format : le mini-langage

str.format() et les f-strings utilisent le même mini-langage de spécification de format à l'intérieur des {} après un deux-points :

{[field_name]:[fill][align][sign][#][0][width][grouping][.precision][type]}

Le tableau ci-dessous présente les options les plus utiles :

Alignement et largeur

text = "hello"
print(f"{text:<10}|")   # left-aligned in 10-char field
# hello     |
print(f"{text:>10}|")   # right-aligned
#      hello|
print(f"{text:^10}|")   # centered
#   hello   |
print(f"{text:*^10}|")  # centered, filled with *
# **hello***|

Les mêmes spécificateurs d'alignement fonctionnent avec str.format(). Voici un exemple combinant alignement et précision :

Formatage des nombres

x = 123.456789

print(f"{x:.2f}")        # two decimal places
# 123.46

print(f"{x:,.2f}")       # thousands separator, two decimal places
# 123.46

print(f"{x:+.2f}")       # explicit plus sign for positive numbers
# +123.46

print(f"{x:10.2f}")      # right-aligned in a 10-char field
#     123.46

print(f"{x:<10.2f}|")    # left-aligned
# 123.46    |

print(f"{x:010.2f}")     # zero-padded to 10 characters
# 0000123.46

Grands nombres et pourcentages

population = 8_100_000_000
print(f"{population:,}")    # comma separator
# 8,100,000,000

print(f"{population:_}")    # underscore separator (Python 3.6+)
# 8_100_000_000

ratio = 0.8567
print(f"{ratio:.1%}")       # percentage, one decimal place
# 85.7%

Bases des entiers

n = 255
print(f"{n:d}")   # decimal (default)
# 255
print(f"{n:x}")   # lowercase hexadecimal
# ff
print(f"{n:X}")   # uppercase hexadecimal
# FF
print(f"{n:#x}")  # hex with 0x prefix
# 0xff
print(f"{n:o}")   # octal
# 377
print(f"{n:b}")   # binary
# 11111111
print(f"{n:#b}")  # binary with 0b prefix
# 0b11111111

Vous pouvez également utiliser les mêmes spécificateurs avec str.format() :

Notation scientifique

avogadro = 6.02214076e23
print(f"{avogadro:.3e}")   # scientific notation, 3 decimal places
# 6.022e+23

print(f"{avogadro:.3E}")   # uppercase E
# 6.022E+23

print(f"{avogadro:.3g}")   # general: compact form, removes trailing zeros
# 6.02e+23

Formatage de chaînes avec format() et les f-Strings

Les trois approches produisent le même résultat pour une substitution simple :

Les spécificateurs propres aux chaînes permettent de contrôler la troncature et le rembourrage :

s = "Python"
print(f"{s:.3}")      # truncate to 3 characters
# Pyt

print(f"{s:10}")      # pad to width 10 (left-aligned by default for strings)
# Python    

print(f"{s:>10}")     # right-aligned
#     Python

print(f"{s:*^12}")    # centered, filled with *
# ***Python***

Formatage des dates et heures

Utilisez les codes de format strftime à l'intérieur des accolades lors du formatage d'objets datetime avec des f-strings ou str.format() :

import datetime

date = datetime.datetime(2024, 3, 15, 10, 30, 0)

# Default string representation
print(f"Default: {date}")
# Default: 2024-03-15 10:30:00

# strftime codes inside the format spec
print(f"Formatted: {date:%B %d, %Y}")
# Formatted: March 15, 2024

print(f"Time only: {date:%H:%M:%S}")
# Time only: 10:30:00

print(f"ISO-style: {date:%Y-%m-%d}")
# ISO-style: 2024-03-15

La même syntaxe fonctionne avec str.format() :

import datetime
date = datetime.datetime(2024, 3, 15, 10, 30, 0)
print("The date is {:%B %d, %Y}".format(date))
# The date is March 15, 2024

Pour le formatage avancé des dates, consultez le chapitre Python Modify Strings qui couvre les techniques de manipulation de chaînes.

Techniques avancées

Expressions imbriquées dans les f-Strings

Les f-strings vous permettent de calculer le spécificateur de format dynamiquement :

width = 10
precision = 3
value = 3.14159

print(f"{value:{width}.{precision}f}")
# output:      3.142  (right-aligned in a 10-char field, 3 decimal places)

Spécificateur de format avec format() et variables

La même technique fonctionne avec str.format() en utilisant des {} imbriquées :

width = 8
print("{:{width}}".format("left", width=width))
# left    

Formatage conditionnel dans les f-Strings

Comme les f-strings évaluent n'importe quelle expression, vous pouvez utiliser des expressions conditionnelles en ligne :

score = 73
label = f"{'pass' if score >= 60 else 'fail'}"
print(f"Score {score}: {label}")
# Score 73: pass

Débogage avec = (Python 3.8+)

Ajoutez = à l'intérieur d'une f-string pour afficher à la fois l'expression et sa valeur — très utile pour le débogage :

x = 42
y = x * 2
print(f"{x=}, {y=}")
# x=42, y=84

Pièges courants

1. Échappement des accolades. Pour inclure un { ou } littéral dans une chaîne formatée, doublez-le :

print(f"Use {{curly braces}} in f-strings")
# Use {curly braces} in f-strings

2. Guillemets à l'intérieur des f-strings. Dans Python 3.11 et versions antérieures, l'expression à l'intérieur de {} ne peut pas utiliser le même type de guillemet que la f-string externe :

names = ["Alice", "Bob"]
# Wrong in Python <= 3.11:
# print(f"First: {names[0].upper()}")  -- this is fine
# print(f"{'Alice'.upper()}")          -- single quotes inside double-quoted f-string is fine
# But nesting the same quotes fails:
# print(f"{names["Alice"]}")           -- SyntaxError in <= 3.11

# Safe approach for <= 3.11:
key = "Alice"
print(f"{key.upper()}")
# ALICE

3. Le piège du tuple avec %. Lors de l'utilisation du formatage % avec une valeur unique qui est elle-même un tuple, encapsulez-la :

coords = (10, 20)
# This raises TypeError because % sees a 2-element tuple:
# print("Position: %s" % coords)

# Fix: wrap in a 1-element tuple
print("Position: %s" % (coords,))
# Position: (10, 20)

4. str.format() et la sécurité. Ne transmettez jamais une entrée utilisateur non fiable comme chaîne de format à str.format() — un modèle malveillant peut accéder aux attributs des objets et divulguer des données. Les f-strings sont toujours des chaînes codées en dur, elles ne sont donc pas vulnérables à cela.

Comparaison pratique

Voici le même résultat produit par les trois méthodes côte à côte :

item = "widget"
qty = 42
unit_price = 4.5

# % operator
print("%-12s %4d  $%7.2f" % (item, qty, unit_price))

# str.format()
print("{:<12} {:>4}  ${:>7.2f}".format(item, qty, unit_price))

# f-string
print(f"{item:<12} {qty:>4}  ${unit_price:>7.2f}")

# All print:
# widget         42  $   4.50

Résumé

• Utilisez les f-strings pour le nouveau code Python 3.6+ : elles sont les plus lisibles et les plus rapides.
• Utilisez str.format() lorsque vous avez besoin d'une chaîne de modèle réutilisable ou devez prendre en charge Python 2.6+.
• Utilisez % uniquement dans le code hérité ou lorsque vous travaillez avec le module logging (qui diffère le formatage jusqu'à ce que l'entrée du journal soit réellement émise).
• Le mini-langage de spécification de format (width, precision, align, fill, type) s'applique de la même manière à str.format() et aux f-strings.

Chapitres associés :

• Python f-Strings — exploration approfondie des expressions f-string et des fonctionnalités de Python 3.12
• Python Strings — bases des chaînes, indexation et découpage
• Modify Strings — méthodes intégrées des chaînes
• Escape Characters — caractères spéciaux dans les chaînes

Pratique