Comment utiliser les formatteurs de chaînes en Python 3

###Introduction

La méthode str.format() de la classe string de Python vous permet de faire des substitutions de variables et du formatage de valeurs. Cela vous permet de concaténer des éléments ensemble dans une chaîne à travers le formatage positionnel.

Ce tutoriel vous guidera à travers certaines des utilisations courantes des formatteurs en Python, ce qui peut aider à rendre votre code et votre programme plus lisibles et conviviaux.

Conditions préalables

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 consulter les 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 formatteurs

Les formatteurs 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 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 insérée au même endroit que l'espace réservé lorsque vous exécuterez le programme.

Imprimons une chaîne qui utilise un formatteur :

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

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 passé la valeur de l'entier 5 à cette méthode. Cela place la valeur de 5 dans la chaîne là où se trouvaient les accolades :

Sammy has 5 balloons.

Nous pouvons également assigner une variable pour qu'elle soit égale à la valeur d'une chaîne qui a des espaces réservés de formatage :

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

Sammy loves open source.

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

Les formatteurs en Python vous permettent d'utiliser des accolades comme espaces réservés pour des valeurs que vous passerez avec la méthode str.format().

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

Vous pouvez utiliser plusieurs paires d'accolades lors de l'utilisation de formats. Si nous souhaitons ajouter un autre remplacement de variable à la phrase ci-dessus, nous pouvons le faire en ajoutant une deuxième paire d'accolades et en passant une deuxième valeur dans la méthode :

new_open_string = "Sammy loves {} {}."                      #2 {} placeholders
print(new_open_string.format("open-source", "software"))    #Pass 2 strings into method, separated by a comma

Sammy loves open-source software.

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

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

sammy_string = "Sammy loves {} {}, and has {} {}."                      #4 {} placeholders
print(sammy_string.format("open-source", "software", 5, "balloons"))    #Pass 4 strings into method

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

Dans sammy_string, nous avons ajouté 4 paires d'accolades comme espaces réservés pour la substitution de variables. Nous avons ensuite passé 4 valeurs à la méthode str.format(), en mélangeant des types de données chaînes et entiers. Chacune de ces valeurs est séparée par une virgule.

##Réorganiser les formateurs avec des arguments positionnels et des arguments de mot-clé

Lorsque nous laissons les accolades vides sans paramètres, Python remplacera les valeurs passées par la méthode str.format() dans l'ordre. Comme nous l'avons vu jusqu'à présent, une construction de formatteur avec deux accolades vides et deux valeurs passées ressemblera à ceci :

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

Sammy the shark has a pet pilot fish!

La première paire d'accolades est remplacée par la valeur de chaîne de "requin", et la seconde paire est remplacée par la valeur de chaîne de "poisson pilote".

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

("shark", "pilot fish")

Ils sont essentiellement le type de données tuple et chaque valeur individuelle contenue dans le tuple peut être appelée par son numéro d'indice, qui commence par le numéro d'indice 0.

Nous pouvons passer ces numéros d'index dans les accolades qui servent de paramètres dans la chaîne d'origine :

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 dans les accolades car nous appelons les valeurs dans le tuple dans l'ordre :

Sammy the shark has a pet pilot fish!

Mais, si nous inversions les numéros d'index avec les paramètres des espaces réservés, nous pouvons inverser les valeurs passées dans la chaîne :

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

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 faites appel à 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"))

IndexError: tuple index out of range

Le message d'erreur que nous voyons fait référence au fait que le tuple n'a des valeurs qu'aux indices 0 et 1, plaçant ainsi l'indice 2 hors limites.

Ajoutons quelques autres espaces réservés et quelques autres valeurs à leur transmettre, afin que nous puissions mieux comprendre comment nous pouvons réorganiser les formatters. Tout d'abord, voici une nouvelle chaîne avec quatre espaces réservés :

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

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 :

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

Sammy is a shark, blue, and smiling happy!

Puisque nous avons commencé avec le numéro d'index 3, nous avons d'abord appelé la dernière valeur de "requin". Les autres numéros d'index inclus en tant que paramètres modifient l'ordre dans lequel les mots apparaissent dans la chaîne d'origine.

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

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

Sammy the shark made a pull request.

