Aller au contenu
DevSecOps Logo DevSecOps Logo DevSecOps
Docs
Blog
Blog

Utiliser des dictionnaires en Python

Mise à jour :

logo python

Les dictionnaires en Python sont l’une des structures de données les plus puissantes et polyvalentes. En permettant de stocker des paires clé-valeur, ils offrent un moyen flexible de structurer et d’accéder aux données. Les dictionnaires sont particulièrement adaptés lorsque vous avez besoin d’une organisation facile d’accès, car chaque clé est associée à une valeur unique. Cette particularité en fait un choix privilégié pour de nombreuses applications, que ce soit pour le stockage de configurations, la gestion de bases de données ou la manipulation d’objets complexes.

Création d’un dictionnaire

Créer un dictionnaire en Python est simple et intuitif. Un dictionnaire se définit en utilisant des accolades {} et en spécifiant des paires clé-valeur séparées par des virgules. Chaque clé doit être unique et peut être de type immuable (comme une chaîne ou un entier), tandis que les valeurs peuvent être de n’importe quel type.

Exemple de création d’un dictionnaire :

# Création d'un dictionnaire simple
personne = {
    "nom": "Alice",
    "âge": 30,
    "ville": "Paris"
}

Dans cet exemple, "nom", "âge" et "ville" sont les clés, et leurs valeurs respectives sont "Alice", 30, et "Paris". Vous pouvez utiliser des types variés pour les valeurs, comme des listes, d’autres dictionnaires, ou même des tuples si nécessaire.

Vous pouvez aussi créer un dictionnaire vide et y ajouter des éléments par la suite :

# Dictionnaire vide
dictionnaire_vide = {}


# Ajout de paires clé-valeur
dictionnaire_vide["clé1"] = "valeur1"
dictionnaire_vide["clé2"] = "valeur2"

Accéder aux valeurs dans un dictionnaire

Une fois un dictionnaire créé, accéder à ses valeurs est très simple. Il suffit d’utiliser la clé correspondante entre crochets [] pour obtenir la valeur associée.

Exemple d’accès à une valeur :

personne = {
    "nom": "Alice",
    "âge": 30,
    "ville": "Paris"
}


# Accéder à la valeur de la clé "nom"
nom_personne = personne["nom"]
print(nom_personne)  # Affiche : Alice

Dans cet exemple, en utilisant la clé "nom", j’obtiens la valeur "Alice" associée à cette clé.

Gérer l’absence de clé avec get()

Si vous essayez d’accéder à une clé qui n’existe pas, Python renvoie une erreur. Pour éviter cela, vous pouvez utiliser la méthode get(), qui retourne None si la clé n’est pas trouvée, ou une valeur par défaut que vous spécifiez.

Exemple avec get() :

# Utilisation de get pour une clé qui n'existe pas
profession = personne.get("profession", "Inconnue")
print(profession)  # Affiche : Inconnue

Ici, comme la clé "profession" n’existe pas dans le dictionnaire, get() renvoie "Inconnue" au lieu de générer une erreur. Cette méthode est particulièrement utile pour éviter des exceptions et pour rendre votre code plus robuste lorsqu’il s’agit d’accéder à des valeurs dans un dictionnaire.

Ajouter des éléments

Les dictionnaires en Python sont des structures dynamiques, ce qui signifie que vous pouvez facilement y ajouter de nouvelles paires clé-valeur ou modifier des valeurs existantes.

Ajouter un nouvel élément

Pour ajouter un nouvel élément dans un dictionnaire, il suffit de spécifier une nouvelle clé entre crochets [] et d’y assigner une valeur.

Exemple d’ajout :

personne = {
    "nom": "Alice",
    "âge": 30
}


# Ajout d'une nouvelle clé-valeur
personne["ville"] = "Paris"
print(personne)  # Affiche : {'nom': 'Alice', 'âge': 30, 'ville': 'Paris'}

Dans cet exemple, j’ajoute une nouvelle entrée "ville" avec la valeur "Paris" dans le dictionnaire personne.

Modifier un élément existant

Pour modifier la valeur d’une clé existante, il suffit de la réassigner avec la nouvelle valeur souhaitée.

Exemple de modification :

