Python, de zéro

Une chaîne possède un opérateur pourcent (%) permettant de la formater, c'est-à-dire d'y insérer des expressions évaluées à l’exécution.

Le mécanisme ressemble au printf() du C. On écrit la chaîne de base, en préparant la position des expressions à afficher. Cette préparation se fait avec le caractère pourcent (%) suivi de « d » pour indiquer une expression donnant un nombre entier écrit en décimal, « x » pour un nombre hexadécimal, « f » pour un flottant ou plus simplement « s » qui permet de prendre en compte tout le reste (chaînes, listes, tuples, ensembles, dictionnaires, booléens, None) ainsi que les types déjà cités (int, float).

Une fois la chaîne terminée, on y rajoute ensuite de nouveau l’opérateur pourcent (%) pour indiquer qu’elle va se continuer avec des paramètres ; puis on y place derrière soit un tuple contenant toutes les expressions attendues dans l'ordre prévu par la chaîne (si plusieurs éléments attendus) ; soit l'expression attendue si elle est unique.

Exemple :

>>> var=5
>>> print("Ma variable vaut %d " % var)
Ma variable vaut 5
>>> print("Ma variable vaut %d et sa moitié vaut %f" % (var, var/2))
Ma variable vaut 5 et sa moitié vaut 2.500000

Si tuple il doit y avoir, ce tuple peut bien évidemment parfaitement provenir d’une variable.

>>> var=5
>>> calc=(var, var /2)
>>> print("Ma variable vaut %d et sa moitié vaut %f" % calc)
Ma variable vaut 5 et sa moitié vaut 2.500000

Dans le cas de plusieurs expressions mises dans un tuple, l'ordre des expressions du tuple doit correspondre à l'ordre des formats spécifiés dans la chaîne.

On peut toutefois forcer cet ordre en rajoutant des identificateurs entre parenthèses. On associera alors ces identificateurs aux expressions à afficher en remplaçant le tuple final par un dictionnaire avec les identificateurs comme clefs. La chaîne n’aura donc pas besoin de se préoccuper de l’ordre des valeurs attendues puisque le dictionnaire lui donnera un accès direct par l’identificateur.

Exemple :

>>> var=5
>>> print("Ma variable vaut %(valeur)d et sa moitié vaut %(moitie)f" % {"moitie" : var/2, "valeur" : var})
Ma variable vaut 5 et sa moitié vaut 2.500000

Outre la possibilité de ne plus se préoccuper de l'ordre des éléments à afficher, cette technique permet aussi d'afficher plusieurs fois une expression tout en ne l'ayant calculée qu'une seule fois…

>>> var=5
>>> print("J'ai obtenu le carre %(carre)d en calculant %(valeur)d*%(valeur)d – Ce carre %(carre)d est évidemment un carré parfait de %(valeur)d" % {"valeur" : var, "carre" : var**2})
J’ai obtenu le carre 25 calculant 5*5 – Ce carre 25 est évidemment un carré parfait de 5

Les spécificateurs de type peuvent être complétés d’options définissant la façon dont seront affichés ces éléments.

>>> "%5s" % "x"             # Justification à droite avec des espaces
'    x'
>>> "%-5s" % "x"            # Justification à gauche avec des espaces
'x    '
>>> "%5d" % 123             # Justification à droite avec des espaces
'  123'
>>> "%-5d" % 123            # Justification à gauche avec des espaces
'123  '
>>> "%05d" % 123            # Justification à droite avec des zéros
'00123'
>>> "%8.2f" % 123           # Justification à droite avec des espaces
'  123.00'
>>> "%-8.2f" % 123          # Justification à gauche avec des espaces
'123.00  '
>>> "%08.2f" % 123          # Justification à droite sur 8 digits dont 2 après la virgule avec des 0
'00123.00'

Dans le cas où la valeur de justification n’est pas connue, mais calculée dans une expression, il est possible de l’indiquer en remplaçant le nombre par une étoile (*) pour indiquer l’expression qui sera alors placée au même niveau que la valeur à afficher.

>>> v=3
>>> "%0*d" % (v**2, 123)    # Justification à droite avec des zéros
'000000123'

Une chaîne possède aussi une méthode format() permettant des opérations analogues, mais en utilisant des paramètres positionnels. Ces positions se précisent en utilisant les accolades ({}).

Accessoirement, le typage n’est plus obligatoire (plus besoin de spécifier « s », « d » ou autre).

Exemple :

>>> var=5
>>> print("Ma variable vaut {} et sa moitié vaut {}".format(var, var/2))
Ma variable vaut 5 et sa moitié vaut 2.5

De même, cette méthode permet aussi de préciser l’ordre d’affichage des éléments en indiquant cet ordre dans les accolades (le premier élément formaté commençant à 0) et de factoriser les calculs.

>>> var=5
>>> print("J'ai obtenu le carre {1} en calculant {0}*{0} – Ce carre {1} est évidemment un carré parfait de {0}".format(var, var**2))
J’ai obtenu le carre 25 calculant 5*5 – Ce carre 25 est évidemment un carré parfait de 5

De plus, le typage originel ("s", "d", "f", "x") peut quand même être précisé si nécessaire avec le signe deux-points (:)…

>>> var=5
>>> print("Ma variable vaut {:d} et sa moitié vaut {:f}".format(var, var/2))
Ma variable vaut 5 et sa moitié vaut 2.500000

… lesquels peuvent être associés avec l’ordre d’affichage…

>>> var=5
>>> print("Ma variable vaut {1:d} et sa moitié vaut {0:f}".format(var/2, var))
Ma variable vaut 5 et sa moitié vaut 2.500000

… ce qui permet alors d’y rajouter des options définissant la façon dont seront formatés ces éléments.

