Comment aligner la sortie lors de l'impression en Python

PythonPythonBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Lorsque vous écrivez des programmes Python, présenter la sortie de manière propre et organisée est essentiel tant pour la lisibilité du code que pour l'expérience utilisateur. Que vous créiez des rapports, affichiez des données tabulaires ou simplement imprimiez des informations dans la console, un alignement correct du texte rend votre sortie plus professionnelle et plus facile à lire.

Dans ce lab (atelier), vous apprendrez diverses techniques pour aligner et formater la sortie textuelle en Python. Vous explorerez différentes méthodes d'alignement, pratiquerez des techniques de formatage et créerez des affichages tabulaires bien structurés qui peuvent être appliqués dans des applications réelles.

Alignement de chaînes de caractères de base en Python

Dans cette première étape, vous allez apprendre les concepts fondamentaux de l'alignement de texte en Python et mettre en œuvre des techniques d'alignement de base.

Qu'est-ce que l'alignement de texte ?

L'alignement de texte fait référence à la façon dont le texte est positionné dans un espace donné. Python propose plusieurs méthodes pour contrôler le positionnement du texte lors de son affichage dans la console. Les trois principaux types d'alignement sont :

  • Alignement à gauche : Le texte commence à partir du bord gauche de l'espace alloué.
  • Alignement à droite : Le texte se termine au bord droit de l'espace alloué.
  • Alignement au centre : Le texte est centré dans l'espace alloué.

Votre premier programme d'alignement

Créons un simple script Python pour démontrer les techniques d'alignement de base.

  1. Ouvrez le WebIDE dans votre environnement LabEx.

  2. Créez un nouveau fichier nommé basic_alignment.py dans le répertoire /home/labex/project en cliquant sur l'icône "Nouveau fichier" dans le WebIDE.

  3. Ajoutez le code suivant au fichier :

## basic_alignment.py
print("Basic String Alignment Examples")
print("-" * 30)

## Left alignment example
print("Left alignment:")
print("Python".ljust(20) + "|")
print("Programming".ljust(20) + "|")
print("Alignment".ljust(20) + "|")
print()

## Right alignment example
print("Right alignment:")
print("Python".rjust(20) + "|")
print("Programming".rjust(20) + "|")
print("Alignment".rjust(20) + "|")
print()

## Center alignment example
print("Center alignment:")
print("Python".center(20) + "|")
print("Programming".center(20) + "|")
print("Alignment".center(20) + "|")
  1. Enregistrez le fichier en appuyant sur Ctrl+S ou en sélectionnant "Fichier" > "Enregistrer" dans le menu.

  2. Ouvrez un terminal dans le WebIDE (s'il n'est pas déjà ouvert) en cliquant sur le menu "Terminal" et en sélectionnant "Nouveau terminal".

  3. Exécutez le script à l'aide de l'interpréteur Python :

cd ~/project
python3 basic_alignment.py
  1. Vous devriez voir la sortie suivante :
Basic String Alignment Examples
------------------------------
Left alignment:
Python              |
Programming         |
Alignment           |

Right alignment:
              Python|
         Programming|
           Alignment|

Center alignment:
       Python       |
     Programming    |
      Alignment     |

Comprendre le code

Le script que vous venez de créer démontre trois méthodes d'alignement de chaînes de caractères de base en Python :

  • ljust(width) : Justifie la chaîne de caractères à gauche dans un champ de la largeur spécifiée.
  • rjust(width) : Justifie la chaîne de caractères à droite dans un champ de la largeur spécifiée.
  • center(width) : Centre la chaîne de caractères dans un champ de la largeur spécifiée.

Dans chaque exemple, nous avons ajouté une barre verticale (|) à la fin de chaque ligne pour montrer clairement la limite de l'espace alloué. Remarquez comment le texte s'aligne différemment dans chaque cas tout en conservant la même largeur totale de 20 caractères.

Alignement de chaînes de caractères avec différents caractères

Les méthodes de justification de chaînes de caractères peuvent également prendre un deuxième paramètre pour spécifier le caractère de remplissage qui sera utilisé pour le remplissage. Modifions notre script pour voir cela en action.

  1. Créez un nouveau fichier nommé alignment_with_chars.py dans le répertoire /home/labex/project.

  2. Ajoutez le code suivant au fichier :

## alignment_with_chars.py
print("String Alignment With Custom Characters")
print("-" * 40)

