Concepts & Exercices
Affichage = Données + Format + Structure + Clarté
Formule de l'affichage structuré
Formatage
→ print()
Organisation des données
Tableaux
→ Listes
Structures de données
Chaînes
→ f-strings
Formatage dynamique
Processus de l'affichage structuré
Données → Structure → Formatage → Affichage → Lisibilité
Exercice 1
Afficher des données structurées dans un tableau avec des colonnes alignées.
Exercice 2
Utiliser les f-strings pour afficher des variables de manière formatée.
Exercice 3
Afficher des listes imbriquées de manière hiérarchique.
Exercice 4
Créer un affichage de données tabulaires avec des en-têtes.
Exercice 5
Afficher des données avec une interface utilisateur en console.
Corrigé : Exercices 1 à 3
1 Affichage de tableau aligné
Définition de l'affichage aligné :
Affichage aligné : Technique permettant d'organiser des données dans des colonnes avec un alignement uniforme.
Méthodologie d'analyse :
- Identifier les données à afficher
- Déterminer la largeur de chaque colonne
- Appliquer un formatage cohérent
- Tester la lisibilité du résultat
Méthodes d'alignement en Python
{:<10}: Alignement à gauche{:>10}: Alignement à droite{:^10}: Centrage.format()ou f-strings
Étape 1 : Préparation des données
donnees = [
["Nom", "Age", "Ville"],
["Alice", 25, "Paris"],
["Bob", 30, "Lyon"],
["Charlie", 22, "Marseille"]
]Étape 2 : Formatage des colonnes
for ligne in donnees:
print(f"{ligne[0]:<10} {ligne[1]:>3} {ligne[2]:<12}")Étape 3 : Résultat obtenu
Nom Age Ville
Alice 25 Paris
Bob 30 Lyon
Charlie 22 Marseille
Utilisation des f-strings pour un alignement précis
Réponse finale :
# Affichage de tableau aligné
donnees = [
["Nom", "Age", "Ville"],
["Alice", 25, "Paris"],
["Bob", 30, "Lyon"],
["Charlie", 22, "Marseille"]
]
for ligne in donnees:
print(f"{ligne[0]:<10} {ligne[1]:>3} {ligne[2]:<12}")
Lois et principes :
• Alignement gauche : {:<largeur} pour aligner à gauche
• Alignement droite : {:>largeur} pour aligner à droite
• Centrage : {:^largeur} pour centrer le texte
2 Utilisation des f-strings
Définition des f-strings :
F-strings : Chaînes de caractères formatées permettant d'insérer des variables directement dans le texte.
Avantages des f-strings
- Lisibilité du code
- Performance élevée
- Flexibilité du formatage
- Intégration directe des variables
Étape 1 : Syntaxe de base
nom = "Alice"
age = 25
message = f"Bonjour {nom}, vous avez {age} ans"Étape 2 : Formatage avancé
prix = 12.345
print(f"Prix: {prix:.2f} €") # 2 décimales
print(f"Prix: {prix:>8.2f} €") # Aligné à droiteÉtape 3 : Calculs dans les f-strings
a, b = 10, 20
print(f"Somme: {a + b}") # Affiche: Somme: 30
Les f-strings permettent un formatage dynamique et lisible
Réponse finale :
# Exemples de f-strings
nom = "Alice"
age = 25
taille = 1.68
print(f"Nom: {nom}")
print(f"Âge: {age} ans")
print(f"Taille: {taille:.2f} m")
print(f"Anniversaire dans {365-age*365//1000} jours")
Lois et principes :
• Préfixe f : Ajouter f avant la chaîne pour activer les f-strings
• Variables directes : Insérer les variables entre accolades
• Calculs possibles : On peut effectuer des opérations dans les accolades
3 Affichage de listes imbriquées
Définition des listes imbriquées :
Listes imbriquées : Structures de données où des listes contiennent d'autres listes comme éléments.
Techniques d'affichage des listes imbriquées
- Parcours avec boucles imbriquées
- Indentation pour la hiérarchie
- Numérotation des éléments
- Formatage conditionnel
Étape 1 : Structure des données
donnees = [
["Étudiant 1", [12, 15, 14]],
["Étudiant 2", [18, 16, 17]],
["Étudiant 3", [10, 11, 13]]
]Étape 2 : Parcours des listes
for etudiant in donnees:
nom = etudiant[0]
notes = etudiant[1]
print(f"{nom}: {notes}")Étape 3 : Affichage hiérarchisé
for i, etudiant in enumerate(donnees):
print(f"Étudiant {i+1}: {etudiant[0]}")
print(" Notes:", end=" ")
for j, note in enumerate(etudiant[1]):
print(f"[{j+1}] {note}", end=" ")
print() # Nouvelle ligne
Utilisation de boucles imbriquées pour une structure hiérarchique
Réponse finale :
# Affichage de listes imbriquées
donnees = [
["Alice", [12, 15, 14]],
["Bob", [18, 16, 17]],
["Charlie", [10, 11, 13]]
]
for i, etudiant in enumerate(donnees):
print(f"Étudiant {i+1}: {etudiant[0]}")
print(" Notes:", end=" ")
for j, note in enumerate(etudiant[1]):
print(f"[{j+1}] {note}", end=" ")
print() # Nouvelle ligne
Lois et principes :
• Boucles imbriquées : Une boucle dans une autre pour parcourir les structures
• Indentation : Utiliser l'indentation pour montrer la hiérarchie
• Indexation : Accéder aux éléments avec des indices
Corrigé : Exercices 4 à 5
4 Données tabulaires avec en-têtes
Définition des données tabulaires :
Données tabulaires : Ensemble de données organisées en lignes et colonnes avec des en-têtes de colonne.
Composants d'un tableau structuré
- En-têtes de colonne
- Données alignées
- Séparateurs visuels
- Largeurs fixes de colonne
Étape 1 : Définition des en-têtes
entetes = ["Produit", "Prix", "Quantité", "Total"]Étape 2 : Données du tableau
donnees = [
["Pommes", 2.50, 10, 25.00],
["Oranges", 3.00, 8, 24.00],
["Bananes", 1.80, 15, 27.00]
]Étape 3 : Affichage structuré
# Affichage des en-têtes
print(f"{entetes[0]:<10} {entetes[1]:>8} {entetes[2]:>8} {entetes[3]:>10}")
print("-" * 40)
# Affichage des données
for ligne in donnees:
print(f"{ligne[0]:<10} {ligne[1]:>8.2f} {ligne[2]:>8} {ligne[3]:>10.2f}")
Création d'un tableau avec en-têtes et séparateurs visuels
Réponse finale :
# Tableau avec en-têtes
entetes = ["Produit", "Prix", "Quantité", "Total"]
donnees = [
["Pommes", 2.50, 10, 25.00],
["Oranges", 3.00, 8, 24.00],
["Bananes", 1.80, 15, 27.00]
]
# Affichage des en-têtes
print(f"{entetes[0]:<10} {entetes[1]:>8} {entetes[2]:>8} {entetes[3]:>10}")
print("-" * 40)
# Affichage des données
for ligne in donnees:
print(f"{ligne[0]:<10} {ligne[1]:>8.2f} {ligne[2]:>8} {ligne[3]:>10.2f}")
Lois et principes :
• En-têtes distincts : Afficher les en-têtes séparément des données
• Séparateurs : Utiliser des lignes pour séparer les en-têtes
• Alignement cohérent : Maintenir le même alignement pour chaque colonne
5 Interface utilisateur en console
Définition de l'interface en console :
Interface en console : Interface textuelle permettant à l'utilisateur d'interagir avec le programme.
Éléments d'une interface console
- Menu principal
- Options numérotées
- Retours visuels clairs
- Validation des entrées
Étape 1 : Création du menu
menu = """
=== MENU PRINCIPAL ===
1. Afficher les données
2. Ajouter une entrée
3. Supprimer une entrée
4. Quitter
======================
Votre choix: """Étape 2 : Boucle principale
while True:
choix = input(menu)
if choix == "1":
# Afficher les données
pass
elif choix == "2":
# Ajouter une entrée
pass
elif choix == "3":
# Supprimer une entrée
pass
elif choix == "4":
break
else:
print("Option invalide!")Étape 3 : Affichage des données
def afficher_donnees():
print("\nDonnées actuelles:")
print(f"{'ID':<5} {'Nom':<15} {'Valeur':<10}")
print("-" * 30)
for i, (nom, valeur) in enumerate(donnees):
print(f"{i:<5} {nom:<15} {valeur:<10}")
Interface utilisateur structurée avec menu et options
Réponse finale :
donnees = [["Alice", 25], ["Bob", 30]]
def afficher_menu():
print("\n=== MENU PRINCIPAL ===")
print("1. Afficher les données")
print("2. Ajouter une entrée")
print("3. Quitter")
print("======================")
def afficher_donnees():
print("\nDonnées actuelles:")
print(f"{'ID':<5} {'Nom':<15} {'Valeur':<10}")
print("-" * 30)
for i, (nom, valeur) in enumerate(donnees):
print(f"{i:<5} {nom:<15} {valeur:<10}")
while True:
afficher_menu()
choix = input("Votre choix: ")
if choix == "1":
afficher_donnees()
elif choix == "2":
nom = input("Nom: ")
valeur = input("Valeur: ")
donnees.append([nom, valeur])
print("Entrée ajoutée!")
elif choix == "3":
break
else:
print("Option invalide!")
Lois et principes :
• Menu clair : Fournir des options numérotées et des descriptions
• Boucle infinie : Utiliser une boucle avec condition de sortie
• Validation : Vérifier la validité des choix de l'utilisateur
Cours bien détaillé
Affichage = Données × Format × Structure × Clarté × Lisibilité
Formule de l'affichage structuré
Définition : L'affichage structuré consiste à organiser les données de manière lisible et hiérarchisée pour l'utilisateur.
Objectifs : Améliorer la lisibilité, organiser les données, faciliter l'interaction utilisateur.
Types : Tableaux, listes imbriquées, f-strings, menus, interfaces console.
Applications : Interfaces utilisateur, rapports, tableaux de données, visualisation de structures.
Conseil : Utilisez les f-strings pour un formatage lisible
Attention : Vérifiez la largeur des colonnes pour l'alignement
Astuce : Utilisez des séparateurs pour structurer les données
Méthode : Créez d'abord la structure avant l'affichage
Vérification : Testez la lisibilité avec des données réelles
Techniques d'affichage structuré :
- Alignement : Gauche, droite, centrage des colonnes
- Formatage : f-strings, .format(), %
- Hiérarchie : Indentation, niveaux de profondeur
- Séparation : Lignes de séparation, espacement
- Structuration : En-têtes, titres, sous-titres
Concepts clés à retenir :
- L'affichage structuré améliore la lisibilité des données
- Les f-strings permettent un formatage dynamique et lisible
- L'alignement des colonnes facilite la lecture des tableaux
- Les listes imbriquées nécessitent des boucles imbriquées pour l'affichage
- Une interface utilisateur claire améliore l'expérience
Processus de l'affichage structuré
Données → Structure → Formatage → Alignement → Affichage → Validation