# Modification de la valeur de la clé "âge"
personne["âge"] = 31
print(personne)  # Affiche : {'nom': 'Alice', 'âge': 31, 'ville': 'Paris'}

Ici, j’ai mis à jour la valeur associée à la clé "âge" en la remplaçant par 31.

Avec cette flexibilité, vous pouvez adapter le contenu de vos dictionnaires au fur et à mesure que les données évoluent dans votre programme.

Supprimer des éléments d’un dictionnaire

Python offre plusieurs méthodes pour supprimer des éléments d’un dictionnaire, qu’il s’agisse de supprimer une clé spécifique ou de vider complètement le dictionnaire.

Supprimer un élément avec pop()

La méthode pop() permet de supprimer une clé spécifique et de renvoyer sa valeur. Si la clé n’existe pas, une erreur est générée, sauf si vous spécifiez une valeur par défaut.

Exemple d’utilisation de pop() :

personne = {
    "nom": "Alice",
    "âge": 30,
    "ville": "Paris"
}


# Suppression de la clé "ville"
ville = personne.pop("ville")
print(ville)        # Affiche : Paris
print(personne)     # Affiche : {'nom': 'Alice', 'âge': 30}

Dans cet exemple, j’ai supprimé la clé "ville" du dictionnaire, et pop() a renvoyé la valeur "Paris".

Supprimer un élément avec del

Vous pouvez aussi utiliser l’instruction del pour supprimer un élément spécifique. Contrairement à pop(), del ne renvoie pas la valeur supprimée.

Exemple d’utilisation de del :

# Suppression de la clé "âge"
del personne["âge"]
print(personne)     # Affiche : {'nom': 'Alice'}

Ici, del a supprimé la clé "âge" et sa valeur associée du dictionnaire.

Vider complètement un dictionnaire avec clear()

Si vous souhaitez supprimer tous les éléments d’un dictionnaire, utilisez clear(). Cela vide le dictionnaire sans le supprimer lui-même.

Exemple d’utilisation de clear() :

# Vider le dictionnaire
personne.clear()
print(personne)     # Affiche : {}

Le dictionnaire personne est maintenant vide, prêt à être réutilisé ou rempli à nouveau.

Méthodes courantes sur les dictionnaires

Les dictionnaires Python disposent de plusieurs méthodes pratiques pour manipuler et explorer leur contenu. Voici quelques-unes des méthodes les plus utiles que vous utiliserez souvent.

Obtenir les clés avec keys()

La méthode keys() renvoie un objet contenant toutes les clés du dictionnaire, ce qui est pratique pour parcourir ou vérifier la présence d’une clé.

Exemple d’utilisation de keys() :

personne = {
    "nom": "Alice",
    "âge": 30,
    "ville": "Paris"
}


# Obtenir les clés
cles = personne.keys()
print(cles)     # Affiche : dict_keys(['nom', 'âge', 'ville'])

Obtenir les valeurs avec values()

La méthode values() retourne toutes les valeurs du dictionnaire. Vous pouvez l’utiliser pour parcourir uniquement les valeurs.

Exemple d’utilisation de values() :

# Obtenir les valeurs
valeurs = personne.values()
print(valeurs)  # Affiche : dict_values(['Alice', 30, 'Paris'])

Obtenir les paires clé-valeur avec items()

La méthode items() renvoie une vue contenant des paires clé-valeur sous forme de tuples. Cette méthode est particulièrement utile pour parcourir un dictionnaire en obtenant à la fois les clés et les valeurs.

Exemple d’utilisation de items() :

# Obtenir les paires clé-valeur
paires = personne.items()
print(paires)   # Affiche : dict_items([('nom', 'Alice'), ('âge', 30), ('ville', 'Paris')])

Exemple de parcours avec items()

Vous pouvez utiliser items() dans une boucle pour accéder aux clés et valeurs en même temps.

for cle, valeur in personne.items():
    print(f"{cle} : {valeur}")
# Affiche :
# nom : Alice
# âge : 30
# ville : Paris

Ces méthodes vous permettent de manipuler efficacement le contenu d’un dictionnaire et d’accéder facilement à ses différentes parties selon vos besoins.

Compréhension de dictionnaire

