La problématique des chaînes formatées¶

Le formatage de chaînes est une possibilité offerte par de nombreux langages de programmation de créer une chaîne de caractères (comprendre du texte) à partir d’un modèle prédéfini. Typiquement, on peut utiliser le formatage de chaîne pour générer une date en français puisqu’une telle date a la structure jj/mm/aaaa connue à l’avance ou encore l’heure qui a le format hh:mm:ss. Mais, au-delà de ces formats figés, de nombreuses compositions structurées comme un sudoku à remplir, une table de conjugaison ou un calendrier :

    Janvier 2038
di lu ma me je ve sa
                1  2
 3  4  5  6  7  8  9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31

sont avantageusement construites en utilisant des chaînes formatées.

La notion de chaîne formatée¶

Supposons qu’on veuille générer de façon automatisée des phrases ayant la structure suivante :

Son nom est titi et il a 8 ans.
Son nom est Arthur et il a 30 ans.
Son nom est Alfred et il a 100 ans.

D’une phrase à l’autre, seuls le nom et le nombre représentant l’âge changent. Les chaînes ci-dessus sont dites des chaînes formatées : toutes les chaînes ont même structure, ici de la forme

Son nom est XXX et il a YYY ans.

Seuls varient le nom XXX et l’âge YYY.

Dans le présent document j’appelerai la chaîne-modèle telle que

Son nom est XXX et il a YYY ans.

un gabarit ou encore un modèle ou parfois une chaîne de formatage. Les parties à remplacer sont appelées champs de remplacement (en anglais remplacement field). Un gabarit est le modèle à partir duquel d’autres chaînes vont être produites par substitution.

Les chaînes formatées avec la méthode format¶

Python permet de créer des chaînes formatées basées sur un gabarit.

Considérons le gabarit informel suivant :

Son nom est XXX et il a YYY ans.

Voici le code Python permettant de produire les chaînes formatées basées sur ce gabarit :

1
2
3
4
5
6
7
8
9

modele = "Son nom est {} et il a {} ans."

a = modele.format("titi", 8)
print(a)

b = modele.format("Arthur", 30)
print(b)

print(modele.format("Alfred", 100))

10
11
12

Son nom est titi et il a 8 ans.
Son nom est Arthur et il a 30 ans.
Son nom est Alfred et il a 100 ans.

• Ligne 1 : c’est la traduction Python du gabarit informel Son nom est XXX et il a YYY ans. C’est ici une chaîne littérale. Les champs de remplacement sont représentés par des paires d’accolades {} au lieu de XXX et YYY.
• Ligne 3 : construction de la chaîne formatée (qui est affichée ligne 10) à l’aide de la méthode standard format. La première paire d’accolades est remplacée dans le gabarit par le premier argument, de même pour la deuxième paire d’accolades.
• Lignes 6 et 9 : analogue à la ligne 3.

En résumé, les deux étapes de création d’une chaîne formatée sont

• la construction du gabarit : un gabarit est réalisé en Python avec une chaîne de caractères Python, le plus souvent une chaîne littérale (c’est-à-dire délimitée par des guillemets). Les parties « variables » du gabarit sont placées entre des paires d’accolades. Dans les cas les plus simples, les paires d’accolades ne contiennent rien ;
• la génération de la chaîne formatée : pour « remplir » le gabarit, on appelle la méthode format du type chaîne en la préfixant avec la chaîne gabarit. Dans le cas où les accolades sont de la forme {} ie ne contiennent rien, le remplissage du gabarit est positionnel : le \(k\)-e champ de remplacement du gabarit est remplacé par le \(k\)-e argument de la fonction. La méthode format peut prendre un nombre arbitraire d’arguments. Elle renvoie la chaîne formatée.

Numérotation des arguments¶

On peut placer des numéros au début d’une paire d’accolades présentes dans un gabarit pour se référer aux arguments de la méthode format suivant leur numéro d’ordre d’apparition en tant qu’arguments :

1
2

modele = "une {1}, une {2} et une {0}"
print(modele.format("pomme", "poire", "prune"))

3

une poire, une prune et une pomme

• Ligne 1 : le gabarit contient trois champs. Par exemple, le champ {2} se réfère à l’argument n°2 de la liste des arguments de la méthode format, c’est-à-dire le 3ème argument de la liste.

Le premier argument de la méthode format est numéroté 0. Chaque paire d’accolades avec son contenu est appelé champ de remplacement. On dit aussi que le gabarit utilise les arguments positionnels de la méthode format. Chaque nombre placé entre les accolades est appelé nom de remplacement.

Les arguments de la méthode format peuvent servir plusieurs fois dans le gabarit ou certains arguments peuvent ne pas servir :

1
2

modele = "une {1}, une {2} et une {1}"
print(modele.format("pomme", "poire", "prune"))

3

une poire, une prune et une poire

• L’argument numéro 0 ne sert pas et l’argument numéro 1 sert deux fois.

Arguments nommés dans un champ de remplacement¶

Pour permettre une plus grande facilité d’utilisation, la méthode format accepte des arguments dits « nommés » :

1
2
3

modele = "Son nom est {prenom} et il a {age} ans."
a=modele.format(age=42, prenom= "Arthur")
print(a)

4

Son nom est Arthur et il a 42 ans.

• Ligne 1 : la gabarit modele possède deux champs de remplacement nommés : {prenom} et {age}.
• Ligne 2 : la méthode format est appelée sur le gabarit. Les arguments de l’appel sont nommés, l’un age, l’autre prenom. Les valeurs de ces arguments (respectivement 42 et "Arthur") vont remplacer les champs du gabarit portant le même nom.

On peut aussi obtenir le même effet si les arguments sont des clés d’un dictionnaire que l’on décompresse dans l’appel :

1
2
3
4
5

modele = "Son nom est {prenom} et il a {age} ans."
dico={"age":42,"prenom":"Arthur"}

a=modele.format(**dico)
print(a)

6

Son nom est Arthur et il a 42 ans.

• Ligne 4 : le dictionnaire est décompressé en des arguments nommés, ce qui donne le même résultat que dans l’exemple précédent.

Dans le même registre, si les arguments sont en fait des variables locales (et donc présentes dans le dictionnaire des variables locales), on peut obtenir le même effet :

