Les dictionnaires Python, fréquemment appelés tableaux associatifs ou "maps" dans d'autres langages, représentent une structure de données fondamentale pour l'organisation d'informations. Ils stockent des données sous forme de paires "clé-valeur", où chaque clé est unique et est associée à une valeur spécifique. Cette caractéristique les rend particulièrement efficaces pour la recherche, la récupération et la manipulation rapide de données.
Voici les principales propriétés des dictionnaires :
- Clés uniques et immuables : Chaque clé au sein d'un dictionnaire doit être unique et d'un type immuable (par exemple, des chaînes de caractères, des nombres, ou des tuples).
- Valeurs flexibles : Les valeurs associées aux clés peuvent être de n'importe quel type de données Python, incluant d'autres dictionnaires, des listes ou des objets personnalisés.
- Accès rapide : L'accès aux valeurs via leurs clés est extrêmement performant, ce qui est un avantage majeur par rapport aux listes pour des recherches spécifiques.
- Ordonnancement : Depuis Python 3.7 (et de manière implémentation-spécifique depuis 3.6 pour CPython), les dictionnaires conservent l'ordre d'insertion des éléments.
Création de dictionnaires
Un dictionnaire peut être instancié de plusieurs manières en Python :
-
Par littéral de dictionnaire (syntaxe
{}) : C'est la méthode la plus directe et la plus courante pour définir un dictionnaire.informations_contact = {'nom': 'Dupont', 'prenom': 'Sophie', 'email': 'sophie.dupont@exemple.com'} print(informations_contact) # Output: {'nom': 'Dupont', 'prenom': 'Sophie', 'email': 'sophie.dupont@exemple.com'} -
Avec le constructeur
dict():- À partir d'arguments nommés : Utile lorsque les clés sont des identifiants Python valides.
parametres_serveur = dict(port=8080, timeout=30, debug_mode=True) print(parametres_serveur) # Output: {'port': 8080, 'timeout': 30, 'debug_mode': True} -
À partir d'un itérable de paires (clé, valeur) : Comme une liste de tuples ou d'autres dictionnaires.
liste_donnees = [('fruit', 'pomme'), ('couleur', 'rouge')]
produit = dict(liste_donnees)
print(produit)
# Output: {'fruit': 'pomme', 'couleur': 'rouge'}
- À partir d'un autre dictionnaire (pour créer une copie superficielle) :
copie_parametres = dict(parametres_serveur)
print(copie_parametres)
# Output: {'port': 8080, 'timeout': 30, 'debug_mode': True}
-
Avec la méthode de classe
dict.fromkeys(): Cette méthode permet de créer un dictionnaire à partir d'une séquence de clés en leur assignant la même valeur par défaut.liste_statuts = ['initialise', 'en_attente', 'traite'] statuts_par_defaut = dict.fromkeys(liste_statuts, False) print(statuts_par_defaut) # Output: {'initialise': False, 'en_attente': False, 'traite': False} # Exemple avec une chaîne de caractères comme itérable pour les clés valeurs_numeriques = dict.fromkeys('abc', 100) print(valeurs_numeriques) # Output: {'a': 100, 'b': 100, 'c': 100}
Opérations de manipulation (CRUD)
Ajout et mise à jour d'éléments
-
Assignation directe (
mon_dict[clé] = valeur) : C'est la méthode la plus simple pour ajouter un nouvel élément ou modifier la valeur d'une clé existante.notes_etudiants = {'Alice': 15, 'Bob': 12} notes_etudiants['Charlie'] = 18 # Ajout d'une nouvelle entrée notes_etudiants['Alice'] = 16 # Mise à jour de la note d'Alice print(notes_etudiants) # Output: {'Alice': 16, 'Bob': 12, 'Charlie': 18} -
setdefault(clé, valeur_defaut): Ajoute une paire clé-valeur si la clé n'existe pas, et retourne la valeur associée. Si la clé existe déjà, elle ne modifie pas sa valeur et retourne la valeur existante.configuration = {'theme': 'clair'} configuration.setdefault('theme', 'sombre') # 'theme' existe, aucune modification configuration.setdefault('langue', 'fr') # 'langue' n'existe pas, ajoutée print(configuration) # Output: {'theme': 'clair', 'langue': 'fr'} -
update(autre_dictionnaire)ouupdate(arguments_nommes): Fusionne le dictionnaire actuel avec un autre dictionnaire ou des paires clé-valeur fournies. Les clés existantes sont mises à jour, et les nouvelles sont ajoutées.profil_utilisateur = {'pseudo': 'dev_python', 'email': 'dev@exemple.com'} nouvelles_infos = {'email': 'nouveau@exemple.com', 'abonnement': 'premium'} profil_utilisateur.update(nouvelles_infos) print(profil_utilisateur) # Output: {'pseudo': 'dev_python', 'email': 'nouveau@exemple.com', 'abonnement': 'premium'} profil_utilisateur.update(derniere_connexion='2024-01-10') print(profil_utilisateur) # Output: {'pseudo': 'dev_python', 'email': 'nouveau@exemple.com', 'abonnement': 'premium', 'derniere_connexion': '2024-01-10'}
Suppression d'éléments
-
del mon_dict[clé]: Supprime la paire clé-valeur spécifiée. UneKeyErrorest levée si la clé n'existe pas.liste_courses = {'lait': 1, 'pain': 2, 'oeufs': 12} del liste_courses['pain'] print(liste_courses) # Output: {'lait': 1, 'oeufs': 12} -
pop(clé, [valeur_defaut]): Supprime l'élément avec la clé spécifiée et retourne sa valeur. Si la clé n'est pas trouvée, et qu'unevaleur_defautest fournie, celle-ci est retournée. Sinon, uneKeyErrorest levée.commandes_en_cours = {'ID001': 'en_preparation', 'ID002': 'en_livraison'} statut_commande1 = commandes_en_cours.pop('ID001') print(f"Commande ID001: {statut_commande1}") # Output: Commande ID001: en_preparation print(commandes_en_cours) # Output: {'ID002': 'en_livraison'} statut_commande3 = commandes_en_cours.pop('ID003', 'non_trouve') print(f"Commande ID003: {statut_commande3}") # Output: Commande ID003: non_trouve -
popitem(): Supprime et retourne la dernière paire clé-valeur insérée sous forme de tuple(clé, valeur). Avant Python 3.7, l'élément supprimé était arbitraire.journal_activite = {'login': '2024-01-10', 'logout': '2024-01-10'} derniere_action = journal_activite.popitem() print(f"Dernière action: {derniere_action}") # Output: Dernière action: ('logout', '2024-01-10') print(journal_activite) # Output: {'login': '2024-01-10'} -
clear(): Supprime tous les éléments du dictionnaire, le rendant vide.cache_temp = {'data1': [1,2,3], 'data2': [4,5,6]} cache_temp.clear() print(cache_temp) # Output: {}
Accès aux éléments (Lecture)
-
Accès par clé (
mon_dict[clé]) : Récupère la valeur associée à la clé. Lève uneKeyErrorsi la clé n'existe pas.produit_details = {'nom': 'Smartphone', 'marque': 'TechBrand', 'prix': 699} print(f"Nom du produit: {produit_details['nom']}") # Output: Nom du produit: Smartphone # print(produit_details['disponibilite']) # Cette ligne lèverait une KeyError -
get(clé, [valeur_defaut]): Récupère la valeur associée à la clé. Si la clé n'existe pas, retourneNonepar défaut ou lavaleur_defautspécifiée.parametres_profil = {'pseudo': 'admin', 'notifications': True} print(f"Pseudo: {parametres_profil.get('pseudo')}") # Output: Pseudo: admin print(f"Email: {parametres_profil.get('email')}") # Output: Email: None print(f"Theme: {parametres_profil.get('theme', 'sombre')}") # Output: Theme: sombre -
Itération : Pour parcourir les éléments d'un dictionnaire.
- Parcourir les clés :
inventaire_fruits = {'pomme': 100, 'banane': 50, 'orange': 75} for fruit_cle in inventaire_fruits: # Ou for fruit_cle in inventaire_fruits.keys(): print(f"Clé: {fruit_cle}") # Output: # Clé: pomme # Clé: banane # Clé: orange -
Parcourir les valeurs :
for quantite_valeur in inventaire_fruits.values():
print(f"Quantité: {quantite_valeur}")
# Output:
# Quantité: 100
# Quantité: 50
# Quantité: 75
- Parcourir les paires clé-valeur (
items()) :
for cle, valeur in inventaire_fruits.items():
print(f"Fruit: {cle}, Quantité: {valeur}")
# Output:
# Fruit: pomme, Quantité: 100
# Fruit: banane, Quantité: 50
# Fruit: orange, Quantité: 75
Piège avec dict.fromkeys() et les valeurs mutables
Il est crucial de comprendre que si la valeur par défaut fournie à dict.fromkeys() est un objet mutable (comme une liste ou un autre dictionnaire), toutes les clés du nouveau dictionnaire partageront la même référence à cet objet. Modifier l'objet via une clé affectera la valeur pour toutes les clés.
# Exemple INCORRECT: La liste est partagée par toutes les clés
sessions_utilisateurs_incorrect = dict.fromkeys(['user_A', 'user_B'], [])
sessions_utilisateurs_incorrect['user_A'].append('actif')
print(sessions_utilisateurs_incorrect)
# Output: {'user_A': ['actif'], 'user_B': ['actif']} (Les deux utilisateurs ont la même liste modifiée)
# Exemple CORRECT: Créer des objets mutables distincts pour chaque clé
sessions_utilisateurs_correct = {user: [] for user in ['user_X', 'user_Y']}
sessions_utilisateurs_correct['user_X'].append('connecté')
print(sessions_utilisateurs_correct)
# Output: {'user_X': ['connecté'], 'user_Y': []} (Chaque utilisateur a sa propre liste)
Formatage de chaînes avec des dictionnaires
Python offre plusieurs mécanismes pour insérer des valeurs de dictionnaire dans des chaînes de caractères :
-
L'opérateur
%(méthode traditionnelle) :donnees_employe = {'nom': 'Martin', 'age': 35, 'poste': 'Chef de projet'} message_employe = "L'employé %(nom)s a %(age)d ans et occupe le poste de %(poste)s." % donnees_employe print(message_employe) # Output: L'employé Martin a 35 ans et occupe le poste de Chef de projet. -
Méthode
str.format():message_employe_format = "L'employé {nom} a {age} ans et occupe le poste de {poste}.".format(**donnees_employe) print(message_employe_format) # Output: L'employé Martin a 35 ans et occupe le poste de Chef de projet. -
F-strings (chaînes de caractères formatées, Python 3.6+) : La méthode la plus moderne et recommandée.
message_employe_fstring = f"L'employé {donnees_employe['nom']} a {donnees_employe['age']} ans et occupe le poste de {donnees_employe['poste']}." print(message_employe_fstring) # Output: L'employé Martin a 35 ans et occupe le poste de Chef de projet.
Dictionnaires imbriqués
Les dictionnaires peuvent contenir d'autres dictionnaires, des listes ou toute autre structure de données, permettant de modéliser des informatoins complexes et hiérarchiques.
details_commande = {
'id_commande': 'ORD789',
'client': {
'nom': 'Léa Dubois',
'adresse': '123 Rue de la Paix',
'ville': 'Lyon'
},
'articles': [
{'produit_id': 'P001', 'quantite': 2, 'prix_unitaire': 25.50},
{'produit_id': 'P005', 'quantite': 1, 'prix_unitaire': 120.00}
],
'statut': 'validée'
}
# Exemples de manipulation de dictionnaires imbriqués :
# 1. Accéder au nom du client:
print(f"Nom du client: {details_commande['client']['nom']}")
# Output: Nom du client: Léa Dubois
# 2. Changer le statut de la commande:
details_commande['statut'] = 'expédiée'
print(f"Nouveau statut: {details_commande['statut']}")
# Output: Nouveau statut: expédiée
# 3. Ajouter un article à la commande:
details_commande['articles'].append({'produit_id': 'P010', 'quantite': 3, 'prix_unitaire': 5.99})
print(f"Articles mis à jour: {details_commande['articles']}")
# Output: Articles mis à jour: [{'produit_id': 'P001', 'quantite': 2, 'prix_unitaire': 25.5}, {'produit_id': 'P005', 'quantite': 1, 'prix_unitaire': 120.0}, {'produit_id': 'P010', 'quantite': 3, 'prix_unitaire': 5.99}]
# 4. Mettre à jour la quantité d'un article existant (si on connaît son index ou le cherche):
# Supposons que nous voulons changer la quantité du premier article (P001)
if details_commande['articles'][0]['produit_id'] == 'P001':
details_commande['articles'][0]['quantite'] = 3
print(f"Quantité de P001 mise à jour: {details_commande['articles'][0]['quantite']}")
# Output: Quantité de P001 mise à jour: 3