La compréhension de dictionnaire est une méthode concise pour créer et manipuler des dictionnaires en Python. Inspirée des compréhensions de listes, cette syntaxe permet de générer un dictionnaire en une seule ligne, en appliquant des filtres ou transformations aux clés et valeurs.

Syntaxe de base

La syntaxe d’une compréhension de dictionnaire est similaire à celle des listes, mais utilise des accolades {} et suit le format {clé: valeur for élément in iterable}.

Exemple de compréhension de dictionnaire simple :

# Créer un dictionnaire de carrés
carres = {x: x**2 for x in range(1, 6)}
print(carres)   # Affiche : {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Dans cet exemple, j’ai créé un dictionnaire où chaque nombre de 1 à 5 est une clé associée à son carré comme valeur.

Filtrer les éléments avec une condition

Vous pouvez ajouter une condition pour filtrer les éléments à inclure dans le dictionnaire.

Exemple de compréhension avec condition :

# Dictionnaire de carrés pour les nombres pairs seulement
carres_pairs = {x: x**2 for x in range(1, 6) if x % 2 == 0}
print(carres_pairs)  # Affiche : {2: 4, 4: 16}

Ici, seules les clés représentant des nombres pairs sont ajoutées au dictionnaire, car j’ai appliqué une condition if x % 2 == 0.

Transformer les valeurs

La compréhension de dictionnaire permet aussi de transformer les valeurs tout en gardant les mêmes clés.

Exemple de transformation des valeurs :

personne = {
    "nom": "Alice",
    "âge": 30,
    "ville": "Paris"
}


# Transformation : ajouter "!" à chaque valeur
personne_maj = {cle: str(valeur) + "!" for cle, valeur in personne.items()}
print(personne_maj)  # Affiche : {'nom': 'Alice!', 'âge': '30!', 'ville': 'Paris!'}

Dans cet exemple, chaque valeur est transformée en chaîne de caractères avec un point d’exclamation ajouté à la fin.

Dictionnaires imbriqués

Un dictionnaire imbriqué est un dictionnaire qui contient d’autres dictionnaires en tant que valeurs. Cette structure est idéale pour stocker des données complexes et hiérarchiques, comme des informations sur des objets ayant plusieurs attributs ou sous-attributs.

Création d’un dictionnaire imbriqué

Vous pouvez créer un dictionnaire imbriqué en assignant un dictionnaire comme valeur à une clé.

Exemple de dictionnaire imbriqué :

employes = {
    "employe1": {"nom": "Alice", "âge": 30, "poste": "Développeuse"},
    "employe2": {"nom": "Bob", "âge": 25, "poste": "Designer"},
    "employe3": {"nom": "Charlie", "âge": 35, "poste": "Manager"}
}


print(employes)
# Affiche :
# {
#   'employe1': {'nom': 'Alice', 'âge': 30, 'poste': 'Développeuse'},
#   'employe2': {'nom': 'Bob', 'âge': 25, 'poste': 'Designer'},
#   'employe3': {'nom': 'Charlie', 'âge': 35, 'poste': 'Manager'}
# }

Dans cet exemple, chaque employé est une clé dans le dictionnaire employes, et sa valeur est un autre dictionnaire contenant ses attributs.

Accéder aux éléments dans un dictionnaire imbriqué

Pour accéder aux éléments d’un dictionnaire imbriqué, utilisez plusieurs paires de crochets [] pour descendre dans les niveaux de la structure.

Exemple d’accès aux données :

# Accéder au poste de "employe2"
poste_employe2 = employes["employe2"]["poste"]
print(poste_employe2)  # Affiche : Designer

Ici, j’accède d’abord à la clé "employe2", puis à la clé "poste" à l’intérieur du sous-dictionnaire correspondant.

Modifier un élément dans un dictionnaire imbriqué

Vous pouvez modifier des valeurs dans un dictionnaire imbriqué de la même manière que dans un dictionnaire simple.

Exemple de modification :

# Changer le poste de "employe3"
employes["employe3"]["poste"] = "Directeur"
print(employes["employe3"])  # Affiche : {'nom': 'Charlie', 'âge': 35, 'poste': 'Directeur'}

Parcourir un dictionnaire imbriqué

Pour parcourir un dictionnaire imbriqué, utilisez une boucle for et items() pour accéder aux clés et sous-dictionnaires, puis une autre boucle pour parcourir les éléments du sous-dictionnaire.