1
2
3
4
5
6

age=42
prenom = "Arthur"
modele = "Son nom est {prenom} et il a {age} ans."

a=modele.format(**locals())
print(a)

7

Son nom est Arthur et il a 42 ans.

• Lignes 1-3 : trois variables locales age, prenom, modele.
• Ligne 4 : locals() renvoie un dictionnaire dont les clés sont des chaînes de même nom que les variables locales. Comme dans l’exemple précédent, le dictionnaire est décompressé.

Toutefois, la syntaxe des arguments nommés n’est pas aussi souple que celle des f-chaînes puisque le champ de remplacement ne peut contenir qu’une clé de dictionnaire et pas une expression. Ainsi, le code suivant échoue :

1
2
3

modele = "Son nom est {prenom} et il a {age+10} ans."
a=modele.format(age=42, prenom= "Arthur")
print(a)

alors qu’une f-chaîne permettait d’écrire :

1
2
3
4

age=42
prenom= "Arthur"
a = f"Son nom est {prenom} et il a {age+10} ans."
print(a)

5

Son nom est Arthur et il a 52 ans.

Enfin, il est possible d’utiliser à la fois des arguments positionnels numérotés et des arguments nommés mais tous les arguments positionnels doivent être au début de la liste des arguments de la méthode format :

1
2
3

modele = "Son nom est {prenom} et, dans {1} mois et {0} jours, il aura {age} ans."
a=modele.format(2, 5, age=42, prenom= "Arthur")
print(a)

4

Son nom est Arthur et, dans 5 mois et 2 jours, il aura 42 ans.

Arguments sous forme de liste¶

Examinons l’exemple suivant :

1
2
3
4

modele = "le {1[2]} est {0}"
objets=["soleil", "stylo", "papier"]
a = modele.format("rouge", objets)
print(a)

5

le papier est rouge

• Ligne 1 : dans le champ de remplacement {1[2]}, le numéro 1 correspond à l’argument numéro 1 de l’appel de la méthode format, ici la liste à la ligne 2.
• Lignes 3 et 5 : le champ {1[2]} est remplacé par objets[2] et le champ {0} est remplacé par l’argument numéro 0, ie la chaîne "rouge".

Un nom de champ de la forme i[j] signifie que le champ sera remplacé par t[j] où t désigne l’objet référencé par l’argument numéro i de la méthode format, ce qui suppose que l’objet t est accessible par l’opération d’indexation (c’est le cas, par exemple, si t est une liste).

De même, un nom de champ de la forme toto[j] signifie que le champ sera remplacé par t[j] où t désigne l’objet référencé par l’argument nommé toto de la méthode format :

1
2
3
4

modele = "le {objets[2]} est {0}"
t=["soleil", "stylo", "papier"]
a = modele.format("rouge", objets=t)
print(a)

5

le papier est rouge

• Ligne 1 : le champ de remplacement {objets[2]}, le nom objets correspond à un argument nommé de l’appel de la méthode format, ici la liste t à la ligne 2.
• Ligne 5 : le champ {objets[2]} est remplacé par t[2]².

Échappement des accolades avec la méthode format¶

L’accolade est un caractère typographique utilisé dans certains domaines. Par exemple, en mathématiques, le contenu d’un ensemble est représenté en le plaçant entre deux accolades. Ainsi, \(E=\{42,421\}\) est l’ensemble formé de deux éléments 42 et 421.

Ainsi, on peut se demander comment, par exemple, créer un gabarit qui affiche un ensemble mathématique ayant deux éléments ? La réponse est que pour représenter une accolade dans un gabarit, on double l’accolade (ce qu’on appelle un échappement) :

1

print("E = {{{}, {}}}".format(42,421))

2

E = {42, 421}

• Ligne 1 : les deux premières accolades permettent de désigner la première accolade ligne 2 ; la paire d’accolade qui suit est un champ de remplacement qui permet de placer l’élément 42 de la ligne 2.

Cela peut servir à créer dynamiquement des gabarits utilisables par format, voici un exemple venant du code source de Panda :

1
2

fmt = '{{x: .{prec:d}g}}'
fmt_str = fmt.format(prec=get_option("display.precision"))

Spécification de formatage avec la méthode format¶

Jusqu’à présent un champ de remplacement (ie une paire d’accolades) dans un gabarit, contient uniquement une référence à un argument de la méthode format, ce qu’on appelle un nom de champ :

1
2
3

modele = "une {1}, une {2} et une {1}"

print(modele.format("pomme", "poire", "prune"))

• Ligne 1 : chaque champ de remplacement contient juste une référence à un argument de l’appel de format.

Mais, cette syntaxe peut être enrichie pour préciser dans chaque champ de remplacement une spécification de formatage, par exemple ici comment on formate une date :

1
2
3

modele = "{0} {2:02}/{1:02}/{3}"
a=modele.format("dimanche", 9, 1, 2030)
print(a)

4

dimanche 01/09/2030

• Ligne 1 : on compte 4 champs de remplacement (les 4 paires d’accolades) ; le 2e et le 3e contiennent une spécification de formatage. Par exemple, dans le champ {1:02}, la partie 02 à droite du symbole : est une spécification de formatage.

À droite du nom du champ, il est possible de placer un « spécification de formatage » qui précise comment la valeur à substituer doit être formatée. Pour signifier une spécification de formatage, après le nom du champ, on place le symbole : (deux-points) ; la spécification de formatage suit le symbole : jusqu’à l’accolade fermante.

En pratique, une spécification de formatage sert surtout à formater des nombres suivant leurs types (entiers, décimaux, etc) et à gérer l’espacement autour du champ de remplacement.

Reprenons l’exemple précédent :

1
2
3

modele = "{0} {2:02}/{1:02}/{3}"
a=modele.format("dimanche", 9, 1, 2030)
print(a)

4

dimanche 01/09/2030

• Ligne 1 : par exemple, le champ {1:02} signifie (ce sera expliqué en détail ultérieurement) que l’argument numéro 1 de la méthode format doit être un nombre et qu’il sera formaté en plaçant un zéro devant le nombre si le nombre n’est constitué que d’un seul chiffre.
• Ligne 4 : l’argument numéro 1, qui vaut 9 comme on le voit ligne 2, est donc formaté sous la forme 09.

