Python
Afficher joliment les dictionnaires Python : Guide pour débutants

Afficher joliment les dictionnaires Python : Guide pour débutants

MoeNagy Dev

L'importance de l'affichage joli

Améliorer la lisibilité : Pourquoi l'affichage joli est crucial pour comprendre les structures de données complexes

Traiter avec des structures de données complexes, telles que les dictionnaires, peut être une tâche difficile, surtout lorsque les données deviennent de plus en plus complexes. Dans ces situations, la manière dont l'information est présentée peut faire une différence significative dans notre capacité à comprendre et à travailler efficacement avec les données. C'est là que le concept de "joli affichage" entre en jeu.

L'affichage joli est le processus de formatage des données de manière à améliorer leur lisibilité et leur organisation visuelle. En ce qui concerne les dictionnaires Python, l'affichage joli peut être particulièrement bénéfique, car il vous permet de saisir rapidement le contenu du dictionnaire, d'identifier les paires clé-valeur et de naviguer plus facilement dans les données.

Identifier les paires clé-valeur : Comment l'affichage joli peut vous aider à saisir rapidement le contenu d'un dictionnaire

Sans un formatage approprié, un dictionnaire peut apparaître comme un bloc dense de texte, ce qui rend difficile l'identification des paires clé-valeur individuelles et la compréhension de la structure globale des données. L'affichage joli, en revanche, peut transformer cette apparence encombrée en une représentation bien organisée et esthétiquement agréable, ce qui rend plus facile la numérisation et la compréhension du contenu du dictionnaire.

Utilisation de la fonction print() intégrée

Utilisation de base : Afficher un dictionnaire sans aucun formatage

La façon la plus basique d'afficher un dictionnaire en Python est d'utiliser la fonction intégrée print(). Cependant, cette approche ne peut pas toujours fournir le niveau de lisibilité souhaité, surtout lorsqu'il s'agit de dictionnaires plus grands ou plus complexes.

my_dict = {'name': 'John Doe', 'age': 35, 'occupation': 'Software Engineer'}
print(my_dict)

Sortie :

{'name': 'John Doe', 'age': 35, 'occupation': 'Software Engineer'}

Limitations : Pourquoi la fonction print() par défaut peut ne pas fournir le niveau de lisibilité souhaité

Bien que la fonction de base print() puisse afficher le contenu d'un dictionnaire, elle peut ne pas être la manière la plus efficace de présenter des structures de données complexes. La sortie peut sembler encombrée et difficile à lire, surtout lorsque le dictionnaire contient un grand nombre de paires clé-valeur ou de structures imbriquées.

Présentation du module pprint

Aperçu : Qu'est-ce que le module pprint et comment peut-il vous aider à afficher joliment les dictionnaires ?

Pour pallier les limitations de la fonction print() par défaut, Python fournit le module pprint (Pretty Print). Ce module offre une manière plus sophistiquée d'afficher les dictionnaires et autres structures de données, les rendant plus faciles à lire et à comprendre.

Importation du module pprint : Assurer l'accès à la fonctionnalité nécessaire

Avant d'utiliser le module pprint, vous devez l'importer dans votre script Python. Cela peut être réalisé avec l'instruction suivante :

import pprint

Affichage joli des dictionnaires avec pprint.pprint()

Utilisation la plus simple : Appeler pprint.pprint() pour afficher joliment un dictionnaire

La manière la plus simple d'utiliser le module pprint pour afficher joliment un dictionnaire est d'appeler la fonction pprint.pprint(). Cette fonction prend un dictionnaire comme argument et renvoie une représentation formatée des données.

my_dict = {'name': 'John Doe', 'age': 35, 'occupation': 'Software Engineer'}
pprint.pprint(my_dict)

Sortie :

{'age': 35,
 'name': 'John Doe',
 'occupation': 'Software Engineer'}

Contrôle de l'indentation : Ajuster le niveau d'indentation pour une meilleure organisation visuelle

