String Format en Python

Python propose une excellente prise en charge pour les opérations liées aux chaînes de caractères et le traitement de texte. Ce langage propose de nombreuses options liées au formatage et à l’édition de textes. Découvrez avec nous les principales méthodes associées à String Format en Python.

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

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

Ces chaînes de caractères peuvent être composées de différents éléments. Dans la plupart des cas, elles sont constituées d’un mélange d’éléments fixes et de données variables, nécessaire pour l’édition de données et la création de documents dans le domaine du développement Web.

Prenons par exemple le cas d’une boutique en ligne. Nous souhaitons calculer le prix total des produits présents dans un panier pour en informer l’utilisateur : « Le prix total est de […] euros ». La première solution consiste à assembler la chaîne de caractères correspondante à l’aide de l’opérateur de concaténation :

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 caractères. Il faut donc commencer par convertir ce nombre en une chaîne de caractères en utilisant la fonction str() :

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

Mais tout cela peut vite prêter à confusion. Il serait certainement préférable de définir l’ensemble du texte, caractères génériques compris, et d’y renseigner des données. Lors de la conversion de ces données, il peut être nécessaire de modifier leur formatage, et c’est précisément à cette problématique que répondent les méthodes String Format Python.

Comment fonctionnent les méthodes String Format Python ?

Python prend en charge plusieurs méthodes String Format, comportant chacune des avantages et des inconvénients. Cette diversité s’étant renforcée au fil du temps, il existe aujourd’hui de nombreux points communs entre ces différentes méthodes, de même que quelques diffé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’interpolation de chaînes
4. Formatage avec des chaînes de modèle

Opérateur modulo

Ce formatage de chaînes de caractères est le premier à avoir été intégré à Python. Il utilise l’opérateur Python du symbole de pourcentage, normalement utilisé pour l’opération mathématique 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éritablement d’importance ; nous les avons simplement choisis de manière à rendre le code le plus compréhensible possible.

Il faut commencer par définir le modèle comme étant la variable portant le nom « template ». Dans ce modèle, nous devons maintenant définir la position du ou des caractè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 correspondre à une variable, mais il est également possible d’utiliser un littéral ou encore une expression. 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 individuels et souhaitons indiquer le prix total dans le message. Nous appliquons donc le même schéma, en montrant ici que l’opérateur modulo peut être suivi d’une expression :

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 uniquement le symbole de pourcentage. En réalité, le « s » a une importance toute particulière : au moment de l’insertion des données, celles-ci sont converties en une chaîne de caractères grâce à la fonction str().

Il existe d’autres raccourcis pour le Format String Python, qui permettent 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 renseigner dans le caractère générique « %s », que vous connaissez 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 raccourcis « %s » et « %g », de nombreuses autres options existent, comme vous le verrez dans le paragraphe suivant.

Avec le formatage de chaîne modulo de Python, il est également possible de définir plusieurs caractères génériques et d’y renseigner des données. Dans ce cas, l’opérateur modulo attend un tuple comportant autant de valeurs que de caractères génériques. Ces valeurs sont renseignées au niveau des caractè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 particulièrement lisible. Pour améliorer légèrement 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 parenthèses après le symbole de pourcentage 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élioration 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écifique, elle se base sur l’application d’une approche orientée objet. La méthode str.format() est donc compatible avec d’autres méthodes liées aux chaînes de caractè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 caractères du modèle, les caractères génériques sont représentés par des accolades et les données sont transmises 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 caractères génériques, le même nombre d’arguments doit être transmis :

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

Nous spécifions, de manière facultative, la position des arguments à inclure (sous la forme d’indices). L’ordre des caractères génériques peut ainsi être dissocié des arguments. Rappelez-vous que les indices commencent toujours à zéro :

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

Comme les différentes valeurs sont présentes dans une même structure de données, nous ajoutons un astérisque devant l’argument afin de décompresser la structure de données. Cette manipulation fonctionne avec les listes et les tuples :

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

Pour les chaînes plus longues, les caractè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 nombreuses valeurs, la liste des arguments serait très longue et pourrait donc être déroutante. Si tel est le cas, il vaut mieux regrouper les valeurs au sein d’un dict, puis le décompresser au moment de l’appel de la fonction. À la différence des listes et des tuples, nous utilisons un double astérisque pour décompresser ce 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 particularité de nombreuses options de formatage. Elles améliorent les fonctionnalités du formatage modulo et sont particulièrement puissantes pour l’édition du texte sur la ligne de commande ou encore les données tabulaires. 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 représenter des nombres positifs ou négatifs sous forme de tableau.

Imaginons par exemple que nous souhaitions afficher des mesures de température :

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 |

Intéressons-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 comprennent quatre composants :

1. Espace : ajoute un caractère d’espacement devant les nombres positifs pour remplacer l’espace occupé par le signe « - » des nombres négatifs.
2. Nombre avant le point : correspond au nombre total de lettres disponibles pour le nombre.
3. Nombre après le point : correspond au nombre de chiffres après la virgule, complétés si nécessaire par des zéros.
4. Lettre « f » avant l’accolade fermante : permet de formater le nombre comme un nombre décimal.

Il existe de nombreuses autres options de formatage permettant de contrôler précisément l’édition de nombres et de chaînes de caractères. Au quotidien, leur utilisation est plutôt rare ; en cas de besoin, vous pouvez consulter la documentation officielle de Python sur le formatage de chaîne.

Interpolation de chaînes

Depuis Python 3.6, une autre méthode de formatage est proposée : l’interpolation de chaînes. Également connue sous le nom « f-strings », cette approche est la plus commode et la plus performante pour de nombreux cas d’application. Elle tire son nom de sa syntaxe générale ; les « f-strings » commencent par la lettre « f », placée juste avant les guillemets ouvrants.

Les caractères génériques sont représentés par des accolades. À la différence des méthodes que nous vous avons déjà présentées, les caractères génériques ne contiennent ni index ni nom, mais plutôt une expression. Lors de la définition d’une « f-string », les caractères génériques sont immédiatement remplis :

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

L’expression peut également correspondre au nom d’une variable :

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

Il est tout à fait possible d’insérer plusieurs expressions :

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ésenté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 protection contre les failles de sécurité lors du formatage de chaînes venant directement de l’utilisateur.

Au sein des template strings, les possibilités de formatage sont limitées : les caractères génériques peuvent uniquement correspondre à des noms de variables, et non à des expressions. Comme elles sont très simples, les templates strings sont parfaites pour « internationaliser » des chaînes de caractères et les mettre à disposition en plusieurs langues.

Le caractère générique correspond 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 substitute() :

# 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 caractè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 remplacements 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 particularités qui lui sont propres. Nous les résumons ci-dessous :