1
2
3

modele = "{0} {2:02}/{1:02}/{3}"
a=modele.format("dimanche", 9, 1, 2030)
print(a)

4

dimanche 01/09/2030

1
2
3

modele = "{0} {2:02}/{1:02}/{3}"
a=modele.format("dimanche", 9, 1, 2030)
print(a)

4

dimanche 01/ 9/2030

Partie décimale d’un flottant avec la méthode format¶

Le formatage des valeurs des flottants en Python peut faire apparaître jusqu’à 6 décimales. Le programmeur souhaite parfois n’en faire apparaître qu’un nombre plus réduit (ou plus important). Une spécificateur dit de précision permet de contrôler le nombre de chiffres décimaux nécessaires pour représenter un nombre flottant donné :

1
2
3
4

x=22/7
print(x)
print("{:.2f}".format(x))
print("{:.50f}".format(x))

5
6
7

3.142857142857143
3.14
3.142857142857142793701541449991054832935333251953125

• Ligne 3 : la spécification est ici .2f et contient deux spécificateurs :

  • point suivi de la valeur de la précision (un entier positif)
  • le type f (pour flottant)

• Ligne 7 : l’approximation donnée est incorrecte, par défaut, on ne peut pas espérer plus d’une quinzaine de chiffres significatifs corrects.

Même comportement si le nombre à formater est de type entier ou s’il possède moins de chiffres significatif que la précision demandée :

1
2
3
4
5
6

x=42.5
print(x)
print("{:.2f}".format(x))
x=42
print(x)
print("{:.2f}".format(x))

 7
 8
 9
10

42.5
42.50
42
42.00

La représentation obtenue avec le spécificateur de précision est un arrondi et non pas une troncature, autrement dit, c’est la valeur la plus proche du nombre et ayant le nombre de chiffres indiqué qui est retenue :

1
2
3

x=2/3
print(x)
print("{:.2f}".format(x))

4
5

0.6666666666666666
0.67

• Ligne 5 : si le formatage avait tronqué la valeur, le résultat aurait été 0.66.

Avec une f-chaîne, le contrôle du nombre de décimales se fait comme suit :

x=22/7
print(f"{x:.2f}")

d’où :

1

3.14

Fenêtre de champ avec la méthode format¶

On souhaite parfois placer un espacement autour d’un champ de remplacement, souvent pour des raisons d’alignement vertical. Par exemple, pour obtenir les chaînes formatées suivantes

1
2
3

coloration : blanc        → noir
taille     : gigantesque  → minuscule
vitesse    : lent         → rapide

• Lignes 1-3 : on observe que les mots correspondants sont alignés verticalement ainsi que les séparateurs : et →.

Un gabarit sans spécificateur de formatage permet difficilement d’obtenir le même effet d’alignement vertical :

1
2
3
4
5

modele = "{2} : {0} → {1}"

print(modele.format("blanc", "noir", "coloration"))
print(modele.format("gigantesque", "minuscule", "taille"))
print(modele.format("lent", "rapide", "vitesse"))

6
7
8

coloration : blanc → noir
taille : gigantesque → minuscule
vitesse : lent → rapide

Maintenant, regardons cet exemple pour illustrer la syntaxe définissant une largeur du champ de remplacement :

1
2
3
4

fruit = "orange"
print(".....123456789012.....")
s=".....{:12}.....".format(fruit)
print(s)

5
6

.....123456789012.....
.....orange      .....

On voit, dans la sortie, que la valeur du champ de remplacement, la chaîne orange, est placée dans une « fenêtre » de largeur 12.

Ainsi, pour placer la valeur d’une expression, disons expr, dans un fenêtre de largeur, par exemple, w, le champ de remplacement à placer dans la f-chaîne aura la syntaxe {expr :w}, par exemple.

La largeur est le nombre total de caractères. Par défaut, des caractères " " (espace) constituent le « bourrage » de la fenêtre de largeur donnée.

Le formatage présenté tout au début du paragraphe a été obtenu avec le code suivant :

1
2
3
4
5

modele = "{2:10} : {0:12} → {1}"

print(modele.format("blanc", "noir", "coloration"))
print(modele.format("gigantesque", "minuscule", "taille"))
print(modele.format("lent", "rapide", "vitesse"))

6
7
8

coloration : blanc        → noir
taille     : gigantesque  → minuscule
vitesse    : lent         → rapide

Noter que, parfois, le terme de champ se réfère autant à une valeur de remplacement qu’à l’emplacement de cette valeur dans la chaîne formatée.

Voyons sur un exemple comment le remplissage se fait en fonction de la dimension de l’objet qui remplace :

1
2
3
4

modele = "~~~~~{:10}~~~~~"
print(modele.format(''))
print(modele.format("Hello!"))
print(modele.format("Hello World!"))

5
6
7

~~~~~          ~~~~~
~~~~~Hello!    ~~~~~
~~~~~Hello World!~~~~~

• Ligne 1 : un champ de 10 caractères sera inséré.
• Ligne 2 : La ligne-étalon pour comparer avec les lignes suivantes.
• Ligne 3 : le champ est rempli des 6 caractères du mot Hello! et de 4 espaces (cf. la ligne-étalon)
• Ligne 4 et 7 : si le remplacement déborde le champ, le remplacement complet est effectué et aucun blanc n’est placé. Dans ce cas, le champ n’a eu aucun effet visible.

Par défaut, chaque élément est placé à gauche du champ. S’il reste de la place dans le champ, le formatage y place des espaces. La largeur du champ est le nombre total de caractères du conteneur. Si l’objet à placer dans le champ est plus large que la largeur du champ, l’objet se place normalement et le champ n’est pas visible.

Alignement, remplissage avec la méthode format¶

Par défaut, l’alignement est fait au début du champ, c’est-à-dire à gauche. Il est possible de modifier ce comportement en utilisant un des spécificateurs d’alignement > ou ^ :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

modele = "----|{:20}|----"
print(modele.format("bonjour"))

modele = "----|{:>20}|----"
print(modele.format("bonjour"))

modele = "----|{:^20}|----"
print(modele.format("bonjour"))

modele = "----|{:<20}|----"
print(modele.format("bonjour"))

12
13
14
15

