Tout ce que vous devez savoir sur le formatage des chaînes en Python et le mini-langage de formatage Python.
Vous connaissez peut-être toutes sortes de façons de manipuler manuellement des chaînes en Python - peut-être avez-vous appris de notre cours Travailler avec des chaînes en Python (partie de la piste Python Basics). Aujourd'hui, vous apprendrez comment Python gère le formatage des chaînes , ou l'art de combiner une chaîne avec des données dynamiques de manière à ce qu'elle soit facilement lisible par un lecteur humain ou une machine qui attend. (Consultez cet article si vous manipulez également des chaînes en SQL.)
Qu'est-ce que le formatage de chaînes en Python ?
Travailler avec des chaînes est l'une des premières choses que tout développeur apprend à faire; en tant que tel, il semble que ce devrait être l'un des plus simples. Après tout, tous les "Hello World!" fait vraiment est d'imprimer une chaîne :
>>> print("Hello world!")
Hello world!
Cependant, des complications surviennent lorsque nous devons introduire des éléments dynamiques données - c'est-à-dire des données qui peuvent changer au fil du temps ou à chaque exécution. Prenez, par exemple, l'extrait de code ci-dessous :
>>> print("John ordered a Pepperoni Pizza for $4.25 with a 15% tip")
John ordered a Pepperoni Pizza for $4.25 with a 15% tip
Dans cet extrait, nous imprimons les détails d'une commande dans une pizzeria. Les données ici, cependant, sont codées en dur. Que se passe-t-il lorsque nous devons lire le nom du client, sa commande, son prix et le montant du pourboire à partir de variables ?
>>> print("customer_name ordered a order_name for price with a tip_percentage tip")
customer_name ordered a order_name for price with a tip_percentage tip
Cela ne suffira clairement pas.
Avant l'introduction de Python 3, le formatage des chaînes était principalement réalisé via l'opérateur %. Son utilisation consistait principalement à ajouter un espace réservé de style C dans la chaîne où une variable devait aller, puis à la lier en ajoutant les références de variable à la chaîne à l'aide de %. Ceci est démontré ci-dessous :
>>> print("Lorem %s dolor sit %s..." % ("ipsum", "amet"))
Lorem ipsum dolor sit amet...
Cette méthode obsolète a été explicitement désavouée dans la documentation Python 3 car elle est sujette aux erreurs et obsolète. Nous ne passerons plus de temps à en parler - sauf pour mentionner que cela pourrait être utile lorsqu'il s'agit d'anciennes versions de Python. Depuis Python 3, le formatage des chaînes est effectué principalement à l'aide du format() fonction, qui appartient à la classe String.
Si l'un des termes ci-dessus (tel que variable ou fonction) ne vous sont pas familiers, veuillez lire les Termes Python que les débutants devraient connaître - Partie 1 et Termes Python que les débutants devraient connaître - Partie 2 avant de continuer cet article.
Présentation de la fonction String.format()
La fonction String.format() est un outil de formatage de chaîne puissant et flexible introduit dans Python 3. (Il est également disponible dans les versions 2.7 et ultérieures.) Il fonctionne essentiellement en liant des espaces réservés marqués par des accolades {} et les données de formatage qu'elles contiennent aux arguments passés à la fonction.
La façon la plus simple d'utiliser la fonction format() est d'insérer des espaces réservés vides {} dans la chaîne, puis transmettez les variables nécessaires en tant qu'arguments.
>>> print("Apples can be {}, {}, and {}.".format("red", "yellow", "green"))
Apples can be red, yellow, and green.
Si vous ne souhaitez pas que l'ordre des espaces réservés soit identique à l'ordre des arguments, vous pouvez insérer des espaces réservés indexés {n} , où n est le numéro d'index de l'argument auquel l'espace réservé est censé être lié.
>>> print("Apples can be {1}, {2}, and {0} - yes, {0}!".format("red", "yellow", "green"))
Apples can be yellow, green, and red - yes, red!
Notez que vous pouvez mélanger l'ordre pour être ce que vous voulez, et vous pouvez même réutiliser le même argument deux fois.
Utiliser les liens positionnels , comme indiqué ci-dessus, n'est pas recommandé pour le formatage de chaînes plus longues. Les numéros d'index n'ont aucune signification intrinsèque et peuvent facilement se confondre lorsque le code est mis à jour. L'alternative consiste à lier les arguments à l'aide d'un espace réservé nommé, par ex. {arg_name} .
>>> print("The name's {last_name}, {first_name} {last_name}.".format(first_name="James", last_name="Bond"))
The name's Bond, James Bond.
Cela devrait être suffisant pour insérer les variables dans une chaîne, mais que se passe-t-il si vous voulez en savoir plus sur votre formatage ? Revenons à l'extrait de commande de pizza et formatons-le à l'aide de simples espaces réservés.
>>> print("{} ordered a {} for {} with a {} tip".format(customer_name, order_name, price, tip_percentage))
John ordered a Pepperoni Pizza for 4.25 with a 0.15 tip
Les variables sont imprimées dans leur forme la plus simple, mais que se passerait-il si nous voulions spécifier les chiffres décimaux du prix ? Peut-être devons-nous nous assurer que les chaînes résultantes s'alignent correctement. Nous devons absolument nous assurer que le pourcentage de pourboire, actuellement stocké sous forme décimale, est affiché sous forme de pourcentage. Pour ce faire (et plus encore), nous devons utiliser des modificateurs de formatage dans le cadre du mini-langage de formatage Python .
Introduction au mini-langage de formatage Python
Le mini-langage de formatage Python est une syntaxe qui autorise les modificateurs à placer dans un espace réservé particulier pour lui donner une signification supplémentaire. Cette signification peut être n'importe quoi, depuis la largeur de caractère du champ, la précision des types décimaux ou la notation dans laquelle les nombres (le cas échéant) sont représentés.
La syntaxe générale d'un espace réservé selon la spécification du format Python est illustrée ci-dessous :
{:[[fill]align][sign][#][0][width][grouping_option][.precision][type]}
Chaque champ entouré de crochets [] représente une catégorie de modificateur. Un seul modificateur de chaque catégorie peut être présent à la fois. Par exemple, nous ne pouvons pas utiliser à la fois le modificateur d'alignement à gauche < et le modificateur d'alignement à droite > dans un seul champ.
De plus, l'ordre des modificateurs est strictement défini . Par exemple, l'espace réservé {.2+} n'est pas valide, car le .precision modificateur (ici, .2 ) doit toujours venir après le sign modificateur(ici, + ). Un espace réservé valide serait {+.2} .
Tous les modificateurs sont facultatifs, c'est pourquoi même l'espace réservé vide {} reste valable. Les tableaux suivants détaillent la syntaxe appropriée pour chacune des catégories de modificateurs mentionnées ci-dessus.
Modificateur de remplissage
>>> print("{:~^10}".format("TEST"))~~~TEST~~~ Utiliser uniquement avec align. Aligner les modificateurs
>>> print("{:~>10}".format("TEST")) ~~~~~~TEST =Aligne à droite le champ et force le rembourrage à être placé après le signe.>>> print("{:~=10}".format(-58)) -~~~~~~~58 Types numériques uniquement. Utiliser uniquement avec sign . ^Centré le champ.>>> print("{:~^10}".format("TEST")) ~~~TEST~~~ Champs numériques uniquement. Modificateurs de signe
>>> print("{:+} {:+}".format(58, -58))
+58 -58 Champs numériques uniquement. -Place un signe pour les nombres négatifs uniquement.>>> print("{:-} {:-}".format(58, -58))
58 -58 Champs numériques uniquement. Un espace videPlace un espace avant les nombres positifs et un signe avant les nombres négatifs.>>> print("{: } {: }".format(58, -58))
58 -58 Champs numériques uniquement. # modificateur
>>> print("{0:#b} {0:#o} {0:#x} {0:#X}".format(124))
0b1111100 0o174 0x7c 0X7C Champs numériques uniquement. Modificateur de largeur
>>> print("{:~^10}".format("TEST"))
~~~TEST~~~ Modificateurs de regroupement
>>> print("{:_}".format(123456789))
123_456_789
>>> print("{:_x}".format(123456789))
75b_cd15 Champs numériques uniquement. Pour les types b, o, x et X, un trait de soulignement sera inséré tous les 4 chiffres. ,Définit la virgule comme séparateur de milliers.>>> print("{:,}".format(123456789))
123,456,789 Champs numériques uniquement. Modificateur de précision
1.667
>>> print("{:.3g}".format(5 / 3))
1.67
>>> print("{:.3s}".format("TEST"))
TES Définit les chiffres après le point pour les types f et F , chiffres totaux pour les types g et G , ou le nombre maximal de caractères affichés pour les chaînes. Modificateurs de type
>>> print("{:b}".format(112))
1110000 cFormat de caractère>>> print("{:c}".format(112))
p dFormat entier>>> print("{:d}".format(112))
112 Notation eScientific>>> print("{:e}".format(112))
1.120000e+02 ENotation scientifique avec majuscule>>> print("{:E}".format(112))
1.120000E+02 fNotation à virgule fixe>>> print("{:f}".format(123.456))
123.456000 FNotation à virgule fixe (majuscule)>>> print("{:F}".format(float("inf")))
INF gFormat décimal général - virgule fixe pour les petits nombres, notation scientifique pour les grands nombres.>>> print("{:g}".format(123.456))
123.456
>>> print("{:g}".format(123456789.456))
1.23457e+08
GFormat décimal général (majuscule)>>> print("{:G}".format(123.456))
123.456
>>> print("{:G}".format(123456789.456))
1.23457E+08 nFormat numérique>>> print("{:n}".format(123.456))
123.456 oFormat octal>>> print("{:o}".format(58))
72 sFormat de chaîne>>> print("{:s}".format("Hello world!"))
Hello world! Format xHex (minuscule)>>> print("{:x}".format(58))
3a Format XHex (majuscule)>>> print("{:X}".format(58))
3A Format %pourcentage>>> print("{:%}".format(0.25))
25.000000% Syntaxe du mini-langage de formatage de Python :les détails
Modificateurs d'alignement, de remplissage et de largeur
Ces modificateurs nous aident à formater des variables de longueur imprévisible pour s'adapter à une largeur fixe. Ceci est particulièrement utile si vous souhaitez que la sortie de chaîne soit soignée et compatible avec les tabulations.
Le width Le modificateur définit la largeur de champ totale minimale d'un champ, y compris les préfixes, séparateurs et autres caractères de formatage.
Le alignment le modificateur définit si la valeur est
<Aligné à gauche. La valeur par défaut pour les types de chaîne. Similaire à ljust().>Aligné à droite. La valeur par défaut pour les types numériques. Similaire à rjust().=Aligné à droite sauf pour le signe, qui est aligné à gauche. Gère les nombres de la même manière que zfill().^Aligné au centre. Similaire à center().
Enfin, le fill modificateur définit le caractère qui sera utilisé pour remplir les espaces vides (le cas échéant) laissés par le rembourrage. Sa valeur par défaut est un espace vide. Le fill le modificateur doit toujours être juste derrière le alignment modificateur.
>>> print("{:~^10}".format("TEST"))
~~~TEST~~~
>>> print("{:~<10}".format("TEST"))
TEST~~~~~~
>>> print("{:~>10}".format("TEST"))
~~~~~~TEST
>>> print("{:~=10}".format(-58))
-~~~~~~~58
Modificateurs de signe
Ces modificateurs déterminent le signe utilisé dans les types numériques :
+Lieux+avant les nombres positifs et-avant les nombres négatifs.-Ne place rien avant les nombres positifs et-devant les nombres négatifs. C'est la valeur par défaut.- Un espace vide place un espace avant les nombres positifs et
-avant les nombres négatifs.
Ces modificateurs ne peuvent pas être utilisés avec des types non numériques.
>>> print("{:+} {:+}".format(58, -58))
+58 -58
>>> print("{:-} {:-}".format(58, -58))
58 -58
>>> print("{: } {: }".format(58, -58))
58 -58
Modificateurs de regroupement
Dans les types numériques, ceux-ci définissent la façon dont les chiffres seront regroupés. Les valeurs possibles sont :
_Insère un trait de soulignement comme séparateur de milliers. Si utilisé avec les typesb,o,x, ouX, insère un trait de soulignement une fois tous les 4 chiffres.,Insère une virgule comme séparateur de milliers. Si utilisé avec le typen, insère à la place un séparateur compatible avec les paramètres régionaux.
>>> print("{:_}".format(123456789))
123_456_789
>>> print("{:_x}".format(123456789))
75b_cd15
>>> print("{:,}".format(123456789))
123,456,789
Modificateur de précision
Le modificateur de précision définit le nombre de chiffres qui seront affichés dans les champs avec des types décimaux.
Pour les types à virgule flottante f et F , il indique les chiffres décimaux affichés après le point.
Pour les types g et G , il indique le nombre total de chiffres à afficher – avant et après le point.
Pour le type de chaîne s il indique le maximum nombre de caractères affichés.
>>> print("{:.3f}".format(5 / 3))
1.667
>>> print("{:.3g}".format(5 / 3))
1.67
>>> print("{:.3s}".format("TEST"))
TES
Modificateurs de type
Le modificateur de type affecté à un champ détermine le type avec lequel ce champ doit être traité. Cela a des ramifications sur la façon dont les données sont présentées et sur le nombre d'autres modificateurs qui fonctionnent.
Les modificateurs de type peuvent être divisés en trois catégories principales – les types de chaîne, les types entiers et les types décimaux.
Il n'y a qu'un seul type de chaîne , s :
>>> print("{:s}".format("Hello world!"))
Hello world!
Les types entiers sont :
bRenvoie un entier en base 2 (binaire).oRenvoie un entier en base 8 (octal).dRenvoie un entier en base 10 (décimal).xRenvoie un entier en base 16 (hexadécimal). Les lettres hexadécimales sont en minuscules.XRenvoie un entier en base 16 (hexadécimal). Les lettres hexadécimales sont en majuscules.nIdentique àd, sauf qu'il utilise un caractère adapté aux paramètres régionaux comme séparateur de milliers.
>>> print("{0:b} {0:d} {0:x} {0:X} {0:n}".format(124))
1111100 124 7c 7C 124
Enfin, les types décimaux disponibles sont :
eNotation scientifique.EIdentique àe, sauf que le caractère de séparation est en majuscule.fNotation à virgule fixe.FIdentique àf, maisnanetinfdevenirNANetINF.gFormat général. Affiche les petits nombres en notation à virgule fixe et les grands nombres en notation scientifique. Ce mécanisme est décrit plus en détail dans la spécification du format Python.GIdentique àg, mais en majuscule.- n
Identique àg, sauf qu'il utilise un caractère adapté aux paramètres régionaux comme séparateur de milliers. %Multiplie le nombre par 100, l'affiche en notation à virgule fixe et ajoute un signe de pourcentage à la fin.
>>> print("{0:e} {0:E} {0:f} {0:F} {0:g} {0:G} {0:n} {0:%}".format(123456.789))1.234568e+05 1.234568E+05 123456.789000 123456.789000 123457 123457 123457 12345678.900000% Le modificateur de forme alternative
Le modificateur de forme alternative # impacte la présentation des types numériques. Dans les types entiers, il ajoute le préfixe 0b , 0o , 0x , ou 0X aux notations binaire, octale, hexadécimale et majuscule-hexadécimale, respectivement.
>>> print("{0:#b} {0:#o} {0:#x} {0:#X}".format(124))
0b1111100 0o174 0x7c 0X7C
Accéder aux attributs et éléments des arguments
Jusqu'à présent, nous avons vu comment lier directement les espaces réservés aux variables. Nous pouvons également accéder aux attributs et aux éléments d'une variable à partir de la chaîne formatée elle-même, comme illustré ci-dessous :
>>> print("{0.x},{0.y}".format(point))
2,5
>>> print("{0[0]},{0[1]}".format((2, 5)))
2,5
L'exemple de la pizza avec des chaînes correctement formatées
Avec les outils décrits ci-dessus, nous sommes maintenant prêts à formater entièrement l'exemple de commande de pizza du précédent. La voici à nouveau pour rappel :
>>> print("{} ordered a {} for {} with a {} tip".format(customer_name, order_name, price, tip_percentage))
John ordered a Pepperoni Pizza for 4.25 with a 0.15 tip
Notre objectif est de créer un format qui se traduira par une sortie attrayante et conviviale pour la tabulation avec des longueurs de ligne égales. Nous voulons également qu'il affiche les nombres dans leur format approprié.
Commençons par le nom. Si nous supposons une longueur de nom maximale de 10 caractères, nous pouvons utiliser une combinaison des modificateurs de largeur et d'alignement pour nous assurer que les variations de longueur du nom n'entraîneront pas de longueurs de ligne inégales. Nous définissons une largeur de 10 , un alignement de centre , et un type de chaîne en utilisant {:^10s} .
Le même principe s'applique pour le nom de la commande, sauf que nous allons augmenter la largeur. Nous définissons une largeur de 20 , un alignement de centre , et un type de chaîne en utilisant {:^20s} .
Le prix est un peu différent. Ce sera un type décimal, et nous aurons toujours besoin précisément de 2 chiffres décimaux. Nous fixons une précision de 2 et un type de point fixe en utilisant {:.2f} .
Enfin, le pourboire est un pourcentage, stocké en interne sous forme de virgule flottante. Nous ne sommes pas intéressés par les décimales au-delà du pourcentage entier lui-même, ce qui signifie que nous voulons une précision de 0. Nous définissons une précision de 0 et un type de pourcentage en utilisant {:.0%} .
En rassemblant tout cela, on obtient :
>>> order_str = "{:^10s} ordered a {:^20s} for ${:.2f} with a {:.0%} tip" Et maintenant pour le tester :
>>> print(order_str.format("John", "Pepperoni Pizza", 4.25, 0.15))
>>> print(order_str.format("Mike", "Margherita Pizza", 3.55, 0.25))
>>> print(order_str.format("Greg", "Large fries", 1, 0.1))
Les résultats :
John ordered a Pepperoni Pizza for $4.25 with a 15% tip Mike ordered a Margherita Pizza for $3.55 with a 25% tip Greg ordered a Large fries for $1.00 with a 10% tip
Assez bien! Les lignes sont paires, les dollars sont des dollars, les pourcentages sont des pourcentages, et tous avec les bons espaces décimaux.
En savoir plus sur le formatage des chaînes en Python
Vous avez maintenant une assez bonne connaissance de ce qu'il faut pour formater des chaînes en Python. Pour en savoir plus sur l'affichage correct des chaînes, vous pouvez lire la documentation Python Formatting Mini-Language ainsi que How to Pretty-Print Tables in Python et d'autres disponibles sur LearnPython.com.