Cet exemple montre l'utilisation d'un argument de mot-clé utilisé avec des arguments positionnels. Nous pouvons remplir l'argument de mot-clé pr en même temps que des arguments positionnels, et nous pouvons déplacer ces arguments pour modifier la chaîne résultante :

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

Sammy the pull request made a shark.

Les arguments positionnels et par mot-clé utilisés avec les formateurs de chaînes nous donnent plus de contrôle sur la manipulation de nos chaînes d'origine grâce au réordonnancement.

##Spécification du type

Nous pouvons inclure plus de paramètres à l'intérieur des accolades de notre syntaxe. Nous utiliserons la syntaxe de code de format {nom_du_champ:conversion}, où nom_du_champ spécifie le numéro d'index de l'argument à la méthode str.format() que nous avons abordée dans la section de réorganisation, et conversion fait référence 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, d pour afficher les entiers décimaux (base 10), et f que nous utiliserons pour afficher les nombres à virgule flottante 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.

Examinons un exemple où nous avons un entier passé à la méthode, mais que nous voulons l'afficher en tant que flottant en ajoutant l'argument de type de conversion f :

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

Sammy ate 75.000000 percent of a pizza!

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

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 également spécifier 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 niveau de précision élevé, nous pouvons limiter les décimales à 3 en ajoutant .3 avant le type de conversion f :

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

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 comme ceci :

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

Sammy ate 75.8 percent of a pizza!

Notez que modifier la précision entraînera un arrondi du nombre.

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

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

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

Si vous ne souhaitez pas afficher de décimales, vous pouvez écrire votre formateur de cette manière :

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

Sammy ate 76 percent of a pizza!

Cela ne convertira pas votre nombre à virgule flottante en un entier, mais limitera plutôt le nombre de décimales affichées.

##Substitutions de variables de remplissage

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

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"))

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 balloons 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 alignées à gauche dans le champ, et les nombres sont alignés à 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 numéro et centrons la chaîne :

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

Sammy has 5    red     balloons    !

Maintenant, nous voyons que 5 est aligné à gauche, laissant de l'espace dans le champ avant rouge, et ballons est centré dans son champ avec de l'espace à gauche et à droite.

Par défaut, lorsque nous agrandissons un champ avec des formateurs, Python remplira le champ avec des caractères d'espace. 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"))

*******Sammy********

Nous acceptons la chaîne passée à str.format() dans la position d'index 0 puisque nous n'avons pas spécifié autrement, y compris les deux-points, et en spécifiant que nous allons utiliser * au lieu d'espace pour remplir le champ. Nous centrons la chaîne avec ^, en spécifiant que le champ fait 20 caractères de long, 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))

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 float et inclus les deux-points, indiqué la taille du champ et inclus le point final, écrit le nombre de chiffres après la virgule, puis spécifié le type de conversion de f.

##Utilisation des 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))

Sammy has 8 balloons today!

Nous pouvons utiliser des variables à la fois pour la chaîne originale et ce qui est passé dans la méthode :

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

Sammy has 8 balloons today!

Les variables peuvent être facilement substituées pour chaque partie de notre syntaxe de construction de formatteur. Cela facilite le travail lorsque nous prenons des entrées générées par l'utilisateur et que nous attribuons ces valeurs aux variables.

##Utiliser des formatteurs pour organiser les données

Les formatteurs peuvent être perçus sous leur meilleur jour lorsqu'ils sont utilisés pour organiser un grand nombre de données de manière visuelle. Si nous montrons des bases de données aux utilisateurs, utiliser des formatteurs pour augmenter la taille des champs et modifier l'alignement peut rendre votre sortie plus lisible.

Regardons 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)

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

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

Utilisons des formateurs pour donner plus d'espace à ces nombres :

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 le 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 prévu la taille de chaque sortie attendue, en donnant 2 espaces de caractères supplémentaires pour chacune, selon la taille maximale possible du nombre, donc notre sortie ressemble à ceci :

  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 à ce que nous accommodions les plus grands nombres :

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

     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, modifier les numéros d'index des noms de champ, et plus encore pour nous assurer que nous affichons les données comme nous le souhaitons.

##Conclusion

Utiliser des formatteurs 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 formatteurs représentent une méthode de base mais non descriptive pour passer des substitutions de variables dans une chaîne, et sont utiles pour s'assurer que la sortie est lisible et conviviale.