Exemple de parcours :

for employe, details in employes.items():
    print(f"Détails de {employe} :")
    for cle, valeur in details.items():
        print(f"  {cle} : {valeur}")
# Affiche :
# Détails de employe1 :
#   nom : Alice
#   âge : 30
#   poste : Développeuse
# Détails de employe2 :
#   nom : Bob
#   âge : 25
#   poste : Designer
# Détails de employe3 :
#   nom : Charlie
#   âge : 35
#   poste : Directeur

Manipuler des dictionnaires avec des fonctions avancées

Python propose plusieurs fonctions intégrées qui facilitent les manipulations avancées avec les dictionnaires, permettant de créer, fusionner et transformer des dictionnaires efficacement.

Utiliser dict() pour créer un dictionnaire

La fonction dict() permet de créer un dictionnaire à partir de paires clé-valeur sous forme de tuples, ou d’un autre type de données compatible.

Exemple avec dict() :

# Création d'un dictionnaire avec des tuples
infos_personne = dict([("nom", "Alice"), ("âge", 30), ("ville", "Paris")])
print(infos_personne)  # Affiche : {'nom': 'Alice', 'âge': 30, 'ville': 'Paris'}

Fusionner des dictionnaires avec update()

La méthode update() permet de fusionner deux dictionnaires en mettant à jour le premier avec les clés et valeurs du second. Si des clés existent déjà, leurs valeurs seront écrasées.

Exemple d’utilisation de update() :

personne = {"nom": "Alice", "âge": 30}
autres_infos = {"ville": "Paris", "âge": 31}  # Âge mis à jour


personne.update(autres_infos)
print(personne)  # Affiche : {'nom': 'Alice', 'âge': 31, 'ville': 'Paris'}

Ici, la valeur de "âge" a été mise à jour avec celle de autres_infos, et la clé "ville" a été ajoutée.

Créer un dictionnaire avec zip()

La fonction zip() est pratique pour créer un dictionnaire à partir de deux listes : l’une pour les clés, l’autre pour les valeurs.

Exemple de création avec zip() :

cles = ["nom", "âge", "ville"]
valeurs = ["Alice", 30, "Paris"]


personne = dict(zip(cles, valeurs))
print(personne)  # Affiche : {'nom': 'Alice', 'âge': 30, 'ville': 'Paris'}

Fusionner plusieurs dictionnaires avec **

Vous pouvez également utiliser l’opérateur ** pour fusionner plusieurs dictionnaires en un seul.

Exemple de fusion avec ** :

dictionnaire1 = {"nom": "Alice", "âge": 30}
dictionnaire2 = {"ville": "Paris", "poste": "Développeuse"}


personne_complete = {**dictionnaire1, **dictionnaire2}
print(personne_complete)
# Affiche : {'nom': 'Alice', 'âge': 30, 'ville': 'Paris', 'poste': 'Développeuse'}

Utiliser des expressions générées par dictionnaire

Vous pouvez aussi créer un dictionnaire en utilisant des compréhensions et des fonctions ensemble.

Exemple de transformation de valeurs avec une fonction :

# Multiplication par 2 des valeurs dans un dictionnaire de nombres
nombres = {"a": 1, "b": 2, "c": 3}
nombres_double = {k: v * 2 for k, v in nombres.items()}
print(nombres_double)  # Affiche : {'a': 2, 'b': 4, 'c': 6}

Ces fonctions avancées permettent de manipuler les dictionnaires de manière flexible et efficace, que ce soit pour des opérations simples ou des transformations plus complexes.

Exercice

Dans cet exercice, vous allez construire pas à pas un programme en Python pour gérer une bibliothèque de livres. L’objectif est de pratiquer les manipulations de dictionnaires : ajout, modification, suppression et recherche de données. Vous allez aussi pratiquer l’usage des méthodes clés des dictionnaires pour explorer et manipuler ces données.

Scénario

Vous êtes responsable de la gestion des informations de la bibliothèque d’une petite école. Vous devez créer un programme pour stocker les informations de chaque livre, telles que le titre, l’auteur, l’année de publication, et le genre. Vous allez suivre chaque étape pour construire votre programme.