----|bonjour             |----
----|             bonjour|----
----|      bonjour       |----
----|bonjour             |----

• Ligne 1 : rappel du comportement par défaut : alignement à gauche.
• Ligne 4 : spécificateur > pour obtenr un alignement à droite du champ.
• Ligne 7 : spécificateur ^ pour obtenr un alignement centré dans le champ
• Ligne 10 : par homogénéité, le comportement par défaut a aussi son spécificateur : <.

Les parties invisibles d’un champ sont, par défaut, remplies de caractères espace.

< est le spécificateur du comportement par défaut.

Nom : .......Nobel........
Prénom : .......Alfred.......

1
2
3
4
5
6
7
8

modele = "hier {:_<20} demain"
print(modele.format("maintenant"))

modele = "hier {:_>20} demain"
print(modele.format("maintenant"))

modele = "hier {:_^20} demain"
print(modele.format("maintenant"))

 9
10
11

hier maintenant__________ demain
hier __________maintenant demain
hier _____maintenant_____ demain

1
2

modele = "----|{:_20}|----"
print(modele.format("bonjour"))

3
4
5
6

Traceback (most recent call last):
File "a.py", line 2, in <module>
  print(modele.format("bonjour"))
    ValueError: Invalid format specifier

1
2

modele = "hier {:_<20} demain"
print(modele.format(""))

3

hier ____________________ demain

1
2

modele = "hier {:}<20} demain"
print(modele.format(""))

3
4
5
6

Traceback (most recent call last):
  File "a.py", line 2, in <module>
    print(modele.format(""))
ValueError: Single '}' encountered in format string

Champs pour des nombres avec la méthode format¶

Le principe de la fenêtre de champ pour un nombre est le même que pour n’importe quelle chaîne : un nombre (vu comme chaîne de caractères) est placé dans une fenêtre ayant une certain largeur, avec la possibilité de choisir entre un placement à gauche, à droite ou au centre de la fenêtre. Cela permet d’obtenir des effets d’alignement.

1
2
3
4
5

addition="{:>6}\n+{:>5}\n+{:>5}\n------\n{:>6}"
x=10
y=2030
z=8
print(addition.format(x,y,z, x+y+z))

 6
 7
 8
 9
10

    10
+ 2030
+    8
------
  2048

• Lignes 1 : tous les nombres sont alignés à droite dans un champ de largeur 6 ou 5 (à cause du signe +).
• Ligne 6-10 : les nombres sont convenablement alignés.

Il était même plus lisible d’utiliser une chaîne triple :

addition="""\
{:>6}
+{:>5}
+{:>5}
------
{:>6}"""
x=10
y=2030
z=8
print(addition.format(x,y,z, x+y+z))

Signe et premier chiffre avec la méthode format¶

C’est une option de remplissage assez rare d’utilisation et permettant de répéter un caractère entre le signe d’un nombre et son premier chiffre :

1
2

modele="____{:X=9}____{:X=3}____{:X=9}____"
print(modele.format(42, 421, -42))

3

____XXXXXXX42____421____-XXXXXX42____

• Ligne 1 : par exemple, dans le dernier champ de remplacement {:X=9}, un champ de largeur 9 est réservé pour placer un nombre ainsi que son signe. L’espace entre le signe éventuel et le premier chiffre du nombre est rempli par des caractères X. Ainsi, dans notre exemple, moins de 9 caractères vaudront "X", plus précisément, il y en aura 6=9-3 (le nombre -42 utilise 3 caractères).

L’usage le plus courant est de placer des zéros. Cet usage tellement usuel qu’il est aussi rendu possible par le spécificateur de type 0n où n est un entier littéral qui indique le nombre total de chiffres à formater :

1
2
3
4
5

modele="Agent {:0=3}"
print(modele.format(7))

modele="Agent {:03}"
print(modele.format(7))

qui affiche

1
2

Agent 007
Agent 007

Formatage d’un flottant avec la méthode format¶

Le spécificateur de formatage le plus usuel pour les flottants est f :

1
2
3

x=22/7
print(x)
print("{:f}".format(x))

4
5

3.142857142857143
3.142857

Le formatage limite la partie décimale a au plus 6 décimales.

La dernière décimale du formatage peut avoir subi un arrondi :

1
2
3

x=3.141592653589793
print(x)
print("{:f}".format(x))

4
5

3.141592653589793
3.141593

Appliquer un formatage flottant à un entier fera apparaître 6 décimales valant toutes 0 :

1

print("{:f}".format(2030))

2

2030.000000

Zéros initiaux avec la méthode format¶

Considérons une date telle que 01/09/2030. On observe que le nombre 1 ou le nombre 9 sont précédés d’un chiffre 0. Il existe une option de formatage qui permet de placer un certain nombre de zéros avant un nombre présent dans une chaîne.

Voici un exemple

1
2

modele="____{:09}________{:02}_______"
print(modele.format(42, 421))

3

____000000042________421_______

• Ligne 1 : la spécificateur 09 indique

  • qu’un champ de 9 caractères de large et destiné à recevoir un nombre est créé
  • que le formatage placera le nombre dans le champ et le fera précéder d’autant de zéros que nécessaire pour remplir le champ.

• Ligne 2 : si le nombre déborde du champ, aucun zéro n’est placé.

Si le nombre est négatif, les zéros sont placés, comme on s’y attend, entre le signe moins et le premier chiffre :

1
2

modele="____{:09}________{:02}_______"
print(modele.format(-42, -421))

3

____-00000042________-421_______

Conversion dans certaines bases avec la méthode format¶

Par défaut, les nombres sont formatés en base 10. On souhaite parfois que le nombre soit converti dans l’une des bases suivantes : 2, 8 ou 16. Pour cela il suffit de placer, en dernière position de la spécification de formatage un code de conversion donné dans le tableau suivant :

Voici un exemple d’utilisation de chaque spécificateur :

1
2
3
4
5
6

print("{:b}".format(42))
print("{:o}".format(42))
print("{:d}".format(42))
print("{:}".format(42))
print("{:x}".format(42))
print("{:X}".format(42))

 7
 8
 9
10
11
12

101010
52
42
42
2a
2A

101010

52

42

2a

2A

