Le formatage de texte en Python

Dans tous les langages de programmation, on doit afficher des informations sous forme de texte. Cela ne pose pas de difficultés lorsque l'on souhaite afficher une variable de texte. Mais qu'en est-il lorsque l'on souhaite afficher des nombres avec un certain nombre de chiffres après la virgule ? Comment afficher 5 variables à la suite sans écrire des dizaines de + ?

Le formatage de texte en Python permet justement de mettre en forme dynamiquement une chaîne de caractères avec des variables. Après avoir lu cet article, plus besoin d'utiliser les + à répétitions dans les codes Python ! 😉

Formatage de variables

Prenons une exemple simple où l'on souhaite afficher le message Bonjour X !, avec x le nom d'une personne. Sans formatage, nous n'aurions pas d'autre choix que d'utiliser la concaténation de chaînes de caractères.

prenom = "Jean"
"Bonjour " + prenom + " !"

Bonjour Jean !

Tout fonctionne, mais on se doute bien que cela va commencer à être moins lisible si l'on utilise plusieurs variables.

prenom = "Jean"
nom = "Dupont"
"Bonjour " + prenom + " " + nom + " !"

Bonjour Jean Dupont !

Ce qui rend la lisibilité difficile, c'est lorsque l'on doit insérer des espaces entre des variables, comme ici + " " +.

À lire aussi : découvrez notre formation MLOps

Lorsque l'on utilise des chaînes de caractères en Python, il y a une fonction déjà présente format, qui comme son nom l'indique, va formater le contenu d'une chaîne de caractères.

Cette chaîne va contenur des arguments, représentés par des accolades {}. Dans la fonction format, on indique ensuite les variables qui remplaceront les accolades dans le même ordre.

prenom = "Jean"
nom = "Dupont"
"Bonjour {} {} !".format(prenom, nom)

Bonjour Jean Dupont !

C'est tout de suite beaucoup plus lisible. Si l'on ne souhaite pas utiliser l'ordre des accolades, il est possible d'utiliser des noms dans les accolades pour référencer les valeurs à remplacer dans format.

prenom = "Jean"
nom = "Dupont"
"Bonjour {p} {n} !".format(n=nom, p=prenom)

Bonjour Jean Dupont !

Formatage de nombres

Le formatage de nombre permet de spécifier la façon dont ils sont affichés et représentés dans des chaînes de caractères. Il y a plusieurs situations où l'on souhaite par exemple avoir au minimum trois chiffres pour représenter un nombre (de 000 à 999), conserver un décalage à gauche si le nombre a une taille d'affichage trop petite, etc.

Nombres entiers

Pour afficher des nombres entiers, on utilise l'identifiant d (pour digit). Dans sa façon la plus simple, la représentation d'un nombre entier sans modification s'écriut {:d}.

"{:d}".format(54)

54

Maintenant, supposons qu'il est nécessaire de créer des fichiers fichier-001.csv, fichier-002.csv. Comment allons nous conserver le format fichier-XXX.csv, avoir obligatoirement trois chiffres, même si le nombre est plus petit que 100 ?

Dans ce cas, il faut spécifier 0n avant le d, n étant le nombre de chiffres au minimum. Ainsi, si l'on formate le nombre 8 avec {:03d}, alors le nombre sera formaté en 008.

for i in range(0, 120, 8):
  print("{:03d}".format(i))

000
008
016
024
032
040
048
056
064
072
080
088
096
104
112

À noter que si l'on ne souhaite pas de 0 mais des espaces à la place, il suffit d'omettre le chiffre 0 dans le formatage.

for i in range(0, 120, 8):
  print("{:3d}".format(i))

  0
  8
 16
 24
 32
 40
 48
 56
 64
 72
 80
 88
 96
104
112

Si l'on regarde bien, il y a deux espaces avant les nombres 0 et 8, car le symbole 3d indique qu'il doit y avoir obligatoirement au moins 3 caractères. Bien sûr, si le nombre comporte plus de 3 chiffres, l'intégralité de celui-ci sera affiché.

Nombres à virgules

Très souvent, lorsque l'on manipule des nombres à virgules, on se retrouve avec beaucoup de chiffres après la virgule. Le formatage est particulièrement utile pour limiter l'écriture des chiffres après la virgule.

