Dictionnaires en Python : clés immuables, get() et pièges à éviter

Les dictionnaires en Python stockent des données sous forme de paires clé-valeur. Cette structure sert dès qu’il faut retrouver une information par un nom précis, comme un profil utilisateur, une configuration, une réponse d’API, un panier, un compteur ou des paramètres d’application.

Contrairement à une liste, où l’accès passe par un index comme 0, 1 ou 2, un dictionnaire permet de demander directement une valeur avec une clé explicite. Le code gagne en lisibilité et l’accès reste rapide quand l’identifiant recherché est connu.

Comprendre la logique clé-valeur avant d’écrire du code

Un dictionnaire Python est un objet de type dict. Il associe une clé unique à une valeur. La clé sert d’étiquette, la valeur contient l’information. Dans un profil utilisateur, la clé peut être « email » et la valeur « [email protected] ».

Exemple : utilisateur = {« nom »: « Lina », « age »: 32, « actif »: True}

Ce dictionnaire contient 3 paires clé-valeur : la clé « nom » renvoie « Lina », la clé « age » renvoie 32, et la clé « actif » renvoie True. Les valeurs peuvent avoir des types différents : chaînes de caractères, nombres, booléens, listes, tuples ou autres dictionnaires.

Dictionnaire ou liste : le bon choix dépend de l’accès aux données

Une liste convient quand l’ordre et la position comptent, par exemple pour une suite d’étapes, une file d’attente ou une collection à parcourir dans son ensemble. Un dictionnaire devient plus pertinent quand chaque élément possède un nom, un identifiant ou une propriété claire.

Structure	Accès principal	Cas d’usage typique
Liste	Par index : liste[0]	Afficher une suite d’éléments dans l’ordre
Dictionnaire	Par clé : dict[« email »]	Retrouver rapidement une information nommée

Sur une collection de 10 000 éléments, chercher une donnée dans une liste peut obliger à parcourir toute la suite si l’on ne connaît pas sa position. Avec un dictionnaire bien structuré, l’accès moyen est généralement en O(1), car Python utilise un mécanisme de hachage pour retrouver la clé.

Créer un dictionnaire Python proprement

La manière la plus courante de créer un dictionnaire consiste à utiliser des accolades. C’est la syntaxe la plus lisible pour déclarer directement des clés et des valeurs.

Exemple : produit = {« nom »: « Clavier », « prix »: 49.90, « stock »: 12}

On peut aussi créer un dictionnaire vide avec {} ou dict(). Ces 2 méthodes sont équivalentes, mais les accolades restent plus directes dans la plupart des exemples.

Exemples : panier = {} ; parametres = dict()

Utiliser dict() et zip() quand les données viennent d’ailleurs

La fonction dict() est utile quand les données arrivent sous forme de couples ou de listes séparées. Avec 2 listes, l’une pour les clés et l’autre pour les valeurs, zip() permet de fabriquer rapidement un dictionnaire.

Exemple : cles = [« nom », « age », « ville »] ; valeurs = [« Nora », 28, « Lyon »] ; profil = dict(zip(cles, valeurs))

Cette approche sert quand on transforme des données issues d’un fichier, d’un formulaire ou d’une API. Elle évite d’écrire chaque paire à la main, à condition que les deux listes soient cohérentes et dans le même ordre.

Quelles clés sont autorisées ?

Les clés d’un dictionnaire doivent être immuables, c’est-à-dire non modifiables après leur création. Les chaînes de caractères, les nombres et les tuples peuvent donc servir de clés. En revanche, une liste ne peut pas être utilisée comme clé, car elle est mutable. Python lève alors une erreur de type TypeError, souvent liée à un objet unhashable.

Exemple valide : tarifs = {(« Paris », « Lyon »): 42, (« Paris », « Marseille »): 79}

Un tuple comme clé peut représenter une combinaison stable, par exemple un trajet, une coordonnée ou une paire de critères. Ce choix reste pertinent quand la clé composée apporte plus de clarté qu’une clé simple.

Lire une valeur sans provoquer d’erreur inutile

L’accès direct à une valeur se fait avec des crochets. C’est simple et efficace lorsque l’on est certain que la clé existe.

Exemple : email = utilisateur[« email »]

Si la clé « email » n’existe pas, Python déclenche une KeyError. Cette erreur est utile pendant le développement, car elle signale une hypothèse fausse. En production ou dans du code qui reçoit des données variables, mieux vaut souvent sécuriser l’accès.

get() : la méthode à utiliser quand la clé peut manquer

La méthode get() permet de récupérer une valeur sans faire planter le programme si la clé est absente. Par défaut, elle renvoie None, mais on peut lui fournir une valeur par défaut plus explicite.

Exemples : ville = utilisateur.get(« ville ») ; role = utilisateur.get(« role », « invité »)

