String Format en Python

Python propose une ex­cel­lente prise en charge pour les opé­ra­tions liées aux chaînes de ca­rac­tères et le trai­te­ment de texte. Ce langage propose de nom­breuses options liées au formatage et à l’édition de textes. Découvrez avec nous les prin­ci­pales méthodes associées à String Format en Python.

À quoi servent les méthodes String Format en Python ?

En Python, les chaînes de ca­rac­tères (ou « strings ») peuvent contenir des lettres, des mots, des phrases ou des documents entiers. En pratique, il est souvent né­ces­saire d’appliquer des méthodes pour formater ces chaînes de ca­rac­tères, mais celles-ci n’ont rien à voir avec des marques visuelles, comme les ca­rac­tères gras utilisés dans Word. Mais alors, de quoi s’agit-il ?

Ces chaînes de ca­rac­tères peuvent être composées de dif­fé­rents éléments. Dans la plupart des cas, elles sont cons­ti­tuées d’un mélange d’éléments fixes et de données variables, né­ces­saire pour l’édition de données et la création de documents dans le domaine du dé­ve­lop­pe­ment Web.

Prenons par exemple le cas d’une boutique en ligne. Nous sou­hai­tons calculer le prix total des produits présents dans un panier pour en informer l’uti­li­sa­teur : « Le prix total est de […] euros ». La première solution consiste à assembler la chaîne de ca­rac­tères cor­res­pon­dante à l’aide de l’opérateur de con­ca­té­na­tion :

price = 69.42
message = "The total price is" + price + "EUR"

Nous obtenons alors un message d’erreur, car le prix s’exprime en chiffres et ne peut pas être concaténé avec une chaîne de ca­rac­tères. Il faut donc commencer par convertir ce nombre en une chaîne de ca­rac­tères en utilisant la fonction str() :

message = "The total price is" + str(price) + "EUR"

Mais tout cela peut vite prêter à confusion. Il serait cer­tai­ne­ment pré­fé­rable de définir l’ensemble du texte, ca­rac­tères gé­né­riques compris, et d’y ren­seig­ner des données. Lors de la con­ver­sion de ces données, il peut être né­ces­saire de modifier leur formatage, et c’est pré­ci­sé­ment à cette pro­blé­ma­tique que répondent les méthodes String Format Python.

Comment fonc­tion­nent les méthodes String Format Python ?

Python prend en charge plusieurs méthodes String Format, com­por­tant chacune des avantages et des in­con­vé­nients. Cette diversité s’étant renforcée au fil du temps, il existe aujourd’hui de nombreux points communs entre ces dif­fé­rentes méthodes, de même que quelques dif­fé­rences. Découvrez avec nous les quatre approches les plus connues associées à String Format Python :

1. Formatage de chaînes avec l’opérateur modulo
2. Formatage de chaînes avec la méthode str.format()
3. Formatage avec l’in­ter­po­la­tion de chaînes
4. Formatage avec des chaînes de modèle

Opérateur modulo

Ce formatage de chaînes de ca­rac­tères est le premier à avoir été intégré à Python. Il utilise l’opérateur Python du symbole de pour­cen­tage, nor­ma­le­ment utilisé pour l’opération ma­thé­ma­tique modulo. Ainsi, cette approche est également connue sous le nom de « formatage de chaînes modulo ».

Vous trouverez ci-dessous un schéma avec trois variables. Leurs noms n’ont pas vé­ri­ta­ble­ment d’im­por­tance ; nous les avons sim­ple­ment choisis de manière à rendre le code le plus com­pré­hen­sible possible.

Il faut commencer par définir le modèle comme étant la variable portant le nom « template ». Dans ce modèle, nous devons main­te­nant définir la position du ou des ca­rac­tères gé­né­riques concernés à l’aide du raccourci « %s » :

template = "The total price is %s"

Il convient ensuite de définir la valeur à insérer comme étant la variable nommée « data » :

data = 69.51

Pour appliquer la méthode Format String Python, il nous faut écrire le modèle de chaîne suivi de l’opérateur modulo, et enfin de la variable « data ». Dans le même temps, nous affectons la chaîne ainsi formatée à la variable « message » :

message = template % data

Les données peuvent cor­res­pondre à une variable, mais il est également possible d’utiliser un littéral ou encore une ex­pres­sion. L’opération modulo peut être placée sur une seule et même ligne. Dans l’exemple ci-dessous, un littéral est inséré en lieu et place du caractère générique :

message = "Here comes %s" % "Jack"

Prenons un autre exemple : nous calculons la somme des prix in­di­vi­duels et sou­hai­tons indiquer le prix total dans le message. Nous ap­pli­quons donc le même schéma, en montrant ici que l’opérateur modulo peut être suivi d’une ex­pres­sion :

prices = (42, 69, 51)
message = "The total price is %s" % sum(prices)

Ici, vous vous demandez peut-être pourquoi nous utilisons le caractère générique « %s » et pas uni­que­ment le symbole de pour­cen­tage. En réalité, le « s » a une im­por­tance toute par­ti­cu­lière : au moment de l’insertion des données, celles-ci sont con­ver­ties en une chaîne de ca­rac­tères grâce à la fonction str().