Par défaut, la fonction pprint.pprint() utilise un niveau d'indentation standard de 1 pour séparer les paires clé-valeur. Cependant, vous pouvez ajuster ce niveau d'indentation selon vos préférences ou les exigences spécifiques de votre projet.

pprint.pprint(my_dict, indent=4)

Sortie :

{   'age': 35,
    'name': 'John Doe',
    'occupation': 'Software Engineer'}

Limitation de la profondeur de l'affichage : Se concentrer sur les parties les plus pertinentes d'un dictionnaire profondément imbriqué

Lorsque vous traitez avec des dictionnaires profondément imbriqués, vous pouvez utiliser le paramètre depth pour contrôler le niveau d'imbrication qui est affiché dans la sortie joliment formatée. Cela peut être particulièrement utile lorsque vous souhaitez vous concentrer sur la structure de niveau supérieur des données sans être submergé par la profondeur complète de la hiérarchie.

nested_dict = {'outer_key': {'inner_key1': 'value1', 'inner_key2': 'value2'}}
pprint.pprint(nested_dict, depth=1)

Sortie :

{'outer_key': {...}}

Personnalisation de la sortie de l'affichage joli

Modification du niveau d'indentation : Augmenter ou diminuer l'indentation pour des cas d'utilisation spécifiques

En plus du niveau d'indentation par défaut, le module pprint offre la possibilité de personnaliser l'indentation selon vos besoins. Cela peut être particulièrement utile lors de travaux avec différents types de structures de données ou lorsque vous essayez d'aligner la sortie avec des exigences de formatage spécifiques.

pprint.pprint(my_dict, indent=2)

Sortie :

{
  'age': 35,
  'name': 'John Doe',
  'occupation': 'Software Engineer'
}

Modification du séparateur : Ajuster les caractères utilisés pour séparer les paires clé-valeur

Le module pprint vous permet également de personnaliser le séparateur utilisé entre les paires clé-valeur dans la sortie joliment formatée. Cela peut être utile lorsque vous souhaitez utiliser un délimiteur différent ou lorsque vous travaillez avec des données nécessitant une convention de formatage spécifique.

pprint.pprint(my_dict, indent=2, sep='=')

Sortie :

{
  'age'=35,

'mon_prénom' = 'John Doe', 'occupation' = 'Ingénieur logiciel' }


## Contrôle de flux

### Instructions conditionnelles

Les instructions conditionnelles vous permettent d'exécuter différents blocs de code en fonction de certaines conditions. L'instruction conditionnelle la plus courante est l'instruction `if-elif-else`.

