Comment utiliser les formateurs de chaîne dans Python 3

###Introduction

La méthode str.format() de la classe string en Python vous permet d’effectuer des substitutions de variables et de formater des valeurs. Cela vous permet de concaténer des éléments ensemble dans une chaîne grâce au formatage positionnel.

Ce tutoriel vous guidera à travers certaines des utilisations courantes des formateurs en Python, ce qui peut aider à rendre votre code et programme plus lisible et convivial pour l’utilisateur.

Prérequis

Vous devez avoir Python 3 installé et un environnement de programmation configuré sur votre ordinateur ou serveur. Si vous n’avez pas d’environnement de programmation configuré, vous pouvez vous référer aux guides d’installation et de configuration pour un environnement de programmation local ou pour un environnement de programmation sur votre serveur approprié à votre système d’exploitation (Ubuntu, CentOS, Debian, etc.)

##Utilisation des formateurs

Les formateurs fonctionnent en insérant un ou plusieurs champs de remplacement ou espaces réservés – définis par une paire d’accolades {} – dans une chaîne de caractères et en appelant la méthode str.format(). Vous passerez à la méthode la valeur que vous souhaitez concaténer avec la chaîne. Cette valeur sera transmise à la même position que celle de votre espace réservé lorsque vous exécutez le programme.

Imprimons une chaîne qui utilise un formateur:

print("Sammy has {} balloons.".format(5))

Output
Sammy has 5 balloons.

Dans l’exemple ci-dessus, nous avons construit une chaîne avec une paire d’accolades comme espace réservé:

"Sammy has {} balloons."

Nous avons ensuite ajouté la méthode str.format() et avons transmis la valeur de l’entier 5 à cette méthode. Cela place la valeur de 5 dans la chaîne à l’endroit où se trouvaient les accolades:

Sammy has 5 balloons.

Nous pouvons également attribuer une variable à la valeur d’une chaîne qui a des espaces réservés de formateur:

open_string = "Sammy loves {}."
print(open_string.format("open source"))

Output
Sammy loves open source.

Dans ce deuxième exemple, nous avons concaténé la chaîne "open source" avec la chaîne plus grande, remplaçant les accolades dans la chaîne d’origine.

Les formateurs en Python vous permettent d’utiliser des accolades comme espaces réservés pour les valeurs que vous transmettrez avec la méthode str.format().

##Utiliser des formateurs avec plusieurs espaces réservés

Vous pouvez utiliser plusieurs paires de crochets lors de l’utilisation de formateurs. Si nous voulons ajouter une autre substitution de variable à la phrase ci-dessus, nous pouvons le faire en ajoutant une deuxième paire de crochets et en passant une deuxième valeur à la méthode :

new_open_string = "Sammy loves {} {}."                      #2 {} espaces réservés
print(new_open_string.format("open-source", "software"))    #Passer 2 chaînes à la méthode, séparées par une virgule

Output
Sammy loves open-source software.

Pour ajouter une autre substitution, nous avons ajouté une deuxième paire de crochets à la chaîne d’origine. Ensuite, nous avons passé deux chaînes à la méthode str.format(), en les séparant par une virgule.

Suivant la même syntaxe, nous pouvons ajouter des substitutions supplémentaires :

sammy_string = "Sammy loves {} {}, and has {} {}."                      #4 {} espaces réservés
print(sammy_string.format("open-source", "software", 5, "balloons"))    #Passer 4 chaînes à la méthode

Output
Sammy loves open-source software, and has 5 balloons.

Dans sammy_string, nous avons ajouté 4 paires de crochets comme espaces réservés pour la substitution de variable. Ensuite, nous avons passé 4 valeurs à la méthode str.format(), mélangeant les types de données de chaîne et d’entier. Chacune de ces valeurs est séparée par une virgule.

##Reordonner les formateurs avec des arguments positionnels et des mots-clés

Lorsque nous laissons les crochets vides sans aucun paramètre, Python remplacera les valeurs passées à travers la méthode str.format() dans l’ordre. Comme nous l’avons vu jusqu’à présent, une construction de formateur avec deux paires de crochets vides avec deux valeurs passées ressemblera à ceci :

print("Sammy the {} has a pet {}!".format("shark", "pilot fish"))