Cette syntaxe est utile avec des données incomplètes : profils utilisateurs, paramètres optionnels, résultats de formulaires ou réponses JSON. Elle évite d’écrire des conditions répétitives et garde l’intention claire.

Un dictionnaire reste plus fiable quand le vocabulaire des clés est stable. Si le même identifiant apparaît sous plusieurs formes, par exemple « user_id », « id » ou « uid », le code devient plus fragile. Mieux vaut choisir une clé unique et la conserver partout.

Vérifier l’existence d’une clé avec in

Quand une action dépend vraiment de la présence d’une clé, l’opérateur in est plus explicite. Il permet de tester l’existence avant de lire, modifier ou supprimer une entrée.

Exemple : if « email » in utilisateur: email = utilisateur[« email »]

Cette vérification est préférable quand l’absence de clé change le comportement du programme. Pour une simple valeur de repli, get() reste souvent plus compact.

Ajouter, modifier, supprimer et fusionner des éléments

Un dictionnaire est mutable : on peut le modifier après sa création. L’ajout et la modification utilisent la même syntaxe d’affectation. Si la clé n’existe pas, elle est créée ; si elle existe déjà, sa valeur est remplacée.

Exemples : utilisateur[« ville »] = « Bordeaux » ; utilisateur[« age »] = 33

update() et setdefault() pour enrichir un dictionnaire

La méthode update() sert à ajouter ou mettre à jour plusieurs éléments à la fois. Elle est pratique pour fusionner des paramètres par défaut avec des options personnalisées, ou pour compléter un objet existant avec de nouvelles informations.

Exemple : utilisateur.update({« role »: « admin », « actif »: False})

Si une clé existe déjà, update() écrase l’ancienne valeur. C’est utile dans certains cas, mais risqué si l’on fusionne deux dictionnaires sans vérifier les doublons. Pour définir une valeur seulement si la clé n’existe pas encore, on peut utiliser setdefault().

Exemple : utilisateur.setdefault(« role », « lecteur »)

pop() ou del : deux façons de supprimer

Pour supprimer une entrée, del retire la clé et sa valeur sans rien retourner. La méthode pop(), elle, supprime l’entrée et renvoie la valeur supprimée. C’est utile si l’on veut l’utiliser immédiatement, par exemple pour déplacer une information.

Exemples : ancien_role = utilisateur.pop(« role », « aucun ») ; del utilisateur[« actif »]

Le second argument de pop() sert de valeur par défaut si la clé est absente. Sans lui, supprimer une clé inexistante peut provoquer une KeyError.

Parcourir, copier et utiliser les dictionnaires dans des cas réels

Un dictionnaire se parcourt souvent avec une boucle for. Par défaut, parcourir un dictionnaire revient à parcourir ses clés. Pour rendre le code plus explicite, Python fournit aussi les méthodes keys(), values() et items().

Exemples : for cle in utilisateur.keys(): … ; for valeur in utilisateur.values(): … ; for cle, valeur in utilisateur.items(): …

La méthode items() est souvent la plus pratique, car elle donne accès à la clé et à la valeur dans la même boucle. Elle sert par exemple à afficher une fiche, à construire un tableau ou à transformer des données avant export.

Dictionnaires imbriqués et données d’API

Les dictionnaires peuvent contenir d’autres dictionnaires. Cette structure imbriquée est fréquente avec les données JSON ou les réponses d’API. Par exemple, un utilisateur peut contenir une adresse, elle-même décrite par une ville, un code postal et un pays.

Exemple : utilisateur = {« nom »: « Nora », « adresse »: {« ville »: « Lyon », « code_postal »: « 69000 »}}

Pour accéder à la ville, on peut écrire : utilisateur[« adresse »][« ville »]. Si une partie de la structure peut manquer, il vaut mieux combiner les vérifications ou utiliser get() étape par étape afin d’éviter les erreurs sur des données incomplètes.

Copie indépendante : attention aux références

Écrire copie = utilisateur ne crée pas une vraie copie : les deux variables pointent vers le même dictionnaire. Modifier l’une modifie l’autre, ce qui surprend souvent les débutants. Pour une copie indépendante de premier niveau, on utilise la méthode copy().

Exemple : copie = utilisateur.copy()

Cette copie reste superficielle : si le dictionnaire contient un autre dictionnaire ou une liste, les objets imbriqués peuvent encore être partagés. C’est un point à surveiller dans les structures complexes, notamment quand on manipule des configurations, des données utilisateur ou des objets issus d’une API.

Bien utilisés, les dictionnaires en Python rendent le code plus expressif : on manipule des informations nommées, pas seulement des positions. Les réflexes utiles sont simples : choisir des clés claires et immuables, préférer get() quand une clé peut manquer, utiliser items() pour parcourir proprement, et se méfier des copies qui ne sont que des références.