• Lignes 7-12 : noter qu’il n’y a aucune marque dans la chaîne qui montre en quelle base le nombre est représenté.
• Lignes 3 et 4 :le spécificateur d correspond au comportement par défaut et peut être omis.
• Lignes 5-6 et 11-12 : noter que la seule différence porte sur la casse majuscule/minuscule des chiffres en lettres.

Le spécificateur x formate les chiffres hexadécimaux sous forme de lettres minuscules (a, b, c, d, e, f) et le spécificateur X formate les chiffres hexadécimaux sous forme de lettres majuscules (A, B, C, D, E, F).

Un spécificateur de conversion doit toujours être le dernier spécificateur (autrement dit, le plus à droite) de la spécification de formatage.

b2 = 0b101010
b8 = 0o52
b16 = 0x2a
B16 = 0X2A

print(b2, b8, b16, B16)

42 42 42 42

fmt = "{0:#b}"
x = 42
s = fmt.format(x)
print(s)

0b101010

1
2
3
4
5

print("{0:#b}".format(42))
print("{0:#o}".format(42))
print("{0:#d}".format(42))
print("{0:#x}".format(42))
print("{0:#X}".format(42))

 6
 7
 8
 9
10

0b101010
0o52
42
0x2a
0X2A

Notation scientifique avec la méthode format¶

Python permet de représenter des constantes flottantes avec la notation scientifique stricte, à savoir \(a\times 10^n\) où \(a\) est un flottant, appelé parfois mantisse dont la partie entière au signe près est un flottant entre 1 (inclus) et 10 (exclu).

Le spécificateur de formatage en notation scientifique est e ou E (cette lettre rappelle la première lettre du mot exposant):

1
2
3

print("{:f}".format(2030.4248))
print("{:e}".format(2030.4248))
print("{:E}".format(2030.4248))

4
5
6

2030.424800
2.030425e+03
2.030425E+03

La précision de la mantisse est de 6 décimales. L’exposant est placé dans un champ de 2 chiffres. Le spécificateur e formate la lettre e en minuscule, et le spécificateur E formate en majuscule.

1

print("{:.2e}".format(2030.4248))

2

2.03e+03

Signe + avec la méthode format¶

a = -42
b =  2024

1
2
3
4

modele="{} = {: }"

print(modele.format("a", -42))
print(modele.format("b", 2024))

1
2

modele="Rennes : {:+}°C\nMoscou : {:+}°C"
print(modele.format(42, -24))

3
4

Rennes : +42°C
Moscou : -24°C

1

print(+42)

2

42

Séparateur de milliers avec la méthode format¶

Pour des raisons de lisibilité, l’usage veut qu’on formate des nombres longs en séparant les chiffres par groupes de trois. Un spécificateur permet cette séparation :

1
2
3
4
5
6
7

p = -6542120359.4521263
s = f"prix = {p:,} euros"
print(s)

p = 421
s = f"prix = {p:,} euros"
print(s)

8
9

prix = -6,542,120,359.4521265 euros
prix = 421 euros

Le spécificateur consiste juste en une virgule :

,

Le séparateur est le séparateur utilisé dans le monde anglo-saxon, à savoir une virgule.

La partie décimale n’est pas formatée par groupe de 3 chiffres et il ne semble pas qu’un spécificateur le permette.

Si le nombre a moins de trois chiffres, aucune action de formatage spécifique n’est réalisée.

1
2
3
4
5

import locale
ma_locale = locale.setlocale(locale.LC_ALL, '')
print(ma_locale)

print("{:n}".format(2099.236569633))

6
7

fr_FR.UTF-8
2 099,24

1
2
3
4

import locale
ma_locale = locale.setlocale(locale.LC_ALL, '')

print("{:.10n}".format(2099.236569633))

5

2 099,23657

Pourcentage avec la méthode format¶

Le spécificateur % permet de formater un nombre en pourcentage.

1
2

s = f"{3/4:%}"
print(s)

3

75.000000%

• On notera que le séparateur décimal est ici un point et non une virgule.

Plus précisément, si \(x\) est le nombre à formater, le formatage consiste :

• à générer en flottant le pourcentage \(100x\)
• à adjoindre le symbole %.

L’intérêt semble limité.

Contexte d’utilisation de la méthode format¶

Une chaîne formatée est une chaîne comme les autres. Elle n’est pas exclusivement destinée à être affichée, bien que ce sera assez fréquent en pratique. Une chaîne formatée possède toutes les propriétés d’une chaîne, par exemple une longueur :

1
2
3
4
5
6
7
8

modele = "Son nom est {} et il a {} ans."

naissance= 2000
aujourdhui= 2030

a = modele.format("Arthur", aujourdhui - naissance)
print(len(a))
print(a)

 9
10

34
Son nom est Arthur et il a 30 ans.

1
2
3
4
5
6

modele = "{0} = {2}, {1} = {3} => {0} + {1} = {4}"

x=42
y=18
print(modele.format("x", "y", x, y, x+y))
print(modele.format("too", "titi", x, y, x+y))

7
8

x = 42, y = 18 => x + y = 60
too = 42, titi = 18 => too + titi = 60

1
2
3
4
5

modele = "{0} = {2}, {1} = {3} => {0} + {1} = {4}"

x=42
y=18
print("x =", x, ", y =", y, "=> x + y =", x+y)

6

x = 42 , y = 18 => x + y = 60

 ---------------------------------------------------------------------