Output
Sammy the shark has a pet pilot fish!

La première paire de crochets est substituée par la valeur de chaîne de "requin", et la deuxième paire est substituée par la valeur de chaîne de "poisson-pilote".

Les valeurs qui existent dans la méthode ressemblent à ceci :

("shark", "pilot fish")

Elles sont essentiellement du type de données tuplet et chaque valeur individuelle contenue dans le tuple peut être appelée par son numéro d’index, qui commence par le numéro d’index 0.

Nous pouvons passer ces numéros d’index entre les accolades qui servent de marqueurs de position dans la chaîne originale :

print("Sammy the {0} has a pet {1}!".format("shark", "pilot fish"))

Dans l’exemple ci-dessus, la sortie sera ce que nous obtenons sans passer de numéros d’index entre les accolades car nous appelons les valeurs du tuple dans l’ordre :

Output
Sammy the shark has a pet pilot fish!

Mais, si nous invers[ons](#) les numéros d’index avec les paramètres des marqueurs de position, nous pouvons inverser les valeurs passées dans la chaîne :

print("Sammy the {1} has a pet {0}!".format("shark", "pilot fish"))

Output
Sammy the pilot fish has a pet shark!

Si vous appelez un numéro d’index de 2 dans un tuple qui a des valeurs aux positions d’index 0 et 1, alors vous appelez une valeur qui est hors de portée. Lorsque vous appelez un numéro d’index qui est hors de portée, vous recevrez un message d’erreur :

print("Sammy the {2} has a pet {1}!".format("shark", "pilot fish"))

Output
IndexError: tuple index out of range

Le message d’erreur que nous voyons fait référence au tuple ayant uniquement des valeurs aux numéros d’index 0 et 1, plaçant donc le numéro d’index 2 hors de portée.

Ajoutons quelques marqueurs de position supplémentaires et quelques valeurs supplémentaires à leur passer, afin de comprendre un peu mieux comment nous pouvons réorganiser les formateurs. Tout d’abord, voici une nouvelle chaîne avec quatre marqueurs de position :

print("Sammy is a {}, {}, and {} {}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a happy, smiling and blue shark!

Sans paramètres, les valeurs qui sont passées dans la méthode str.format() sont concaténées dans la chaîne dans l’ordre.

Les valeurs de chaîne contenues dans le tuple correspondent aux numéros d’index suivants :

Utilisons les numéros d’index des valeurs pour changer l’ordre dans lequel elles apparaissent dans la chaîne de caractères :

print("Sammy is a {3}, {2}, and {1} {0}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a shark, blue, and smiling happy!

Depuis que nous avons commencé avec l’index numéro 3, nous avons appelé en premier la dernière valeur de "shark". Les autres numéros d’index inclus en tant que paramètres changent l’ordre dans lequel les mots apparaissent dans la chaîne d’origine.

En plus des arguments positionnels, nous pouvons également introduire des arguments par mot-clé qui sont appelés par leur nom de mot-clé :

print("Sammy the {0} {1} a {pr}.".format("shark", "made", pr = "pull request"))

Output
Sammy the shark made a pull request.

Cet exemple montre l’utilisation d’un argument par mot-clé utilisé avec des arguments positionnels. Nous pouvons remplir l’argument par mot-clé pr aux côtés des arguments positionnels, et pouvons déplacer ces arguments pour changer la chaîne résultante.

print("Sammy the {pr} {1} a {0}.".format("shark", "made", pr = "pull request"))

Output
Sammy the pull request made a shark.

Les arguments positionnels et par mot-clé utilisés avec les formateurs de chaîne nous donnent plus de contrôle sur la manipulation de nos chaînes d’origine en les réorganisant.

## Spécification du type

Nous pouvons inclure plus de paramètres entre les accolades de notre syntaxe. Nous utiliserons la syntaxe du code de format {field_name:conversion}, où field_name spécifie le numéro d’index de l’argument pour la méthode str.format() que nous avons parcourue dans la section de réorganisation, et conversion se réfère au code de conversion du type de données que vous utilisez avec le formateur.

Le type de conversion fait référence au code de type à un seul caractère utilisé par Python. Les codes que nous utiliserons ici sont s pour les chaînes de caractères, d pour afficher les entiers décimaux (base 10), et f que nous utiliserons pour afficher les nombres flottants avec des décimales. Vous pouvez en savoir plus sur le mini-langage de spécification de format à travers la documentation officielle de Python 3.

Regardons un exemple où nous avons un entier passé par la méthode, mais nous voulons l’afficher comme un flottant en ajoutant l’argument de type de conversion f:

print("Sammy ate {0:f} percent of a {1}!".format(75, "pizza"))

Output
Sammy ate 75.000000 percent of a pizza!

Nous avons utilisé la syntaxe {nom_champ:conversion} pour le premier champ de remplacement entre accolades afin de produire un flottant en sortie. Les deuxièmes accolades n’utilisent que le premier paramètre {nom_champ}.

Dans l’exemple ci-dessus, il y a beaucoup de chiffres affichés après la virgule, mais vous pouvez les limiter. Lorsque vous spécifiez f pour les valeurs flottantes, vous pouvez spécifier en plus la précision de cette valeur en incluant un point . suivi du nombre de chiffres après la virgule que vous souhaitez inclure.

Si Sammy a mangé 75,765367% de la pizza, mais que nous n’avons pas besoin d’un haut niveau de précision, nous pouvons limiter les chiffres après la virgule à 3 en ajoutant .3 avant le type de conversion f:

print("Sammy ate {0:.3f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.765 percent of a pizza!

Si nous ne voulons qu’un chiffre après la virgule, nous pouvons réécrire la chaîne et la méthode de la manière suivante :

print("Sammy ate {0:.1f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.8 percent of a pizza!

Remarquez que la modification de la précision entraînera l’arrondi du nombre.

Bien que nous affichions un nombre sans décimales sous forme de flottant, si nous essayons de le changer en un entier en utilisant le type de conversion d, nous recevrons une erreur:

print("Sammy ate {0:d} percent of a pizza!".format(75.765367))

Output
ValueError: Unknown format code 'd' for object of type 'float'

Si vous souhaitez qu’aucune décimale ne soit affichée, vous pouvez écrire votre formateur comme ceci:

print("Sammy ate {0:.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate 76 percent of a pizza!

Cela ne convertira pas votre flottant en un entier, mais limitera plutôt le nombre de chiffres affichés après le point décimal.

## Substitutions de variables de rembourrage

Étant donné que les espaces réservés sont des champs de remplacement, vous pouvez ajouter un rembourrage ou créer de l’espace autour d’un élément en augmentant la taille du champ à l’aide de paramètres supplémentaires. Cela peut être utile lorsque nous devons organiser visuellement beaucoup de données.

Nous pouvons ajouter un nombre pour indiquer la taille du champ (en termes de caractères) après les deux-points : dans les accolades de notre syntaxe:

print("Sammy has {0:4} red {1:16}!".format(5, "balloons"))

Output
Sammy has    5 red balloons        !

Dans l’exemple ci-dessus, nous avons donné au nombre 5 une taille de champ de caractères de 4, et à la chaîne ballons une taille de champ de caractères de 16 (car c’est une longue chaîne).

Comme nous le voyons, par défaut, les chaînes de caractères sont justifiées à gauche dans le champ, et les nombres à droite. Vous pouvez modifier cela en plaçant un code d’alignement après les deux-points. < alignera le texte à gauche dans un champ, ^ centrera le texte dans le champ, et > l’alignera à droite.

Alignons à gauche le nombre et centrons la chaîne :

print("Sammy has {0:<4} red {1:^16}!".format(5, "balloons"))

Output
Sammy has 5    red     balloons    !

Maintenant, nous voyons que 5 est aligné à gauche, fournissant de l’espace dans le champ avant rouge, et ballons est centré dans son champ avec de l’espace à gauche et à droite de celui-ci.

Par défaut, lorsque nous agrandissons un champ avec des formateurs, Python remplira le champ avec des caractères d’espacement. Nous pouvons modifier cela pour qu’il soit un caractère différent en spécifiant le caractère que nous voulons qu’il soit directement après les deux-points :

print("{:*^20s}".format("Sammy"))

Output
*******Sammy********

Nous acceptons la chaîne passée à str.format() à la position d’index 0 puisque nous n’avons pas spécifié autrement, y compris les deux-points, et en spécifiant que nous utiliserons * au lieu de l’espace pour remplir le champ. Nous centrons la chaîne avec ^, en spécifiant que le champ fait 20 caractères de taille, et en indiquant également que nous travaillons avec un type de conversion de chaîne en incluant s.

Nous pouvons combiner ces paramètres avec d’autres paramètres que nous avons utilisés auparavant :

print("Sammy ate {0:5.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate    76 percent of a pizza!

Dans les paramètres entre les accolades, nous avons spécifié le numéro de champ d’index du flottant et inclus les deux-points, indiqué la taille du nombre de champ et inclus le point, écrit le nombre de chiffres après la virgule, puis spécifié le type de conversion de f.

## Utilisation de Variables

Jusqu’à présent, nous avons passé des entiers, des flottants et des chaînes de caractères dans la méthode str.format(), mais nous pouvons également passer des variables à travers la méthode. Cela fonctionne comme n’importe quelle autre variable.

nBalloons = 8
print("Sammy has {} balloons today!".format(nBalloons))

Output
Sammy has 8 balloons today!

Nous pouvons utiliser des variables pour la chaîne d’origine et ce qui est passé dans la méthode :

sammy = "Sammy has {} balloons today!"
nBalloons = 8
print(sammy.format(nBalloons))

Output
Sammy has 8 balloons today!

Les variables peuvent être facilement substituées pour chaque partie de notre construction de syntaxe de formatage. Cela facilite le travail lorsque nous prenons en compte les entrées générées par l’utilisateur et attribuons ces valeurs à des variables.

##Utiliser les formateurs pour organiser les données

Les formateurs se révèlent sous leur meilleur jour lorsqu’ils sont utilisés pour organiser beaucoup de données de manière visuelle. Si nous montrons des bases de données aux utilisateurs, l’utilisation de formateurs pour augmenter la taille des champs et modifier l’alignement peut rendre votre sortie plus lisible.

Jetons un coup d’œil à une boucle for typique en Python qui affichera i, i*i, et i*i*i dans la plage de 3 à 12:

for i in range(3,13):
    print(i, i*i, i*i*i)

Output
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728

Alors que la sortie est organisée de manière, les chiffres débordent dans les colonnes les unes des autres, rendant le bas de la sortie moins lisible. Si vous travaillez avec un ensemble de données plus important contenant de nombreux chiffres petits et grands, cela peut poser un problème.

Utilisons des formateurs pour donner plus d’espace à ces chiffres:

for i in range(3,13):
    print("{:3d} {:4d} {:5d}".format(i, i*i, i*i*i))

Ici, dans nos accolades, nous n’avons pas ajouté le nom du champ pour le numéro d’index et avons commencé par les deux-points, suivi du nombre pour la taille du champ, et d’un type de conversion d puisque nous travaillons avec des entiers. Dans cet exemple, nous avons tenu compte de la taille de chaque sortie attendue, en donnant 2 espaces de caractères supplémentaires pour chacune, en fonction de la taille maximale possible du nombre, donc notre sortie ressemble à ceci:

Output
  3    9    27
  4   16    64
  5   25   125
  6   36   216
  7   49   343
  8   64   512
  9   81   729
 10  100  1000
 11  121  1331
 12  144  1728

Nous pouvons spécifier un nombre de taille de champ cohérent afin d’avoir des colonnes uniformes, en veillant à prendre en compte les nombres plus grands:

for i in range(3,13):
    print("{:6d} {:6d} {:6d}".format(i, i*i, i*i*i))

Output
     3      9     27
     4     16     64
     5     25    125
     6     36    216
     7     49    343
     8     64    512
     9     81    729
    10    100   1000
    11    121   1331
    12    144   1728

Nous pouvons également manipuler l’alignement des colonnes en ajoutant <, ^ et > pour l’alignement du texte, changer d en f pour ajouter des décimales, changer les numéros d’index des champs, et plus encore pour nous assurer que nous affichons les données comme nous le souhaitons.

##Conclusion

Utiliser des formateurs pour la substitution de variables peut être un moyen efficace de concaténer des chaînes et d’organiser des valeurs et des données. Les formateurs représentent un moyen basique mais non descriptif de passer des substitutions de variables dans une chaîne, et sont utiles pour s’assurer que la sortie est lisible et conviviale.