Étapes de l’exercice

  1. Créer un dictionnaire pour un livre

    • Créez un dictionnaire pour un livre avec les informations suivantes : titre, auteur, année de publication, et genre. Remplissez-le avec un exemple de votre choix.

  2. Créer une bibliothèque sous forme de dictionnaire

    • Créez un dictionnaire vide appelé bibliotheque pour stocker plusieurs livres.
    • Ajoutez le livre que vous avez créé dans la première étape en lui assignant un identifiant unique (comme “Livre1”).

  3. Ajouter plusieurs livres à la bibliothèque

    • Créez au moins deux autres livres sous forme de dictionnaires avec les mêmes informations (titre, auteur, année, genre).
    • Ajoutez-les à bibliotheque en utilisant des identifiants uniques (comme “Livre2”, “Livre3”, etc.).

  4. Afficher les informations de tous les livres

    • Parcourez le dictionnaire bibliotheque pour afficher les informations de chaque livre. Utilisez une boucle for pour afficher chaque livre sous la forme :
    Livre1:
      Titre : [titre]
      Auteur : [auteur]
      Année : [année]
      Genre : [genre]

  5. Rechercher un livre par titre

    • Demandez à l’utilisateur de saisir un titre de livre.
    • Parcourez bibliotheque pour vérifier si un livre avec ce titre existe.
    • Si le livre est trouvé, affichez toutes ses informations. Sinon, affichez un message indiquant que le livre n’a pas été trouvé.

  6. Modifier les informations d’un livre

    • Demandez à l’utilisateur de saisir l’identifiant d’un livre (par exemple, “Livre1”).
    • Demandez-lui ensuite quelle information il souhaite modifier (titre, auteur, année ou genre) et la nouvelle valeur.
    • Mettez à jour le dictionnaire bibliotheque avec cette nouvelle information.

  7. Supprimer un livre de la bibliothèque

    • Demandez à l’utilisateur de saisir l’identifiant d’un livre à supprimer (par exemple, “Livre2”).
    • Supprimez le livre correspondant du dictionnaire bibliotheque.

  8. Afficher les livres d’un genre spécifique

    • Demandez à l’utilisateur de saisir un genre (par exemple, “Science-fiction”).
    • Parcourez bibliotheque et affichez les informations de tous les livres appartenant à ce genre.

Bonnes pratiques pour travailler avec les dictionnaires en Python

Les dictionnaires sont des structures très puissantes en Python, mais pour les utiliser efficacement et éviter certains écueils, il est important de suivre quelques bonnes pratiques. Ces conseils vous aideront à écrire du code Python plus lisible, performant, et moins sujet aux erreurs.

Utilisez des clés immuables et descriptives

Les clés dans un dictionnaire doivent être immuables, comme des chaînes de caractères, des entiers, ou des tuples (si les éléments du tuple sont eux-mêmes immuables). Par ailleurs, choisissez des noms de clés significatifs qui rendent votre code lisible et compréhensible. Par exemple, préférez "nom" plutôt que "n" pour stocker un nom.

Exemple :

# Bonnes pratiques pour les clés
profil_utilisateur = {
    "nom": "Alice",
    "âge": 30,
    "email": "alice@example.com"
}

Préférez get() pour accéder aux valeurs lorsque les clés peuvent être absentes

Plutôt que d’accéder directement à une clé avec [], utilisez la méthode get() lorsque vous n’êtes pas sûr que la clé existe dans le dictionnaire. get() vous permet d’éviter une erreur KeyError et de fournir une valeur par défaut si la clé est absente.

Exemple :

# Accès sécurisé avec get()
age = profil_utilisateur.get("âge", "Non spécifié")

Utilisez des méthodes de parcours adaptées au contexte

Python propose plusieurs façons de parcourir les dictionnaires. En fonction de votre besoin (seulement les clés, seulement les valeurs, ou les deux), choisissez la méthode la plus adaptée.

  • Utilisez keys() si vous ne voulez parcourir que les clés.
  • Utilisez values() pour parcourir uniquement les valeurs.
  • Utilisez items() pour parcourir les paires clé-valeur.

Cela rend votre code plus lisible et exprime votre intention plus clairement.

Exemple :