VII-2-a. Pour formater une chaîne▲

>>> "{:>5s}".format("x")         # Justifier à droite avec des espaces
'    x'
>>> "{:<5s}".format("x")         # Justifier à gauche avec des espaces
'x    '
>>> "{:^5s}".format("x")         # Justifier au milieu avec des espaces
'  x  '
>>> "{:>05s}".format("x")        # Justifier à droite avec des zéros
'0000x'
>>> "{:<05s}".format("x")        # Justifier à gauche avec des zéros
'x0000'
>>> "{:^05s}".format("x")        # Justifier au milieu avec des zéros
'00x00'

VII-2-b. Pour formater un entier▲

>>> "{:>5d}".format(123)         # Justifier à droite avec des espaces
'  123'
>>> "{:<5d}".format(123)         # Justifier à gauche avec des espaces
'123  '
>>> "{:^5d}".format(123)         # Justifier au milieu avec des espaces
' 123 '
>>> "{:>05d}".format(123)        # Justifier à droite avec des zéros
'00123'
>>> "{:<05d}".format(123)        # Justifier à gauche avec des zéros
'12300'
>>> "{:^05d}".format(123)        # Justifier au milieu avec des zéros
'01230'

VII-2-c. Pour formater un flottant▲

>>> "{0:>8.2f}".format(123)      # Justifier à droite sur 8 digits dont 2 après la virgule
'  123.00'
>>> "{:<8.2f}".format(123)       # Justifier à gauche sur 8 digits dont 2 après la virgule
'123.00  '
>>> "{:^8.2f}".format(123)       # Justifier au milieu sur 8 digits dont 2 après la virgule
' 123.00 '
>>> "{:>08.2f}".format(123)      # Justifier à droite avec 0 sur 8 digits dont 2 après la virgule
'00123.00'
>>> "{:<8.2f}".format(123)       # Justifier à gauche avec 0 sur 8 digits dont 2 après la virgule
'123.0000'
>>> "{:^8.2f}".format(123)       # Justifier au milieu avec 0 sur 8 digits dont 2 après la virgule
'0123.000'

VII-2-d. Remarque▲

>>> v=3
>>> "{:>0{1}d}".format(123, v**2)        # Justification à droite avec des zéros
'000000123'

>>> var=5
>>> print("Ma variable vaut {{{}}} et sa moitié vaut {{{}}}".format(var, var/2))
Ma variable vaut {5} et sa moitié vaut {2.5}

Depuis Python 3.6, les « f-strings » permettent d’insérer des expressions avec ou sans mise en forme dans des chaînes de caractères en utilisant une syntaxe minimale.

Pour utiliser f-strings, il suffit de mettre un « f » devant la chaîne de caractères et pour insérer la valeur d’une variable ou d’une expression dans la chaîne, il suffit de mettre la variable ou l’expression entre accolades sans se préoccuper des guillemets qui encadrent la chaîne.

Exemple :

>>> var=5
>>> print(f"Ma variable vaut {var} et sa moitié vaut {var/2}")
Ma variable vaut 5 et sa moitié vaut 2.5

Comme pour la méthode format() le typage habituel (« s », « d », « f », « x ») peut quand même être précisé si nécessaire avec les deux-points (:)…

>>> var=5
>>> print(f"Ma variable vaut {var:d} et sa moitié vaut {var/2:f}")
Ma variable vaut 5 et sa moitié vaut 2.500000

… ce qui permet alors d’y rajouter des options définissant la façon dont seront formatés ces éléments.

VII-3-a. Pour formater une chaîne de caractères▲

>>> var="x"
>>> f"{var:>5s}"                # Justifier à droite avec des espaces
'    x'
>>> f"{var:<5s}"                # Justifier à gauche avec des espaces
'x    '
>>> f"{var:^5s}"                # Justifier au milieu avec des espaces
'  x  '
>>> f"{var:>05s}"               # Justifier à droite avec des zéros
'0000x'
>>> f"{var:<05s}"               # Justifier à gauche avec des zéros
'x0000'
>>> f"{var:^05s}"               # Justifier au milieu avec des zéros
'00x00'

VII-3-b. Pour formater un entier▲

>>> var=123
>>> f"{var:>5d}"                # Justifier à droite avec des espaces
'  123'
>>> f"{var:<5d}"                # Justifier à gauche avec des espaces
'123  '
>>> f"{var:^5d}"                # Justifier au milieu avec des espaces
' 123 '
>>> f"{var:>05d}"               # Justifier à droite avec des zéros
'00123'
>>> f"{var:<05d}"               # Justifier à gauche avec des zéros
'12300'
>>> f"{var:^05d}"               # Justifier au milieu avec des zéros
'01230'

VII-3-c. Pour formater un nombre à virgule flottante▲

>>> var=123.00
>>> f"{var:>8.2f}"              # Justifier à droite sur 8 digits dont 2 après la virgule
'  123.00'
>>> f"{var:<8.2f}"              # Justifier à gauche sur 8 digits dont 2 après la virgule
'123.00  '
>>> f"{var:^8.2f}"              # Justifier au milieu sur 8 digits dont 2 après la virgule
' 123.00 '
>>> f"{var:>08.2f}"             # Justifier à droite avec 0 sur 8 digits dont 2 après la virgule
'00123.00'
>>> f"{var:<08.2f}"             # Justifier à gauche avec 0 sur 8 digits dont 2 après la virgule
'123.0000'
>>> f"{var:^08.2f}"             # Justifier au milieu avec 0 sur 8 digits dont 2 après la virgule
'0123.000'

VII-3-d. Remarque▲

>>> var=123
>>> n=3
>>> f"{var:>0{n**2}d}"          # Justification à droite avec des zéros
'000000123'