| 1 x  1 =   1| 2 x  1 =   2| 3 x  1 =   3| 4 x  1 =   4| 5 x  1 =   5|
| 1 x  2 =   2| 2 x  2 =   4| 3 x  2 =   6| 4 x  2 =   8| 5 x  2 =  10|
| 1 x  3 =   3| 2 x  3 =   6| 3 x  3 =   9| 4 x  3 =  12| 5 x  3 =  15|
| 1 x  4 =   4| 2 x  4 =   8| 3 x  4 =  12| 4 x  4 =  16| 5 x  4 =  20|
| 1 x  5 =   5| 2 x  5 =  10| 3 x  5 =  15| 4 x  5 =  20| 5 x  5 =  25|
| 1 x  6 =   6| 2 x  6 =  12| 3 x  6 =  18| 4 x  6 =  24| 5 x  6 =  30|
| 1 x  7 =   7| 2 x  7 =  14| 3 x  7 =  21| 4 x  7 =  28| 5 x  7 =  35|
| 1 x  8 =   8| 2 x  8 =  16| 3 x  8 =  24| 4 x  8 =  32| 5 x  8 =  40|
| 1 x  9 =   9| 2 x  9 =  18| 3 x  9 =  27| 4 x  9 =  36| 5 x  9 =  45|
| 1 x 10 =  10| 2 x 10 =  20| 3 x 10 =  30| 4 x 10 =  40| 5 x 10 =  50|
---------------------------------------------------------------------
| 6 x  1 =   6| 7 x  1 =   7| 8 x  1 =   8| 9 x  1 =   9|10 x  1 =  10|
| 6 x  2 =  12| 7 x  2 =  14| 8 x  2 =  16| 9 x  2 =  18|10 x  2 =  20|
| 6 x  3 =  18| 7 x  3 =  21| 8 x  3 =  24| 9 x  3 =  27|10 x  3 =  30|
| 6 x  4 =  24| 7 x  4 =  28| 8 x  4 =  32| 9 x  4 =  36|10 x  4 =  40|
| 6 x  5 =  30| 7 x  5 =  35| 8 x  5 =  40| 9 x  5 =  45|10 x  5 =  50|
| 6 x  6 =  36| 7 x  6 =  42| 8 x  6 =  48| 9 x  6 =  54|10 x  6 =  60|
| 6 x  7 =  42| 7 x  7 =  49| 8 x  7 =  56| 9 x  7 =  63|10 x  7 =  70|
| 6 x  8 =  48| 7 x  8 =  56| 8 x  8 =  64| 9 x  8 =  72|10 x  8 =  80|
| 6 x  9 =  54| 7 x  9 =  63| 8 x  9 =  72| 9 x  9 =  81|10 x  9 =  90|
| 6 x 10 =  60| 7 x 10 =  70| 8 x 10 =  80| 9 x 10 =  90|10 x 10 = 100|
 ---------------------------------------------------------------------

   45
+ 253
+ 940
-----
 1238

Formatage par défaut d’un objet¶

Jusqu’à présent les remplacements effectués dans un gabarit portent sur des chaînes de caractères ou sur des nombres entiers ou flottants :

1
2
3

modele = "{} {:02}/{:02}/{}"
a=modele.format("dimanche", 1, 9, 2030)
print(a)

4

dimanche 01/09/2030

• Les objets formatés (qui correspondent aux accolades) sont ici soit une chaîne (« dimanche ») soit des entiers comme 2030.

Mais que se passe-t-il si l’argument correspondant à un champ de remplacement est d’un autre type ? Voyons un exemple :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Point:
    def __init__(self, x, y, name):
        self.x = x
        self.y = y
        self.name = name

a = Point(5, 8, "A")

gabarit = "Le point {0.name} ... {0}".format(a)
print(gabarit)
print(str(a))

12
13

Le point A ... <__main__.Point object at 0xb71842ac>
<__main__.Point object at 0xb71842ac>

Lorsqu’un argument, disons A, de la méthode format doit être remplacé dans un gabarit, Python recherche une méthode A.__format__. Si aucune telle méthode n’a été explicitement définie alors le remplacement est effectué par str(A). Par défaut, str(A) est une chaîne peu lisible pour un utilisateur humain, cf. ligne 12 ou 13.

D’autre part, comme le remplacement est effectué par str(A), il est possible de placer dans le champ de remplacement une spécification de formatage valide pour une chaîne. Voici un exemple artificiel :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class Point:
    def __init__(self, x, y, name):
        self.x = x
        self.y = y
        self.name = name

a = Point(5, 8, "A")

gabarit = "Le point {0.name} ... {0:X^60}".format(a)
print(gabarit)

11

Le point A ... XXXXXXXXXXX<__main__.Point object at 0xb715528c>XXXXXXXXXXXX

La spécification de formatage X^60 (ligne 9) a entouré de lettres majuscules X le champ de remplacement dans un champ de largeur 60. Cette utilisation est possible mais ici de peu d’intérêt.

Formatage personnalisé d’un objet¶

Montrons sur un exemple comment on peut définir une méthode spécifique de formatage aux objets d’une classe :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Point:
    def __init__(self, x, y, name):
        self.x = x
        self.y = y
        self.name = name

    def __format__(self, format_spec):
        if format_spec == "x":
            return "x_{0.name} = {0.x}".format(self)
        if format_spec == "y":
            return "y_{0.name} = {0.y}".format(self)
        return "{0.name} =  ({0.x}, {0.y})".format(self)

a = Point(9, 8, "A")
print("Le point {0}".format(a))
print("L'abscisse de {0} vaut {1:x}".format(a.name, a))

17
18

Le point A =  (9, 8)
L'abscisse de A vaut x_A = 9

On définit (lignes 7-12) dans la classe Point une méthode __format__. Lorsqu’un champ de remplacement se réfère à un objet de type Point (lignes 14-16), le remplacement est effectué par ce que renvoie la méthode __format__. Un champ de remplacement peut même disposer après le symbole : comme dans le champ {0.x} d’un spécificateur de formatage sous la forme d’une chaîne format_spec (ligne 7) et qui est passé en argument (le x à la ligne 16) à la méthode __format__.

Remplacement par un attribut d’argument¶

Un champ de remplacement peut référer un attribut d’un des arguments de la méthode format. Ainsi, soit le code :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Point:
    def __init__(self, x, y, name):
        self.x = x
        self.y = y
        self.name = name

a = Point(5, 8, "A")
b = Point(2, -1, "B")
modele = "x_{0.name} = {0.x}\ny_{1.name} = {1.y}"
s = modele.format(a, b)

print(s)

13
14

x_A = 5
y_B = -1

Tout objet de la classe Point possède trois attributs : x, y et name. Dans un gabarit, tout champ de remplacement (entre accolades) peut référer à l’un de ces attributs. Par exemple, 1.y réfère à l’attribut y du 2e argument de format.

Si l’ordre des champs de remplacement correspond à l’ordre des arguments, la présence des numéros n’est pas indispensable :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Point:
    def __init__(self, x, y, name):
        self.x = x
        self.y = y
        self.name = name

a = Point(5, 8, "A")
b = Point(2, -1, "B")