# Parcours avec items() pour accéder à la fois aux clés et valeurs
for cle, valeur in profil_utilisateur.items():
    print(f"{cle} : {valeur}")

Évitez d’imbriquer trop de niveaux de dictionnaires

Bien que les dictionnaires imbriqués soient utiles, une structure trop complexe devient rapidement difficile à lire et à maintenir. Si un dictionnaire contient plusieurs niveaux d’imbrication, envisagez de simplifier la structure ou de regrouper les données en utilisant des classes ou des objets pour organiser les informations de manière plus claire.

Exemple :

Au lieu de ceci :

# Dictionnaire avec plusieurs niveaux d'imbrication
societe = {
    "service_IT": {
        "employes": {
            "Alice": {"poste": "Développeuse"},
            "Bob": {"poste": "Administrateur"}
        }
    }
}

Envisagez une structure plus plate ou l’utilisation d’objets.

Utilisez des compréhensions de dictionnaire pour des transformations simples

Les compréhensions de dictionnaire sont idéales pour créer de nouveaux dictionnaires en appliquant des transformations aux données. Elles sont souvent plus efficaces et lisibles que les boucles traditionnelles, à condition que l’opération reste simple.

Exemple :

# Double les valeurs dans un dictionnaire de notes
notes = {"Alice": 10, "Bob": 8, "Charlie": 9}
notes_double = {nom: note * 2 for nom, note in notes.items()}

Videz un dictionnaire avec clear() plutôt que de recréer une nouvelle variable

Si vous devez vider un dictionnaire existant sans créer une nouvelle variable, utilisez clear(). Cela peut être plus performant, surtout si d’autres références pointent vers le même dictionnaire.

Exemple :

# Vider un dictionnaire
profil_utilisateur.clear()

Évitez les modifications de dictionnaire pendant un parcours

Modifier un dictionnaire tout en le parcourant peut provoquer des erreurs et des comportements imprévisibles. Si vous avez besoin de modifier un dictionnaire pendant que vous le parcourez, envisagez d’abord de créer une copie avec .copy() ou d’accumuler les changements dans un dictionnaire séparé.

Exemple :

# Parcours sécurisé avec copy()
for cle in list(profil_utilisateur.keys()):
    if cle == "email":
        profil_utilisateur.pop(cle)

Commentez les structures complexes

Lorsque vous utilisez des dictionnaires avec des structures complexes ou imbriquées, commentez votre code pour que vous (ou d’autres développeurs) puissiez comprendre la structure et l’intention derrière chaque clé. Cela facilite la maintenance et la lisibilité.

Exemple :

# Structure d'un employé avec des informations imbriquées
employe = {
    "nom": "Alice",
    "poste": "Développeuse",
    # Informations de contact
    "contact": {
        "email": "alice@example.com",
        "telephone": "123456789"
    }
}

Testez l’existence d’une clé avant de modifier ses valeurs

Si vous devez mettre à jour la valeur d’une clé, vérifiez d’abord son existence avec in pour éviter des erreurs KeyError. Cela est particulièrement utile dans des applications où les données proviennent de sources externes (fichiers, API, etc.).

Exemple :

if "email" in profil_utilisateur:
    profil_utilisateur["email"] = "nouveau_email@example.com"
else:
    print("L'email n'existe pas dans le profil utilisateur.")

En suivant ces bonnes pratiques, vous vous assurez de tirer le meilleur parti des dictionnaires Python tout en produisant du code lisible, maintenable, et optimisé. Les dictionnaires sont des structures extrêmement puissantes, et maîtriser leur utilisation est essentiel pour écrire des programmes Python performants et robustes.

Conclusion

Les dictionnaires avec les listes est des types essentiels pour organiser et manipuler des données associatives de manière efficace. Grâce à leur structure en paires clé-valeur, ils permettent un accès rapide aux informations, ce qui est précieux pour de nombreuses applications, comme le stockage de configurations, la gestion de données complexes, ou encore le traitement d’objets imbriqués.

En maîtrisant les dictionnaires et leurs multiples fonctionnalités, vous disposez d’un atout puissant pour structurer efficacement vos programmes et manipuler vos données de manière fluide et optimisée. N’hésitez pas à expérimenter avec ces techniques et à les adapter selon vos besoins pour tirer le meilleur parti des dictionnaires dans vos projets.