Formatage de chaînes

Le formatage de chaînes permet d'incorporer des valeurs de variables dans du texte. Python offre trois approches : l'opérateur % hérité, la méthode polyvalente str.format(), et la syntaxe moderne des f-strings introduite dans Python 3.6. Chacune produit le même résultat pour les cas simples, mais elles diffèrent en termes de puissance, de lisibilité et de version Python requise.

Ce chapitre couvre :

• L'opérateur % et ses codes de type
• str.format() avec des espaces réservés positionnels, indexés et nommés
• Les f-strings — expressions en ligne et le spécificateur de débogage =
• Les spécificateurs de format : largeur, alignement, précision et bases numériques
• Choisir la bonne méthode selon la situation

Chapitres associés : Les chaînes Python · Concaténer des chaînes · Caractères d'échappement · Méthodes de chaîne

L'opérateur %

L'opérateur % est le style de formatage de chaînes le plus ancien en Python, emprunté au printf du langage C. On place des codes de type dans la chaîne comme espaces réservés, puis on fournit les valeurs après le signe %.

Codes de type courants

Formatage de chaînes avec %s et %d

My name is John and I am 30 years old.

Lorsque vous avez plusieurs valeurs, passez-les dans un tuple. Les valeurs sont associées aux espaces réservés de gauche à droite :

item = "coffee"
price = 2.50
qty = 3
print("Item: %s | Price: $%.2f | Qty: %d" % (item, price, qty))

Item: coffee | Price: $2.50 | Qty: 3

Le code de format %.2f arrondit le flottant à 2 décimales.

Quand utiliser % : principalement lorsque vous travaillez avec du code très ancien ou des bases de code Python 2. Pour du nouveau code, préférez str.format() ou les f-strings.

str.format()

La méthode str.format() utilise des espaces réservés entre accolades {} et est plus flexible que %. Elle prend en charge les arguments positionnels, la réutilisation par index et les arguments nommés.

Espaces réservés positionnels

Les accolades vides {} sont remplies de gauche à droite avec les arguments passés à format() :

Formatage de chaînes avec la méthode format en Python

My name is John and I am 30 years old.

Espaces réservés par index

Placez un nombre entre les accolades pour choisir un argument spécifique. Vous pouvez également répéter le même argument :

name = "John"
age = 30
print("{0} is {1} years old and {0} likes Python.".format(name, age))

John is 30 years old and John likes Python.

Espaces réservés nommés

Utilisez des noms de mots-clés pour un formatage plus lisible. Cela vous permet également de réordonner les valeurs indépendamment de la liste d'arguments :

name = "John"
age = 30
print("{name} is {age} years old.".format(name=name, age=age))

John is 30 years old.

Vous pouvez décompresser un dictionnaire directement avec ** :

person = {"name": "Alice", "city": "London"}
print("{name} lives in {city}.".format(**person))

Alice lives in London.

f-Strings (Python 3.6+)

Les f-strings (littéraux de chaînes formatées) s'écrivent en préfixant la chaîne avec f ou F. Toute expression à l'intérieur de {} est évaluée à l'exécution et convertie en string. Elles constituent l'option la plus rapide et la plus lisible pour le code Python moderne.

Formatage de chaînes à l'aide des f-strings en Python

My name is John and I am 30 years old.

Les accolades pouvant contenir n'importe quelle expression Python valide, vous n'êtes pas limité aux simples noms de variables :

x = 10
y = 3
print(f"{x} divided by {y} is {x / y:.2f}")

10 divided by 3 is 3.33

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

Ajoutez = après le nom de la variable pour afficher à la fois le nom de la variable et sa valeur — très utile pour un débogage rapide :

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

val=42, result=84

Spécificateurs de format

Les trois méthodes prennent en charge un mini-langage pour contrôler la façon dont les valeurs sont affichées. La syntaxe à l'intérieur de {} pour format() et les f-strings est :

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

Alignement et largeur

Utilisez < (gauche), > (droite) ou ^ (centre) avec un nombre de largeur :

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

|John      |
|      John|
|   John   |

Vous pouvez spécifier un caractère de remplissage avant le symbole d'alignement :

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

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

Précision décimale

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

Pi is approximately 3.14
Pi is approximately 3.1416

Formatage des nombres

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

1,234,567.89
1.234568e+06

Pour afficher un rapport sous forme de pourcentage, utilisez le spécificateur de type % :

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

85.3%

Bases entières

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

255
ff
FF
377
11111111

Les mêmes spécificateurs fonctionnent avec str.format() :

print("{:b}".format(255))   # 11111111
print("{:x}".format(255))   # ff

Remplissage avec des zéros

Complétez un entier à une largeur fixe avec des zéros non significatifs en utilisant 0 avant la largeur :

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

0000000042

Choisir la bonne méthode

Les f-strings sont la méthode recommandée par défaut pour tout nouveau code Python 3. Elles sont plus rapides que str.format() (pas de surcharge d'appel de méthode) et plus lisibles que %.

Pratique