s = "{.name} et {.name}".format(a, b)

print(s)

13

A et B

Positions après décompression d’une liste¶

Les arguments de la méthode format peuvent être récupérés après une décompression de liste avec la syntaxe *L où L est une liste, comme pour n’importe quelle fonction admettant une liste à décompresser en argument. Tout numéro d’argument dans un nom de remplacement se réfère aux numéros obtenus après décompression.

1
2
3
4

modele = "le {0} de couleurs {2}, {1} et {2}"
couleurs=["rouge", "jaune", "vert"]
a = modele.format("drapeau", *couleurs)
print(a)

5

le drapeau de couleurs jaune, rouge et jaune

• Ligne 1 : le gabarit se réfère aux arguments numéros 0, 1 et 2.
• Ligne 3 : après décompression de l’argument couleurs, c’est comme si la liste des arguments de format était : "drapeau", "rouge", "jaune", "vert". La substitution se poursuit comme avec des arguments positionnels.

Nombre d’accolades¶

Considérons un gabarit Python de formatage, par exemple

modele = "une {1}, une {2} et une {0}"

Si \(n\) est le plus grand numéro apparaissant entre des accolades (dans l’exemple, c’est 2), il doit y avoir au moins \(n+1\) arguments dans l’appel de la méthode format, par exemple

modele.format("pomme", "poire", "prune")

Sinon, une exception est levée :

modele = "une {1}, une {2} et une {0}"
ch=modele.format("pomme", "poire")
print(ch)

Traceback (most recent call last):
  File "a.py", line 2, in <module>
    ch=modele.format("pomme", "poire")
IndexError: tuple index out of range

D’autre part, si une paire d’accolades est vide dans le gabarit, toutes les paires d’accolades suivantes doivent être également vides sinon on reçoit un message d’erreur :

1

print("{}{1}".format(42,17))

2
3
4
5
6

Traceback (most recent call last):
  File "vide_et_non_vide.py", line 1, in <module>
    print("{}{1}".format(42,17))
ValueError: cannot switch from automatic field numbering
to manual field specification

Enfin, bien que semblant avoir peu d’intérêt, il n’est pas interdit que le gabarit ne reçoive aucune accolade et que pourtant format reçoive des arguments :

1
2

s = "19 janvier 2038".format(42)
print(s)

3

19 janvier 2038

Bien sûr, cela n’a aucune action sur le gabarit.

Cela peut être utile lorsque la méthode format est appliquée à des chaînes générées automatiquement.

Spécification de formatage et champ anonyme¶

Le signe : entre des accolades marque la présence d’une spécification de formatage. À gauche de : figure en principe une référence à l’argument de la méthode format qui va servir de remplacement. La référence à l’argument n’est pas nécessaire si les remplacements s’effectuent suivant l’ordre où les arguments apparaissent écrits dans l’appel :

1
2
3

modele = "{} {:02}/{:02}/{}"
a=modele.format("dimanche", 1, 9, 2030)
print(a)

4

dimanche 01/09/2030

• Ligne 1 : tous les champs sont anonymes puisque rien ne précède le séparateur :
• ligne 2 : les remplacements sont faits dans l’ordre des arguments de la méthode format : "dimanche" puis 1 puis 9 et 2030.

Cumuls de spécificateurs avec la méthode format¶

Une spécification de formatage peut contenir plusieurs spécificateurs successifs. Voici un exemple commenté :

1
2
3

modele = "1000 * pi = {:~^ 20,.2f}"
print(modele.format(1000 * 22/7))
print(modele.format(1000 * 333/106))

4
5

1000 * pi = ~~~~~ 3,142.86~~~~~~
1000 * pi = ~~~~~ 3,141.51~~~~~~

Dans l’exemple, il n’y a qu’un champ de remplacement. Sa spécification est :~^ 20,.2f qui est composée de six spécificateurs :

• un spécificateur de remplissage centré (cf. le spécificateur ^) par des caractères ~
• l’espace (résultat : place un unique espace avant un nombre positif)
• un champ de largeur 20
• le séparateur de milliers (spécificateur virgule)
• précision (2 décimales)
• type flottant

L’ordre des spécificateurs n’est pas arbitraire ; de gauche à droite, on trouve des spécificateurs