```python
age = 25
if age < 18:
    print("Vous êtes mineur.")
elif age >= 18 and age < 65:
    print("Vous êtes un adulte.")
else:
    print("Vous êtes un senior.")

Vous pouvez également utiliser l'opérateur ternaire comme raccourci pour les instructions if-else simples.

est_étudiant = True
statut_étudiant = "Étudiant" if est_étudiant else "Pas un étudiant"
print(statut_étudiant)  # Sortie: Étudiant

Boucles

Les boucles vous permettent d'exécuter un bloc de code de manière répétée. Python dispose de deux types principaux de boucles : les boucles for et les boucles while.

# Boucle for
for i in range(5):
    print(i)  # Sortie: 0 1 2 3 4
 
# Boucle while
compteur = 0
while compteur < 3:
    print(compteur)
    compteur += 1  # Sortie: 0 1 2

Vous pouvez également utiliser les instructions break et continue pour contrôler le déroulement de vos boucles.

# Instruction break
for i in range(5):
    if i == 3:
        break
    print(i)  # Sortie: 0 1 2
 
# Instruction continue
for i in range(5):
    if i == 3:
        continue
    print(i)  # Sortie: 0 1 2 4

Fonctions

Les fonctions vous permettent d'encapsuler un bloc de code réutilisable. Vous pouvez définir des fonctions à l'aide du mot clé def.

def saluer(nom):
    print(f"Bonjour, {nom}!")
 
saluer("Alice")  # Sortie: Bonjour, Alice!
 
def ajouter_nombres(a, b):
    return a + b
 
résultat = ajouter_nombres(3, 4)
print(résultat)  # Sortie: 7

Vous pouvez également définir des fonctions avec des valeurs de paramètre par défaut et des arguments de longueur variable.

def afficher_info(nom, âge=30):
    print(f"{nom} a {âge} ans.")
 
afficher_info("Bob")  # Sortie: Bob a 30 ans.
afficher_info("Alice", 25)  # Sortie: Alice a 25 ans.
 
def calculer_somme(*nombres):
    total = 0
    for num in nombres:
        total += num
    return total
 
print(calculer_somme(1, 2, 3))  # Sortie: 6
print(calculer_somme(4, 5, 6, 7, 8))  # Sortie: 30

Modules et packages

La conception modulaire de Python vous permet d'organiser votre code en modules et packages réutilisables.

# mon_module.py
def dire_bonjour():
    print("Bonjour depuis mon_module !")
 
# main.py
import mon_module
mon_module.dire_bonjour()  # Sortie: Bonjour depuis mon_module !
 
# Alternativement, vous pouvez importer des fonctions spécifiques
from mon_module import dire_bonjour
dire_bonjour()  # Sortie: Bonjour depuis mon_module !

Vous pouvez également créer vos propres packages en organisant vos modules dans des répertoires.

mon_package/
    __init__.py
    module1.py
    module2.py

Dans le fichier __init__.py, vous pouvez spécifier quels modules ou fonctions doivent être accessibles depuis le package.

# mon_package/__init__.py
from .module1 import fonction1
from .module2 import fonction2

Ensuite, vous pouvez importer et utiliser les fonctions du package.

from mon_package import fonction1, fonction2
fonction1()
fonction2()

Gestion des exceptions

La gestion des exceptions vous permet de gérer les situations inattendues dans votre code et d'empêcher votre programme de se planter.

try:
    résultat = 10 / 0
except ZeroDivisionError:
    print("Erreur : division par zéro")
 
try:
    int("abc")
except ValueError:
    print("Erreur : format entier invalide")

Vous pouvez également gérer plusieurs exceptions et ajouter un bloc finally pour exécuter du code indépendamment de la survenue d'une exception.

try:
    fichier = open("fichier_inexistant.txt", "r")
    contenu = fichier.read()
    print(contenu)
except FileNotFoundError:
    print("Erreur : fichier introuvable")
except Exception as e:
    print(f"Une erreur s'est produite : {e}")
finally:
    fichier.close()

Entrées/Sorties de fichiers

Python fournit des fonctions intégrées pour la lecture à partir de fichiers et l'écriture dans des fichiers.

# Écriture dans un fichier
with open("output.txt", "w") as fichier:
    fichier.write("Bonjour, fichier !")
 
# Lecture depuis un fichier
with open("input.txt", "r") as fichier:
    contenu = fichier.read()
    print(contenu)

Vous pouvez également utiliser le module os pour effectuer diverses opérations de fichiers et de répertoires.

import os
 
# Créer un répertoire
os.makedirs("nouveau_répertoire")
 
# Lister les fichiers d'un répertoire
fichiers = os.listdir("chemin/vers/répertoire")
for fichier in fichiers:
    print(fichier)
 
# Supprimer un fichier
os.remove("fichier_à_supprimer.txt")

Conclusion

Dans ce tutoriel, vous avez appris divers concepts de Python, notamment le contrôle de flux, les fonctions, les modules et packages, la gestion des exceptions et les entrées/sorties de fichiers. Ces sujets fondamentaux sont essentiels pour la création d'applications Python robustes et faciles à entretenir. Au fur et à mesure de votre progression dans votre apprentissage de Python, n'oubliez pas de pratiquer régulièrement, d'explorer le vaste écosystème Python et de continuer à apprendre de nouvelles techniques et bonnes pratiques.

MoeNagy Dev