Dictionary Basics: Creation, Access, and Iteration

1. Qu'est-ce qu'un dictionnaire ?

Un dictionnaire en Python est une collection non ordonnée (avant Python 3.7) et modifiable de paires clé-valeur. Depuis Python 3.7, ils conservent l'ordre d'insertion, mais leur principal atout reste l'accès par clé.

• Paires clé-valeur : Chaque élément est un couple. La clé est un identifiant unique pour accéder à la valeur.
• Clés uniques et immuables : Les clés d'un dictionnaire doivent être uniques. On utilise le plus souvent des chaînes de caractères ou des nombres comme clés.
• Mutable : Vous pouvez ajouter, modifier ou supprimer des paires clé-valeur après la création du dictionnaire.

On crée un dictionnaire avec des accolades {}.

# Un dictionnaire représentant un étudiant
etudiant = {
    "nom": "Jean",
    "age": 25,
    "cours": ["Maths", "Physique"]
}




# Un dictionnaire pour les hyperparamètres d'un modèle
hyperparametres = {
    "learning_rate": 0.01,
    "epochs": 100,
    "optimizer": "Adam"
}




# On peut aussi créer un dictionnaire vide
dict_vide = {}

2. Accéder, ajouter et modifier des éléments

La principale force des dictionnaires est de pouvoir manipuler les données via des clés explicites.

Accéder aux valeurs

Il y a deux manières principales d'accéder à une valeur :

1. Avec les crochets [] : dictionnaire['cle']. C'est la méthode la plus directe. Cependant, si la clé n'existe pas, votre programme s'arrêtera avec une erreur (KeyError).
2. Avec la méthode .get() : dictionnaire.get('cle'). C'est une méthode plus sûre. Si la clé n'existe pas, elle renvoie None par défaut, sans provoquer d'erreur. Vous pouvez même spécifier une valeur par défaut à renvoyer : dictionnaire.get('cle', 'valeur_par_defaut').

Ajouter et modifier des paires clé-valeur

La syntaxe pour ajouter et modifier est la même, ce qui est très pratique :

• Si la clé n'existe pas, une nouvelle paire clé-valeur est créée.
• Si la clé existe déjà, sa valeur est mise à jour.

# Dictionnaire initial
hyperparametres = {
    "learning_rate": 0.01,
    "epochs": 100
}




# Mettre à jour une valeur existante
hyperparametres['epochs'] = 150
print(f"Après mise à jour : {hyperparametres}")




# Ajouter une nouvelle clé
hyperparametres['batch_size'] = 32
print(f"Après ajout : {hyperparametres}")

Pour mettre à jour plusieurs paires d'un coup, on peut utiliser la méthode .update().

3. Supprimer des éléments

Pour supprimer des paires clé-valeur, vous avez deux options principales :

• Le mot-clé del : del dictionnaire['cle']. Supprime la paire clé-valeur de manière définitive.
• La méthode .pop() : valeur_supprimee = dictionnaire.pop('cle'). Cette méthode est intéressante car elle supprime la paire, mais vous retourne aussi la valeur qui était associée à la clé. C'est utile si vous avez besoin de réutiliser cette valeur.

L'image suivante résume les opérations de base que nous venons de voir. C'est un excellent aide-mémoire.

4. Itérer sur un dictionnaire

Parcourir le contenu d'un dictionnaire est une opération très courante. Python offre plusieurs manières de le faire.

• Itérer sur les clés (comportement par défaut) :

  for cle in hyperparametres:
      print(cle) 
  
  
  
  # ou de manière explicite :
  for cle in hyperparametres.keys():
      print(cle)
  

• Itérer sur les valeurs :

  for valeur in hyperparametres.values():
      print(valeur)
  

• Itérer sur les paires clé-valeur (le plus utile !) :
  La méthode .items() retourne chaque paire sous forme de tuple (clé, valeur), que l'on peut "déballer" directement dans la boucle for.

  for cle, valeur in hyperparametres.items():
      print(f"Le paramètre '{cle}' a la valeur : {valeur}")
  

Pour renforcer ces concepts en arabe, vous pouvez consulter la vidéo d'Elzero. Il y explique plusieurs méthodes utiles pour les dictionnaires.

5. Exercice pratique

Imaginons que vous configurez un modèle de classification. Vos hyperparamètres sont stockés dans un dictionnaire.

# 1. Créez un dictionnaire 'config_modele' avec les paires suivantes :
#    - 'model_name': 'LogisticRegression'
#    - 'regularization': 'L2'
#    - 'penalty_strength': 0.1
config_modele = {
    'model_name': 'LogisticRegression',
    'regularization': 'L2',
    'penalty_strength': 0.1
}
print(f"Configuration initiale : {config_modele}")




# 2. Vous décidez d'augmenter la force de la pénalité.
#    Mettez à jour la valeur de 'penalty_strength' à 1.0.
config_modele['penalty_strength'] = 1.0
print(f"Après ajustement de la pénalité : {config_modele}")




# 3. Vous voulez ajouter un paramètre pour le nombre d'itérations maximum.
#    Ajoutez la clé 'max_iter' avec la valeur 1000.
config_modele['max_iter'] = 1000
print(f"Après ajout de max_iter : {config_modele}")




# 4. Finalement, vous décidez que le nom du modèle n'est pas un hyperparamètre.
#    Supprimez la clé 'model_name' et sa valeur.
del config_modele['model_name']
print(f"Configuration finale des hyperparamètres : {config_modele}")




# 5. Affichez joliment chaque hyperparamètre final sur une nouvelle ligne.
print("\n--- Hyperparamètres finaux ---")
for cle, valeur in config_modele.items():
    print(f"- {cle}: {valeur}")

Résultat attendu :

Configuration initiale : {'model_name': 'LogisticRegression', 'regularization': 'L2', 'penalty_strength': 0.1}
Après ajustement de la pénalité : {'model_name': 'LogisticRegression', 'regularization': 'L2', 'penalty_strength': 1.0}
Après ajout de max_iter : {'model_name': 'LogisticRegression', 'regularization': 'L2', 'penalty_strength': 1.0, 'max_iter': 1000}
Configuration finale des hyperparamètres : {'regularization': 'L2', 'penalty_strength': 1.0, 'max_iter': 1000}

--- Hyperparamètres finaux ---
- regularization: L2
- penalty_strength: 1.0
- max_iter: 1000

Conclusion

Vous savez maintenant manipuler les dictionnaires, l'une des structures de données les plus utiles en Python. Leur capacité à associer des étiquettes (clés) à des données (valeurs) les rend indispensables pour gérer des informations structurées de manière lisible et efficace.

Points clés à retenir :

• Les dictionnaires stockent des paires clé-valeur dans des accolades {}.
• On accède aux valeurs via les clés, soit avec ['cle'] (rapide mais risque d'erreur), soit avec .get('cle') (plus sûr).
• L'assignation d['cle'] = valeur permet d'ajouter ou de modifier une paire.
• On supprime des éléments avec del ou .pop().
• Pour itérer sur les clés et les valeurs, la boucle for cle, valeur in dictionnaire.items(): est la méthode la plus courante et la plus claire.

Dans la prochaine leçon, nous aborderons deux autres structures de données : les tuples et les sets. Vous découvrirez pourquoi on a parfois besoin de collections non modifiables (tuples) et comment gérer efficacement des ensembles d'éléments uniques (sets).