• d’alignement (<, ^, > et plus rarement =), précédé d’un unique caractère de remplissage
• de signe (+ ou espace)
• de préfixe de conversion dans certaines bases (#)
• de remplissage par des zéros (0)
• de largeur de champ (un entier)
• de groupement par blocs de 3 chiffres de la partie entière (une virgule)
• de précision (de la forme .n où n est un entier)
• de type (par exemple f, x, n ou %)

Les spécificateurs sont optionnels, certains peuvent être omis (comme le type). Certains spécificateurs ne s’appliquent qu’à des nombres, voire des nombres d’un certain type. La plupart du temps, le bon sens permet de trancher.

Champs emboîtés avec la méthode format¶

Considérons le gabarit suivant :

gabarit= "__{0:.>20}____{1:-^10}__"

Voici un exemple d’utilisation de ce gabarit :

gabarit= "__{0:.>20}____{1:-^10}__"
print(gabarit.format(2030, 2038))

__................2030____---2038---__

Décrivons ce gabarit. Il contient deux champs de remplacement, à savoir {0:.>20}__ et {1:-^10} ; ces champs sont séparés. Chacun de ces champs est composé

• de la référence à l’argument de la méthode format (0 puis 1)
• du séparateur :
• d’une spécification de formatage (.>20 et -^10).

A priori, des champs de remplacement sont toujours séparés. Cependant, il est possible, sous certaines conditions, de placer des champs de remplacement dans une spécification de format :

gabarit0= "__{0:{2}}____{1:{3}}__"
print(gabarit0.format(2030, 2038, ".>20", "-^10"))

• Ligne 1 : le premier champ de remplacement {0:{2}} a une spécification {2} qui contient un autre champ de remplacement (cf. les accolades). On parle alors de champs emboîtés.

1
2

gabarit0= "__{0:{2}}____{1:{3}}__"
print(gabarit0.format(2030, 2038, ".>20", "-^10"))

3

__................2030____---2038---__

1
2
3
4

gabarit0="__{0:{2}}____{1:{3}}__"
gabarit= gabarit0.replace("{2}",".>20").replace("{3}","-^10")
print(gabarit)
print(gabarit.format(2030, 2038))

5
6

__{0:.>20}____{1:-^10}__
__................2030____---2038---__

1
2
3
4

modele="{:.{}f}"

for prec in [0, 3, 6, 9]:
    print(modele.format(22/7,prec))

5
6
7
8

3
3.143
3.142857
3.142857143

1
2
3
4

modele = "__{0:{1}{2}{3}{4}{5}}__"
x=2038
print(modele.format(x, '?', '>', ' ', 42,','))
print(modele.format(x, '~', '^', '+', 20,'e'))

5
6

__???????????????????????????????????? 2,038__
__~~~+2.038000e+03~~~~__

Drapeau de conversion avec la méthode format¶

Soit le code :

1

print("{0}{1:.^20}".format("Hello", "Rose"))

2

Hello........Rose........

La chaîne "{0}{1:.^20}" comporte 2 champs de remplacement. Examinons par exemple le 2e champ : {1:.^20}. Il comporte deux composantes :

• un numéro d’argument : 1
• un spécificateur de formatage : .^20

Cette syntaxe peut-être enrichie. Pour que mes explications ne soient pas trop abstraites, voici la nouveauté sur un exemple :

print("{0}{1!a:.^20}".format("Hello", "Rose"))

qui affiche

Hello.......'Rose'.......

Un champ de remplacement peut disposer d’une troisième composante : un drapeau de conversion. Ce drapeau est placé en 2e position, entre le représentant de l’argument et avant les deux-points qui précèdent le spécificateur de formatage, cf. ci-dessus, les deux caractères !a.

Un drapeau peut prendre une des trois formes suivantes :

!s ou !r ou !a

Voici un exemple :

1
2
3

print("{0}{1!s:.^20}".format("Hello", "Rose"))
print("{0}{1!r:.^20}".format("Hello", "Rose"))
print("{0}{1!a:.^20}".format("Hello", "Rosé"))

4
5
6

Hello........Rose........
Hello.......'Rose'.......
Hello.....'Ros\xe9'......

Lorqu’un objet X à remplacer est associé à un drapeau de conversion, l’objet X est converti en une chaîne S et c’est la chaîne qui fait l’objet du remplacement. La chaîne S dépend du drapeau :

• si le drapeau est !s alors S est str(X)
• si le drapeau est !r alors S est repr(X)
• si le drapeau est !a alors S est ascii(X) où ascii est une fonction de la bibliothèque standard (par exemple, en français, ça réécrit avec un échappement s’il y a un accent).

Dans les cas usuels, le drapeau !s n’a pas d’action :

1
2

print("{0}{1!s:.^20}".format("Hello", "Rose"))
print("{0}{1:.^20}".format("Hello", "Rose"))

3
4

Hello........Rose........
Hello........Rose........

Il se peut, bien sûr, que le drapeau soit seul dans le champ de remplacement :

1

print("C'est {!a}".format("codé"))

2

C'est 'cod\xe9'

[5, 12, 8]    est une liste
[50, 120, 80] est une liste

1
2
3
4
5
6
7

L = [5, 12, 8]
M = [50, 120, 80]

s = """{:13} est une liste
{:13} est une liste"""

print(s.format(L, M))

8
9

    print(s.format(L, M))
TypeError: unsupported format string passed to list.__format__

L = [5, 12, 8]
M = [50, 120, 80]

s = """{!s:13} est une liste
{!s:13} est une liste"""

print(s.format(L, M))

[5, 12, 8]    est une liste
[50, 120, 80] est une liste

Intérêt du drapeau de conversion¶

Soit un appel de la méthode format de la forme gabarit.format où gabarit est une chaîne. Si gabarit admet un champ de remplacement par un objet X alors le champ est remplacé par le retour d’un appel de X.__format__. Parfois ce comportement par défaut n’est pas souhaité et pour l’éviter, on peut placer un drapeau dans le champ de remplacement.

Par exemple :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Point:
    def __init__(self, x, y, name):
        self.x = x
        self.y = y
        self.name = name

    def __format__(self, format_spec):
        if format_spec == "x":
            return "x_{0.name} = {0.x}".format(self)
        if format_spec == "y":
            return "y_{0.name} = {0.y}".format(self)
        return "{0.name} =  ({0.x}, {0.y})".format(self)

a = Point(9, 8, "A")
print("Le point {0}".format(a))
print(str(a))
print("Le point {0!s}".format(a))

18
19
20

Le point A =  (9, 8)
<__main__.Point object at 0xb713d28c>
Le point <__main__.Point object at 0xb713d28c>

• Pas de drapeau : la méthode __format__ de Point est appelée
• Le drapeau !s empêche l’appel de la méthode __format__ et le champ est remplacé par str(a)

Troncature avec la méthode format¶

On peut vouloir qu’un champ de remplacement reçoive une chaîne dont on ne garde qu’un certain nombre des premiers caractères :

1
2
3

semaine=['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche']
for i in range(7):
    print("{0:.3} {1}/10/2030".format(semaine[i], i+1))

 4
 5
 6
 7
 8
 9
10

lun 1/10/2030
mar 2/10/2030
mer 3/10/2030
jeu 4/10/2030
ven 5/10/2030
sam 6/10/2030
dim 7/10/2030

• Lignes 1-2 : seuls les 3 premiers caractères du jour de la semaine seront utilisés pour remplacer le champ.

Cette utilisation de troncature semble être assez rare.

La même syntaxe sert à contrôler le nombre de décimales d’un flottant.

Concaténation avec la méthode format¶

Le formatage de chaînes permet accessoirement de concaténer ou de joindre des chaînes

1
2
3
4
5

modele = "{}{}{}"
print(modele.format("Uni","Ver","Sel"))

modele = "{}-{}-{}"
print(modele.format("Uni","Ver","Sel"))

6
7

UniVerSel
Uni-Ver-Sel

Documentation sur la méthode format¶

Voici les liens vers la documentation officielle sur le formatage avec la méthode format :

• le formatage avec la méthode format
• la méthode spéciale __format__
• des exemples de traduction de chaînes formatées de style classique en des chaînes formatées avec la méthode format.