Introduction
Cette section est une légère digression, mais lorsqu'on travaille avec des données, on a souvent besoin de produire une sortie structurée (tableaux, etc.). Par exemple :
Nom Actions Prix
---------- ---------- -----------
AA 100 32,20
IBM 50 91,10
CAT 150 83,44
MSFT 200 51,23
GE 95 40,37
MSFT 50 65,10
IBM 100 70,44
Formatage de chaînes de caractères
Une manière de formater des chaînes de caractères en Python 3.6+ est d'utiliser les f-strings.
>>> nom = 'IBM'
>>> actions = 100
>>> prix = 91.1
>>> f'{nom:>10s} {actions:>10d} {prix:>10.2f}'
' IBM 100 91,10'
>>>
La partie {expression:format} est remplacée.
Elle est couramment utilisée avec print.
print(f'{nom:>10s} {actions:>10d} {prix:>10.2f}')
Codes de formatage
Les codes de formatage (après le : à l'intérieur des {}) sont similaires à ceux de printf() en C. Les codes courants sont les suivants :
d Entier décimal
b Entier binaire
x Entier hexadécimal
f Flottant sous la forme [-]m.dddddd
e Flottant sous la forme [-]m.dddddde+-xx
g Flottant, mais utilisation sélective de la notation scientifique
s Chaîne de caractères
c Caractère (à partir d'un entier)
Les modificateurs courants ajustent la largeur du champ et la précision décimale. Voici une liste partielle :
:>10d Entier aligné à droite dans un champ de 10 caractères
:<10d Entier aligné à gauche dans un champ de 10 caractères
:^10d Entier centré dans un champ de 10 caractères
:0.2f Flottant avec une précision de 2 chiffres
Formatage de dictionnaires
Vous pouvez utiliser la méthode format_map() pour appliquer le formatage de chaînes de caractères à un dictionnaire de valeurs :
>>> s = {
'nom': 'IBM',
'actions': 100,
'prix': 91.1
}
>>> '{nom:>10s} {actions:10d} {prix:10.2f}'.format_map(s)
' IBM 100 91,10'
>>>
Elle utilise les mêmes codes que les f-strings mais prend les valeurs dans le dictionnaire fourni.
Méthode format()
Il existe une méthode format() qui peut appliquer un formatage à des arguments positionnels ou nommés.
>>> '{nom:>10s} {actions:10d} {prix:10.2f}'.format(nom='IBM', actions=100, prix=91.1)
' IBM 100 91,10'
>>> '{:>10s} {:10d} {:10.2f}'.format('IBM', 100, 91.1)
' IBM 100 91,10'
>>>
Franchement, format() est un peu verbeux. Je préfère les f-strings.
Formatage du style C
Vous pouvez également utiliser l'opérateur de formatage %.
>>> 'La valeur est %d' % 3
'La valeur est 3'
>>> '%5d %-5d %10d' % (3,4,5)
' 3 4 5'
>>> '%0.2f' % (3.1415926,)
'3,14'
Cela nécessite un seul élément ou un tuple à droite. Les codes de formatage sont également inspirés de printf() en C.
Nota : C'est le seul formatage disponible pour les chaînes d'octets.
>>> b'%s a %d messages' % (b'Dave', 37)
b'Dave a 37 messages'
>>> b'%b a %d messages' % (b'Dave', 37) ## %b peut être utilisé à la place de %s
b'Dave a 37 messages'
>>>
Exercice 2.8 : Comment formater des nombres
Un problème courant lors de l'affichage de nombres est de spécifier le nombre de décimales. Une manière de résoudre ce problème est d'utiliser les f-strings. Essayez ces exemples :
>>> valeur = 42863.1
>>> print(valeur)
42863.1
>>> print(f'{valeur:0.4f}')
42863.1000
>>> print(f'{valeur:>16.2f}')
42863.10
>>> print(f'{valeur:<16.2f}')
42863.10
>>> print(f'{valeur:*>16,.2f}')
*******42,863.10
>>>
La documentation complète sur les codes de formatage utilisés dans les f-strings peut être trouvée ici. Le formatage est également parfois effectué à l'aide de l'opérateur % des chaînes de caractères.
>>> print('%0.4f' % valeur)
42863.1000
>>> print('%16.2f' % valeur)
42863.10
>>>
La documentation sur les différents codes utilisés avec % peut être trouvée ici.
Bien que cela soit couramment utilisé avec print, le formatage de chaînes n'est pas lié à l'affichage. Si vous voulez enregistrer une chaîne de caractères formatée. Assignez simplement la chaîne à une variable.
>>> f = '%0.4f' % valeur
>>> f
'42863.1000'
>>>
Exercice 2.9 : Collecte de données
Dans l'exercice 2.7, vous avez écrit un programme appelé report.py qui calculait le gain/perte d'un portefeuille d'actions. Dans cet exercice, vous allez commencer à le modifier pour produire un tableau comme celui-ci :
Nom Actions Prix Changement
---------- ---------- ---------- ----------
AA 100 9,22 -22,98
IBM 50 106,28 15,18
CAT 150 35,46 -47,98
MSFT 200 20,89 -30,34
GE 95 13,48 -26,89
MSFT 50 20,89 -44,21
IBM 100 106,28 35,84
Dans ce rapport, "Prix" est le prix actuel d'une action et "Changement" est le changement du prix d'achat initial de l'action.
Pour générer le rapport ci-dessus, vous devrez tout d'abord collecter toutes les données affichées dans le tableau. Écrivez une fonction make_report() qui prend une liste d'actions et un dictionnaire de prix en entrée et renvoie une liste de tuples contenant les lignes du tableau ci-dessus.
Ajoutez cette fonction à votre fichier report.py. Voici comment cela devrait fonctionner si vous l'essayez en interaction :
>>> portefeuille = read_portfolio('/home/labex/project/portfolio.csv')
>>> prix = read_prices('/home/labex/project/prices.csv')
>>> rapport = make_report(portefeuille, prix)
>>> for r in rapport:
print(r)
('AA', 100, 9,22, -22,980000000000004)
('IBM', 50, 106,28, 15,180000000000007)
('CAT', 150, 35,46, -47,98)
('MSFT', 200, 20,89, -30,339999999999996)
('GE', 95, 13,48, -26,889999999999997)
...
>>>
Exercice 2.10 : Affichage d'un tableau formaté
Refaites la boucle for de l'exercice 2.9, mais changez l'instruction print pour formater les tuples.
>>> for r in rapport:
print('%10s %10d %10.2f %10.2f' % r)
AA 100 9,22 -22,98
IBM 50 106,28 15,18
CAT 150 35,46 -47,98
MSFT 200 20,89 -30,34
...
>>>
Vous pouvez également étendre les valeurs et utiliser les f-strings. Par exemple :
>>> for nom, actions, prix, changement in rapport:
print(f'{nom:>10s} {actions:>10d} {prix:>10.2f} {changement:>10.2f}')
AA 100 9,22 -22,98
IBM 50 106,28 15,18
CAT 150 35,46 -47,98
MSFT 200 20,89 -30,34
...
>>>
Prenez les instructions ci-dessus et ajoutez-les à votre programme report.py. Faites en sorte que votre programme prenne la sortie de la fonction make_report() et affiche un tableau correctement formaté comme indiqué.
Exercice 2.11 : Ajout de quelques en-têtes
Supposons qu'on ait un tuple de noms d'en-tête comme ceci :
entetes = ('Nom', 'Actions', 'Prix', 'Changement')
Ajoutez du code à votre programme qui prend le tuple d'en-têtes ci-dessus et crée une chaîne de caractères où chaque nom d'en-tête est aligné à droite dans un champ de 10 caractères de large et chaque champ est séparé par un espace unique.
' Nom Actions Prix Changement'
Écrivez du code qui prend les en-têtes et crée la chaîne de caractères séparatrice entre les en-têtes et les données qui suivent. Cette chaîne de caractères est juste une série de caractères "-" sous chaque nom de champ. Par exemple :
'---------- ---------- ---------- -----------'
Quand vous avez fini, votre programme devrait produire le tableau montré au début de cet exercice.
Nom Actions Prix Changement
---------- ---------- ---------- ----------
AA 100 9,22 -22,98
IBM 50 106,28 15,18
CAT 150 35,46 -47,98
MSFT 200 20,89 -30,34
GE 95 13,48 -26,89
MSFT 50 20,89 -44,21
IBM 100 106,28 35,84
Exercice 2.12 : Défi de formatage
Comment modifieriez-vous votre code pour que le prix inclue le symbole de la devise ($) et que la sortie ait l'allure suivante :
Nom Actions Prix Changement
---------- ---------- ---------- ----------
AA 100 $9,22 -22,98
IBM 50 $106,28 15,18
CAT 150 $35,46 -47,98
MSFT 200 $20,89 -30,34
GE 95 $13,48 -26,89
MSFT 50 $20,89 -44,21
IBM 100 $106,28 35,84
Sommaire
Félicitations ! Vous avez terminé le laboratoire de formatage. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.