Il existe d’autres rac­cour­cis pour le Format String Python, qui per­met­tent par exemple d’appliquer un formatage spécial aux chiffres. L’exemple de la constante Pi est parfait pour illustrer cette situation. Il nous suffit pour cela de la ren­seig­ner dans le caractère générique « %s », que vous con­nais­sez déjà. Le résultat contient 15 chiffres après la virgule :

from math import pi as PI
print("The value of Pi is approximately %s" % PI)

En utilisant plutôt le raccourci « %g » en tant que caractère générique, seuls cinq chiffres sont alors affichés après la virgule :

print("The value of Pi is approximately %g" % PI)

En plus des rac­cour­cis « %s » et « %g », de nom­breuses autres options existent, comme vous le verrez dans le pa­ra­graphe suivant.

Avec le formatage de chaîne modulo de Python, il est également possible de définir plusieurs ca­rac­tères gé­né­riques et d’y ren­seig­ner des données. Dans ce cas, l’opérateur modulo attend un tuple com­por­tant autant de valeurs que de ca­rac­tères gé­né­riques. Ces valeurs sont ren­seig­nées au niveau des ca­rac­tères gé­né­riques :

person = (’John’, 42)
message = "My friend %s is %s years old" % person

Comme vous le voyez, l’opération Format String Python avec l’opérateur modulo n’est pas par­ti­cu­liè­re­ment lisible. Pour améliorer lé­gè­re­ment ce résultat, il est possible de passer un dict au lieu d’un tuple avec les données. Dans ce cas, il suffit d’inscrire les noms des entrées dict entre pa­ren­thèses après le symbole de pour­cen­tage du caractère générique. Ainsi, à la lecture du modèle de chaîne, les valeurs attendues sont visibles :

person = {’name’: ’John’, ’age’: 42}
message = "My friend %(name)s is %(age)s years old" % person

Méthode str.format()

La méthode Format String Python constitue une amé­lio­ra­tion du formatage modulo, qui a d’abord été intégré à Python 3 avant d’être transféré dans Python 2.6. Au lieu d’utiliser un opérateur spé­ci­fique, elle se base sur l’ap­pli­ca­tion d’une approche orientée objet. La méthode str.format() est donc com­pa­tible avec d’autres méthodes liées aux chaînes de ca­rac­tères, comme la fonction str.split de Python.

Le schéma de base de la méthode str.format() de Python est similaire au formatage avec l’opérateur modulo. Il prend également une forme similaire dans .NET et Rust. Dans la chaîne de ca­rac­tères du modèle, les ca­rac­tères gé­né­riques sont re­pré­sen­tés par des accolades et les données sont trans­mises comme des arguments de l’appel de fonction :

template = "Here comes {}"
data = ’Jack’
message = template.format(data)

Si la chaîne de modèle contient plusieurs ca­rac­tères gé­né­riques, le même nombre d’arguments doit être transmis :

message = "My friend {} is {} years old".format(’John’, 42)

Nous spé­ci­fions, de manière fa­cul­ta­tive, la position des arguments à inclure (sous la forme d’indices). L’ordre des ca­rac­tères gé­né­riques peut ainsi être dissocié des arguments. Rappelez-vous que les indices com­men­cent toujours à zéro :

message = "My friend {1} is {0} years old".format(69, ’Jim’)

Comme les dif­fé­rentes valeurs sont présentes dans une même structure de données, nous ajoutons un as­té­risque devant l’argument afin de dé­com­pres­ser la structure de données. Cette ma­ni­pu­la­tion fonc­tionne avec les listes et les tuples :

person = (’John’, 42)
message = "My friend {} is {} years old".format(*person)

Pour les chaînes plus longues, les ca­rac­tères gé­né­riques vides peuvent vite s’avérer confus. Il est pré­fé­rable d’utiliser des arguments avec des noms :

template = "My friend {name} is {age} years old"
message = template.format(name = ’Jack’, age = 51)

Avec de nom­breuses valeurs, la liste des arguments serait très longue et pourrait donc être dé­rou­tante. Si tel est le cas, il vaut mieux regrouper les valeurs au sein d’un dict, puis le dé­com­pres­ser au moment de l’appel de la fonction. À la dif­fé­rence des listes et des tuples, nous utilisons un double as­té­risque pour dé­com­pres­ser ce dict :

# define dict
person = {’name’: ’Jim’, ’age’: 69}
# define string with placeholders
template = "My friend {name} is {age} years old"
# unpack dict in `format()` call
message = template.format(**person)

La technique Format String Python avec str.format() a pour par­ti­cu­la­rité de nom­breuses options de formatage. Elles amé­lio­rent les fonc­tion­na­li­tés du formatage modulo et sont par­ti­cu­liè­re­ment puis­santes pour l’édition du texte sur la ligne de commande ou encore les données ta­bu­laires. Découvrez avec nous le mécanisme lié au formatage des nombres.