## Using different padding characters
print("Left alignment with dots:")
print("Python".ljust(20, '.') + "|")
print("Programming".ljust(20, '.') + "|")
print()

print("Right alignment with asterisks:")
print("Python".rjust(20, '*') + "|")
print("Programming".rjust(20, '*') + "|")
print()

print("Center alignment with hyphens:")
print("Python".center(20, '-') + "|")
print("Programming".center(20, '-') + "|")
  1. Enregistrez le fichier et exécutez-le :
python3 ~/project/alignment_with_chars.py
  1. Vous devriez voir une sortie comme celle-ci :
String Alignment With Custom Characters
----------------------------------------
Left alignment with dots:
Python..............|
Programming.........|

Right alignment with asterisks:
**************Python|
*********Programming|

Center alignment with hyphens:
-------Python------|
----Programming----|

Ces exemples montrent comment vous pouvez personnaliser l'apparence de votre texte aligné en utilisant différents caractères de remplissage.

Méthodes de Formatage Avancées pour l'Alignement

Dans l'étape précédente, vous avez appris à aligner des chaînes de caractères de base à l'aide des méthodes ljust(), rjust() et center(). Maintenant, explorons des méthodes de formatage plus puissantes et flexibles disponibles en Python.

Méthodes de Formatage de Chaînes en Python