Pour les nombres avec virgules, on utilise l'identifiant f (pour flottant). On retrouve les mêmes propriétés que pour les nombres entiers, à la différence où l'on peut maintenant utiliser le caractère . comme séparateur des chiffres avant et après la virgule.

"{:2.1f}".format(85.456984155)

85.5

Le format {:2.1f} se lit comme ceci.

• On affiche au moins deux chiffres avant la virgule.
• Le délimiteur de la virgule ici est un point.
• Après la virgule, on affiche au maximum un chiffre.

Attention, la virgule est utilisée pour séparer les milliers, millions, etc. Dans l'écriture suivant, on adopte notamment l'écriture américaine des nombres.

"${:,.2f}".format(130542.125)

$130,542.12

Formatage de collections

Outre les nombres, on souhaite aussi formater des listes ou des dictionnaires. Pour le formatage de liste, on retrouve le même principe que le formatage classique, à savoir où l'on va référencer les différents éléments de la liste qui seront ensuite remplacés selon leur ordre.

"{} {} {}".format(*[0, "a", 2.3])

0 a 2.3

La présence de l'étoile * permet d'indiquer que l'on passe chaque élément de la liste en tant que paramètre en conservant la position, permettant de remplacer chaque accolade par l'élément correspondant.

Prenons le cas des dictionnaires.

person = {
    "prenom": "Jean",
    "nom": "Dupont",
    "age": 54
}

Supposons que l'on souhaite afficher chacune des informations dans une chaîne de caractère. On pourrait tout à fait utiliser la méthode classique de référencement par position.

À lire aussi : découvrez notre formation MLOps

"Je m'appelle {} {} et j'ai {:d} ans.".format(
    person["prenom"],
    person["nom"],
    person["age"]
)

Je m'appelle Jean Dupont et j'ai 54 ans.

On se rend compte que cette écriture est un peu lourde : il faut à chaque fois référence le dictionnaire person, et ensuite accéder à la clé que l'on souhaite. Étant donné que l'on accès tout le temps au même dictionnaire, n'y a-t-il pas moyen d'être plus efficace ?

C'est maintenant que la magie opère. Sous Python, il est possible de référencer une clé d'un dictionnaire dans un formatage de texte. Ensuite, on spécifie dans le format le dictionnaire dépilé **person.

"Je m'appelle {prenom} {nom} et j'ai {age} ans.".format(**person)

Je m'appelle Jean Dupont et j'ai 54 ans.

Il n'y a pas de magie derrière, mais un formatage que l'on connait déjà. L'opération **person est particulière, car elle va transformer un dictionnaire en une liste d'arguments de fonctions clé=valeur.

Autrement dit, l'écriture **person est identique à l'écriture suivante.

"Je m'appelle {prenom} {nom} et j'ai {age} ans.".format(
    prenom=person["prenom"],
    nom=person["nom"],
    age=person["age"]
)

Je m'appelle Jean Dupont et j'ai 54 ans.

On le conviendra, c'est plus rapide est plus propre d'utiliser les doubles *.

Les f-string

Les f-string sont apparus avec les récentes versions de Python 3 (> 3.6). Les f-string permettent d'afficher des variables directement dans le texte sans utiliser format.

prenom = "Jean"
nom = "Dupont"
f"Je m'appelle {prenom} {nom} et j'ai {51} ans !"

Je m'appelle Jean Dupont et j'ai 51 ans !

Elles sont intéressantes dans les situations où l'on ne doit pas faire de formatage particulier, comme sur des nombres. L'opérateur f placé devant la chaîne de caractère va donc remplacer chaque accolade par la variable qui correspond.

Attention néanmoins, il faut vérifier que la variable renseignée est bien définie.

f"J'habite à {ville} !"

NameError                                 Traceback (most recent call last)
<ipython-input-63-cfe2d6a664c6> in <module>()
> 1 f"J'habite à {ville} !"

NameError: name 'ville' is not defined

Conclusion

Ces quelques exemples simplifient le développement en Python, car elles vont permettent de rendre le code lisible à l'aide d'une écriture plus concise, tout en offrant des fonctionnalités très intéressantes sur le formatage des variables, des nombres et des collections.

Pour plus de détails concernant le formatage de texte en Python, cette page regorge d'exemples très intéressants.