Python offre un contrôle précis lors de l’édition des nombres en tant que texte. Vous pouvez donc définir la manière dont les signes de ces nombres doivent être affichés. Pour les nombres décimaux, il est également possible de spécifier un certain nombre de chiffres après la virgule. Cela peut s’avérer utile pour re­pré­sen­ter des nombres positifs ou négatifs sous forme de tableau.

Imaginons par exemple que nous sou­hai­tions afficher des mesures de tem­pé­ra­ture :

samples = [(’A0147D’, 27.6), (’X1489M’, -4.7), (’P9921U’, -10.93)]
for sample in samples:
    print(’| {} | {} |’.format(*sample))

Le résultat paraît « haché », car les nombres n’ont pas la même longueur :

| A0147D | 27.6 |
| X1489M | -4.7 |
| P9921U | -10.93 |

Nous modifions donc le code avant de définir un ensemble d’options de formatage :

for sample in samples:
    print(’| {} | {: 6.2f} |’.format(*sample))

Le nouveau résultat apparaît comme suit :

| A0147D | 27.60 |
| X1489M | -4.70 |
| P9921U | -10.93 |

In­té­res­sons-nous de plus près aux options de formatage du deuxième caractère générique. Celles-ci viennent juste après les deux points et com­pren­nent quatre com­po­sants :

1. Espace : ajoute un caractère d’es­pa­ce­ment devant les nombres positifs pour remplacer l’espace occupé par le signe « - » des nombres négatifs.
2. Nombre avant le point : cor­res­pond au nombre total de lettres dis­po­nibles pour le nombre.
3. Nombre après le point : cor­res­pond au nombre de chiffres après la virgule, complétés si né­ces­saire par des zéros.
4. Lettre « f » avant l’accolade fermante : permet de formater le nombre comme un nombre décimal.

Il existe de nom­breuses autres options de formatage per­met­tant de contrôler pré­ci­sé­ment l’édition de nombres et de chaînes de ca­rac­tères. Au quotidien, leur uti­li­sa­tion est plutôt rare ; en cas de besoin, vous pouvez consulter la do­cu­men­ta­tion of­fi­cielle de Python sur le formatage de chaîne.

In­ter­po­la­tion de chaînes

Depuis Python 3.6, une autre méthode de formatage est proposée : l’in­ter­po­la­tion de chaînes. Également connue sous le nom « f-strings », cette approche est la plus commode et la plus per­for­mante pour de nombreux cas d’ap­pli­ca­tion. Elle tire son nom de sa syntaxe générale ; les « f-strings » com­men­cent par la lettre « f », placée juste avant les guil­le­mets ouvrants.

Les ca­rac­tères gé­né­riques sont re­pré­sen­tés par des accolades. À la dif­fé­rence des méthodes que nous vous avons déjà pré­sen­tées, les ca­rac­tères gé­né­riques ne con­tien­nent ni index ni nom, mais plutôt une ex­pres­sion. Lors de la dé­fi­ni­tion d’une « f-string », les ca­rac­tères gé­né­riques sont im­mé­dia­te­ment remplis :

message = f"40 + 2 equals {40 + 2}"

L’ex­pres­sion peut également cor­res­pondre au nom d’une variable :

name = ’Jack’
message = f"Here comes {name}"

Il est tout à fait possible d’insérer plusieurs ex­pres­sions :

prices = (42, 69, 51)
currency = ’EUR’
message = f"The total price is {sum(prices)} {currency}"

Template strings

En plus des trois méthodes déjà pré­sen­tées, la solution Format String Python prend également en charge les template strings. Celles-ci sont générées à partir d’une classe distincte et offrent une véritable pro­tec­tion contre les failles de sécurité lors du formatage de chaînes venant di­rec­te­ment de l’uti­li­sa­teur.

Au sein des template strings, les pos­si­bi­li­tés de formatage sont limitées : les ca­rac­tères gé­né­riques peuvent uni­que­ment cor­res­pondre à des noms de variables, et non à des ex­pres­sions. Comme elles sont très simples, les templates strings sont parfaites pour « in­ter­na­tio­na­li­ser » des chaînes de ca­rac­tères et les mettre à dis­po­si­tion en plusieurs langues.

Le caractère générique cor­res­pond au signe du dollar, suivi du nom de la variable à utiliser. La syntaxe des template strings rappelle donc celle des langages shell tels que Bash ou Zsh. Pour insérer la valeur, il convient d’appeler la méthode subs­ti­tute() :

# import `Template` class from `string` module
from string import Template
# instantiate template
template = Template("Hey there, I’m $name")
# perform substitution
message = template.substitute(name = ’Jack’)

Comme c’est le cas dans les langages shell, il existe une autre syntaxe pour les ca­rac­tères gé­né­riques. Le signe du dollar est alors suivi d’accolades contenant le nom de la variable. Ainsi, il est possible d’effectuer des rem­pla­ce­ments au sein même d’un mot :

template = Template("Let’s buy $amount ${fruit}s")
message = template.substitute(amount = 3, fruit = ’orange’)

Python String Format : quelle méthode choisir ?

Chaque méthode possède des par­ti­cu­la­ri­tés qui lui sont propres. Nous les résumons ci-dessous :