Python propose plusieurs manières de formater les chaînes :

  1. Formatage de style ancien (utilisant l'opérateur %)
  2. La méthode str.format()
  3. Les f-strings (chaînes littérales formatées, disponibles à partir de Python 3.6)

Chaque méthode offre des moyens d'aligner le texte et de formater divers types de données. Explorons-les une par une.

1. Formatage de Style Ancien (% Opérateur)

Il s'agit de la méthode la plus ancienne de formatage de chaînes en Python, similaire à la fonction printf() de C.

  1. Créez un nouveau fichier nommé old_style_formatting.py dans le répertoire /home/labex/project :
## old_style_formatting.py
print("Formatage de Chaînes de Style Ancien")
print("-" * 30)

## Alignement à gauche avec le formatage %
print("Alignement à gauche :")
print("%-15s | %-10s" % ("Python", "Language"))
print("%-15s | %-10s" % ("JavaScript", "Web"))
print()

## Alignement à droite avec le formatage %
print("Alignement à droite :")
print("%15s | %10s" % ("Python", "Language"))
print("%15s | %10s" % ("JavaScript", "Web"))
print()

## Formatage des nombres
price = 125.5
tax_rate = 0.21
print("Formatage des nombres :")
print("Prix : $%8.2f" % price)
print("Taux de TVA : %6.1f%%" % (tax_rate * 100))
print("Montant de la TVA : $%6.2f" % (price * tax_rate))
print("Total : $%8.2f" % (price * (1 + tax_rate)))
  1. Enregistrez le fichier et exécutez-le :
python3 ~/project/old_style_formatting.py
  1. Vous devriez voir une sortie similaire à ceci :
Formatage de Chaînes de Style Ancien
------------------------------
Alignement à gauche :
Python          | Language
JavaScript      | Web

Alignement à droite :
         Python |  Language
     JavaScript |       Web

Formatage des nombres :
Prix : $   125.50
Taux de TVA :   21.0%
Montant de la TVA : $ 26.36
Total : $   151.86

2. La Méthode str.format()

La méthode str.format() offre une manière plus polyvalente de formater les chaînes et a été introduite pour remédier à certaines limitations de l'opérateur %.

  1. Créez un nouveau fichier nommé format_method.py dans le répertoire /home/labex/project :
## format_method.py
print("Formatage de Chaînes avec str.format()")
print("-" * 35)

## Alignement de base avec format
print("Alignement de base :")
print("{:<15} | {:<10}".format("Python", "Language"))
print("{:>15} | {:>10}".format("Python", "Language"))
print("{:^15} | {:^10}".format("Python", "Language"))
print()

## Alignement avec caractère de remplissage personnalisé
print("Caractère de remplissage personnalisé :")
print("{:*<15} | {:.>10}".format("Python", "Language"))
print("{:#^15} | {:=^10}".format("Python", "Language"))
print()

## Alignement avec des noms de champs
print("Utilisation de noms de champs :")
print("{name:<15} | {type:<10}".format(name="JavaScript", type="Web"))
print("{name:>15} | {type:>10}".format(name="Python", type="Language"))
print()

## Formatage des nombres
price = 125.5
tax_rate = 0.21
print("Formatage des nombres :")
print("Prix : ${:8.2f}".format(price))
print("Taux de TVA : {:6.1f}%".format(tax_rate * 100))
print("Montant de la TVA : ${:6.2f}".format(price * tax_rate))
print("Total : ${:8.2f}".format(price * (1 + tax_rate)))
  1. Enregistrez le fichier et exécutez-le :
python3 ~/project/format_method.py
  1. Vous devriez voir une sortie similaire à ceci :
Formatage de Chaînes avec str.format()
-----------------------------------
Alignement de base :
Python          | Language
         Python |   Language
    Python      |  Language

Caractère de remplissage personnalisé :
Python********* | Language...
#####Python##### | ==Language==

Utilisation de noms de champs :
JavaScript      | Web
         Python |  Language

Formatage des nombres :
Prix : $  125.50
Taux de TVA :   21.0%
Montant de la TVA : $ 26.36
Total : $  151.86

3. F-strings (Python 3.6+)

Les f-strings offrent une manière concise et pratique d'intégrer des expressions à l'intérieur de chaînes littérales. Elles sont préfixées par la lettre 'f' et utilisent des accolades {} pour inclure des expressions.

  1. Créez un nouveau fichier nommé f_strings.py dans le répertoire /home/labex/project :
## f_strings.py
print("Formatage de Chaînes avec F-strings")
print("-" * 35)

language = "Python"
category = "Language"
version = 3.10
year = 2022

## Alignement de base avec f-strings
print("Alignement de base :")
print(f"{language:<15} | {category:<10}")
print(f"{language:>15} | {category:>10}")
print(f"{language:^15} | {category:^10}")
print()

## Spécification de largeur dynamique
width1 = 15
width2 = 10
print("Largeur dynamique :")
print(f"{language:<{width1}} | {category:<{width2}}")
print(f"{language:>{width1}} | {category:>{width2}}")
print()

## Expressions à l'intérieur des f-strings
print("Expressions dans les f-strings :")
print(f"{language + str(version):<15} | {year - 1991:>10} années")
print()

## Formatage des nombres
price = 125.5
tax_rate = 0.21
print("Formatage des nombres :")
print(f"Prix : ${price:8.2f}")
print(f"Taux de TVA : {tax_rate * 100:6.1f}%")
print(f"Montant de la TVA : ${price * tax_rate:6.2f}")
print(f"Total : ${price * (1 + tax_rate):8.2f}")
  1. Enregistrez le fichier et exécutez-le :
python3 ~/project/f_strings.py
  1. Vous devriez voir une sortie similaire à ceci :
Formatage de Chaînes avec F-strings
-----------------------------------
Alignement de base :
Python          | Language
         Python |  Language
    Python      | Language

Largeur dynamique :
Python          | Language
         Python |  Language

Expressions dans les f-strings :
Python 3.1      |         31 années

Formatage des nombres :
Prix : $  125.50
Taux de TVA :   21.0%
Montant de la TVA : $ 26.36
Total : $  151.86

Comparaison des Méthodes de Formatage

Chaque méthode de formatage a ses avantages. Voici quand utiliser chacune d'elles :

  • Opérateur % : Utilisez-le dans le code hérité ou lorsque la compatibilité avec les anciennes versions de Python est nécessaire.
  • Méthode str.format() : Plus puissante que le formatage %, en particulier pour les exigences de formatage complexes.
  • F-strings : L'option la plus concise et lisible, recommandée pour tout nouveau code Python (Python 3.6+).

La tendance moderne en Python est d'utiliser les f-strings autant que possible en raison de leur lisibilité et de leurs avantages en termes de performances.

Création de tableaux formatés avec Python

Maintenant que vous avez appris différentes techniques d'alignement, appliquons-les pour créer des tableaux bien formatés. Les tableaux sont un moyen courant d'afficher des données structurées de manière lisible, et un alignement correct est crucial pour présenter efficacement les informations tabulaires.

Tableau simple avec colonnes de largeur fixe

Commençons par créer un tableau simple avec des colonnes de largeur fixe.

  1. Créez un nouveau fichier nommé simple_table.py dans le répertoire /home/labex/project :
## simple_table.py
print("Tableau simple à largeur fixe")
print("-" * 50)

## Définir certaines données
header = ["Nom", "Âge", "Ville", "Profession"]
data = [
    ["John Smith", 34, "New York", "Médecin"],
    ["Sarah Johnson", 28, "San Francisco", "Ingénieur"],
    ["Michael Brown", 42, "Chicago", "Enseignant"],
    ["Emily Davis", 31, "Boston", "Scientifique"]
]

## Afficher l'en-tête
print(f"{header[0]:<20} {header[1]:<8} {header[2]:<15} {header[3]:<15}")
print("-" * 60)

## Afficher les lignes
for row in data:
    print(f"{row[0]:<20} {row[1]:<8} {row[2]:<15} {row[3]:<15}")
  1. Enregistrez le fichier et exécutez-le :
python3 ~/project/simple_table.py
  1. Vous devriez voir un tableau bien formaté comme celui-ci :
Tableau simple à largeur fixe
--------------------------------------------------
Nom                 Âge      Ville            Profession
------------------------------------------------------------
John Smith           34       New York        Médecin
Sarah Johnson        28       San Francisco   Ingénieur
Michael Brown        42       Chicago         Enseignant
Emily Davis          31       Boston          Scientifique

Tableau dynamique avec différents types d'alignement

Différents types de données sont souvent mieux présentés avec différents styles d'alignement. Par exemple, le texte est souvent aligné à gauche, tandis que les nombres sont alignés à droite. Créons un tableau plus sophistiqué avec un alignement mixte.

  1. Créez un nouveau fichier nommé dynamic_table.py dans le répertoire /home/labex/project :
## dynamic_table.py
print("Tableau dynamique avec alignement mixte")
print("-" * 50)

## Définir certaines données
header = ["Produit", "Prix", "Quantité", "Total"]
products = [
    ["Ordinateur portable", 1299.99, 3, 3899.97],
    ["Souris", 24.50, 10, 245.00],
    ["Moniteur", 349.95, 2, 699.90],
    ["Clavier", 49.99, 5, 249.95],
    ["Casque", 89.95, 4, 359.80]
]

## Calculer les largeurs des colonnes en fonction du contenu
col_widths = [
    max(len(str(header[0])), max(len(str(row[0])) for row in products)) + 2,
    max(len(str(header[1])), max(len(f"${row[1]:.2f}") for row in products)) + 2,
    max(len(str(header[2])), max(len(str(row[2])) for row in products)) + 2,
    max(len(str(header[3])), max(len(f"${row[3]:.2f}") for row in products)) + 2
]

## Afficher l'en-tête
print(f"{header[0]:<{col_widths[0]}}"
      f"{header[1]:>{col_widths[1]}}"
      f"{header[2]:>{col_widths[2]}}"
      f"{header[3]:>{col_widths[3]}}")
print("-" * sum(col_widths))

## Afficher les lignes avec l'alignement approprié
for product in products:
    print(f"{product[0]:<{col_widths[0]}}",
          f"${product[1]:.2f}".rjust(col_widths[1]),
          f"{product[2]}".rjust(col_widths[2]),
          f"${product[3]:.2f}".rjust(col_widths[3]))

## Afficher le résumé
total_quantity = sum(product[2] for product in products)
total_cost = sum(product[3] for product in products)
print("-" * sum(col_widths))
print(f"{'TOTAL':<{col_widths[0]}}",
      f"".rjust(col_widths[1]),
      f"{total_quantity}".rjust(col_widths[2]),
      f"${total_cost:.2f}".rjust(col_widths[3]))

... (le reste du code est identique à l'original)

Résumé

Dans ce laboratoire, vous avez appris diverses techniques pour aligner et formater la sortie textuelle en Python :

  • Méthodes de base d'alignement de chaînes de caractères : ljust(), rjust() et center()
  • Différentes approches de formatage de chaînes de caractères : opérateur %, str.format() et f-strings
  • Comment créer des tables bien structurées avec des colonnes de largeur fixe
  • Comment appliquer différents styles d'alignement en fonction des types de données
  • Comment créer des applications du monde réel telles que des rapports financiers avec un formatage approprié

Ces compétences en matière d'alignement de texte sont essentielles pour créer une sortie lisible et professionnelle dans de nombreuses applications, allant des simples utilitaires en ligne de commande aux systèmes de traitement de données complexes. En maîtrisant l'alignement de texte en Python, vous pouvez améliorer considérablement l'expérience utilisateur et la lisibilité de vos programmes.

Au fur et à mesure que vous poursuivez votre parcours en Python, rappelez-vous qu'une sortie propre et bien formatée est souvent aussi importante que la logique de calcul de vos programmes. Les techniques apprises dans ce laboratoire vous aideront à présenter vos données d'une manière à la fois fonctionnelle et visuellement attrayante.