le dictionnaire de Python

Dans ce tutoriel, vous découvrirez le dictionnaire Python qui vous permet d'organiser des informations apparentées.
Un dictionnaire Python est une collection de paires clé-valeur où chaque clé est associée à une valeur.

Python Type Dictionnaire

Dans le type dictionnaire de python la valeur de la paire clé-valeur peut être un nombre, une chaîne, une liste, un tuple ou même un autre dictionnaire. En fait, vous pouvez utiliser une valeur de n'importe quel type valide en Python comme valeur dans la paire clé-valeur.
Une clé de la paire clé-valeur doit être immuable. En d'autres termes, la clé ne peut pas être modifiée.
Python utilise les accolades {} pour définir un dictionnaire. À l'intérieur des accolades, vous pouvez placer zéro, une ou plusieurs paires clé-valeur.
L'exemple suivant définit un dictionnaire vide :

dictionnaire_vide = {}

En général, on définit un dictionnaire vide avant une boucle, soit la boucle for, soit la boucle while. Et à l'intérieur de la boucle, on ajoute des paires clé-valeur au dictionnaire.
Pour trouver le type d'un dictionnaire, vous utilisez la fonction type() comme suit :

dictionnaire_vide = {}
print(type(dictionnaire_vide))

L'exemple suivant définit un dictionnaire avec quelques paires clé-valeur :

personne = {
    'prénom' : 'Jean',
' Nom ' : 'Doe',
    'âge' :45,
    'competence':[ "Programmation Python", "Bases de données", "Conception de logiciels"],
    actif' : True
}

Le dictionnaire personne comporte cinq paires clé-valeur qui représentent le prénom, le nom, l'âge, les couleurs préférées et le statut actif.

Comment accéder aux valeurs d'un dictionnaire ?

Pour accéder à une valeur par clé dans un dictionnaire, vous pouvez utiliser la notation entre crochets ou la méthode get().

1) Utilisation de la notation entre crochets

Pour accéder à une valeur associée à une clé, on place la clé entre crochets :

dict[clé]

L'exemple suivant montre comment obtenir les valeurs associées à la clé prénom et nom dans le dictionnaire personne :

personne = {
    'prénom' : 'Jean',
' Nom ' : 'Doe',
    'âge' :45,
    'competence':[ "Programmation Python", "Bases de données", "Conception de logiciels"],
    'actif' : True
}
print(personne['prénom'])
print(personne['Nom'])

2) Utilisation de la méthode get()

Si vous tentez d'accéder à une clé qui n'existe pas, vous obtiendrez une erreur. Par exemple :

personne = {
    'prénom' : 'Jean',
' Nom ' : 'Doe',
    'âge' :45,
    'competence':[ "Programmation Python", "Bases de données", "Conception de logiciels"],
    'actif' : True
}

adresse = personne['adresse']

Pour éviter cette erreur, on peut utiliser la méthode get() du dictionnaire :

personne = {
    'prénom' : 'Jean',
' Nom ' : 'Doe',
    'âge' :45,
    'competence':[ "Programmation Python", "Bases de données", "Conception de logiciels"],
    'actif' : True
}

adresse = personne.get('adresse')
print(adresse)

Et comme cet clé n'existe pas, la sortie de ce code sera : None.
Si la clé n'existe pas, la méthode get() renvoie None au lieu de renvoyer une KeyError. Notez que None signifie qu'aucune valeur n'existe.
En outre, en passant la valeur par défaut à son deuxième argument, la méthode get() renvoie la valeur par défaut lorsque la clé n'existe pas. L'exemple suivant renvoie la chaîne '00-000' si la clé adresse n'existe pas dans le dictionnaire personne :

personne = {
    'prénom' : 'Jean',
' Nom ' : 'Doe',
    'âge' :45,
   'competence' :[ "Programmation Python", "Bases de données", "Conception de logiciels"],
    'actif' : True
}

adresse = personne.get('adresse','00-000')
print(adresse)

Ajouter de nouvelles paires clé-valeur

Comme un dictionnaire a une structure dynamique, vous pouvez y ajouter de nouvelles paires clé-valeur à tout moment.
Pour ajouter une nouvelle paire clé-valeur à un dictionnaire, vous devez spécifier le nom du dictionnaire, suivi de la nouvelle clé entre crochets et de la nouvelle valeur.
L'exemple suivant ajoute une nouvelle paire clé-valeur au dictionnaire personne :

personne = {
    'prénom' : 'Jean',
' Nom ' : 'Doe',
    'âge' :45,
   'competence' :[ "Programmation Python", "Bases de données", "Conception de logiciels"],
    'actif' : True
}

personne['genre']='femme'
print(personne)

Modification des valeurs dans une paire clé-valeur

Pour modifier une valeur associée à une clé, vous spécifiez le nom du dictionnaire avec la clé entre crochets et la nouvelle valeur associée à la clé donnée:

dict[clé] = nouvelle_valeur

L'exemple suivant modifie la valeur associée à l'âge du dictionnaire personne :

personne = {
    'prénom' : 'Jean',
' Nom ' : 'Doe',
    'âge' :45,
   'competence' :[ "Programmation Python", "Bases de données", "Conception de logiciels"],
    'actif' : True
}

personne['âge']=46
print(personne)

Suppression d'une paire clé-valeur

Afin de supprimer une paire clé-valeur par une clé, vous utilisez l'instruction del :

del dict[clé]

Dans cette syntaxe, vous spécifiez le nom du dictionnaire et la clé que vous souhaitez supprimer.
L'exemple suivant supprime la clé 'actif' du dictionnaire personne :

personne = {
    'prénom' : 'Jean',
' Nom ' : 'Doe',
    'âge' :45,
   'competence' :[ "Programmation Python", "Bases de données", "Conception de logiciels"],
    'actif' : True
}

del personne['actif']
print(personne)

Boucle dans un dictionnaire

Pour examiner un dictionnaire, vous pouvez utiliser une boucle for pour itérer sur ses paires clé-valeur, ou clés, ou valeurs.

Notez que depuis Python 3.7, lorsque vous parcourez un dictionnaire en boucle, vous obtenez les paires clé-valeur dans l'ordre où vous les avez insérées.

1) Boucle sur toutes les paires clé-valeur d'un dictionnaire

Le dictionnaire Python fournit une méthode appelée items() qui renvoie un objet contenant une liste de paires clé-valeur sous forme de tuples dans une liste.
Par exemple :

personne = {
    'prénom' : 'Jean',
' Nom ' : 'Doe',
    'âge' :45,
   'competence' :[ "Programmation Python", "Bases de données", "Conception de logiciels"],
    'actif' : True
}

print(personne.items())

Pour itérer sur toutes les paires clé-valeur d'un dictionnaire, vous pouvez utiliser une boucle for avec deux variables key et value pour décomposer chaque tuple de la liste :

personne = {
    'prénom' : 'Jean',
' Nom ' : 'Doe',
    'âge' :45,
   'competence' :[ "Programmation Python", "Bases de données", "Conception de logiciels"],
    'actif' : True
}

for key, value in personne.items():
    print(f"{key}: {value}")

Notez que vous pouvez utiliser n'importe quel nom de variable dans la boucle for. Il n'est pas nécessaire qu'il s'agisse de la clé et de la valeur.

2) Boucle à travers toutes les clés d'un dictionnaire

Parfois, vous souhaitez simplement parcourir en boucle toutes les clés d'un dictionnaire. Dans ce cas, vous pouvez utiliser une boucle for avec la méthode keys().
La méthode keys() renvoie un objet qui contient la liste des clés du dictionnaire.
Par exemple :

personne = {
'prénom' : 'Jean',
'Nom ' : 'Doe',
'âge' :45,
'competence' :[ "Programmation Python", "Bases de données", "Conception de logiciels"],
'actif' : True
}

for x in personne.keys():
    print(x)

En fait, le fait de boucler sur toutes les clés est le comportement par défaut lors du bouclage d'un dictionnaire. Par conséquent, vous n'avez pas besoin d'utiliser la méthode keys().
Le code suivant renvoie le même résultat que celui de l'exemple ci-dessus :

personne = {
'prénom' : 'Jean',
'Nom ' : 'Doe',
'âge' :45,
'competence' :[ "Programmation Python", "Bases de données", "Conception de logiciels"],
'actif' : True
}

for x in personne:
    print(x)

3) Parcourir en boucle toutes les valeurs d'un dictionnaire

La méthode values() renvoie une liste de valeurs sans clé.
Pour parcourir toutes les valeurs d'un dictionnaire, vous utilisez une boucle for avec la méthode values() :

personne = {
'prénom' : 'Jean',
'Nom ' : 'Doe',
'âge' :45,
'competence' :[ "Programmation Python", "Bases de données", "Conception de logiciels"],
'actif' : True
}

for x in personne.values():
    print(x)

Le code suivant renvoie le même résultat que celui de l'exemple ci-dessus :

personne = {
'prénom' : 'Jean',
'Nom ' : 'Doe',
'âge' :45,
'competence' :[ "Programmation Python", "Bases de données", "Conception de logiciels"],
'actif' : True
}

for x in personne:
    print(personne[x])

Voir plus sur les boucles dans notre tutoriel

Python Dictionary Comprehension

Une compréhension de dictionnaire vous permet d'exécuter une boucle for sur un dictionnaire et de faire quelque chose sur chaque élément, comme une transformation ou un filtrage, et de renvoyer un nouveau dictionnaire.
Contrairement à une boucle for, une compréhension de dictionnaire offre une syntaxe plus expressive et plus précise si vous l'utilisez correctement.
Voici la syntaxe générale d'une compréhension de dictionnaire :

{key:value for (key,value) in dict.items() if condition}

Cette expression de compréhension de dictionnaire renvoie un nouveau dictionnaire dont l'élément est spécifié par l'expression key : value.

Exemples de compréhension de dictionnaire en Python

Nous allons voir comment utiliser la compréhension de dictionnaire pour transformer et filtrer les éléments d'un dictionnaire.

1) Utilisation de la compréhension de dictionnaire Python pour transformer un dictionnaire

Supposons que vous ayez le dictionnaire suivant dont les éléments sont le symbole et le prix de l'action :

stocks = {
    'ZZPA' : 121,
    'ZNON' : 3380,
    'NSGT' : 219,
    "BLLB" : 280,
    'QCEA' : 266,
    "AVGO" : 144
}

Pour augmenter le prix de chaque action de 2%, vous pouvez créer une boucle for comme celle-ci :

stocks = {
    'ZZPA' : 121,
    'ZNON' : 3380,
    'NSGT' : 219,
    "BLLB" : 280,
    'QCEA' : 266,
    "AVGO" : 144
}
nouveau_stocks = {}
for symbole, prix in stocks.items():
    nouveau_stocks[symbole] = prix*1.02

print(nouveau_stocks)

Comment ça fonctionne?
1, bouclez sur les articles du dictionnaire stocks.
2, augmentez le prix de 2 % et ajoutez l'article au nouveau dictionnaire (nouveau_stocks).
L'exemple suivant montre comment utiliser la compréhension du dictionnaire pour obtenir le même résultat :

stocks = {
    'ZZPA' : 121,
    'ZNON' : 3380,
    'NSGT' : 219,
    "BLLB" : 280,
    'QCEA' : 266,
    "AVGO" : 144
}
nouveau_stocks = {symbole: prix * 1.02 for (symbole, prix) in stocks.items()}
print(nouveau_stocks)

Cette compréhension du dictionnaire est équivalent à la correspondante boucle for, mais il est beaucoup plus facile de la comprendre.

2) Utilisation de la compréhension de dictionnaire Python pour filtrer un dictionnaire

Pour sélectionner les actions dont le prix est supérieur à 200, vous pouvez utiliser la boucle for suivante :

stocks = {
    'ZZPA' : 121,
    'ZNON' : 3380,
    'NSGT' : 219,
    "BLLB" : 280,
    'QCEA' : 266,
    "AVGO" : 144
}
stocks_selection = {}
for symbole, prix in stocks.items():
    if prix > 200:
        stocks_selection[symbole] = prix

print(stocks_selection)

Comment cela fonctionne?
D'abord, il faut itérer sur les éléments du dictionnaire stocks.
Ensuite, ajoutez l'élément au dictionnaire stocks_selection si son prix est supérieur à 200.
Pour obtenir le même résultat, l'exemple suivant utilise la compréhension du dictionnaire avec une clause if :

stocks = {
    'ZZPA' : 121,
    'ZNON' : 3380,
    'NSGT' : 219,
    "BLLB" : 280,
    'QCEA' : 266,
    "AVGO" : 144
}
stocks_selection = {s: p for (s, p) in stocks.items() if p > 200}
print(stocks_selection)

Et vous pouvez comparer entre la boucle for et la compréhension du dictionnaire

Dictionnaires imbriqués

Un dictionnaire peut contenir des dictionnaires, on parle alors de dictionnaires imbriqués.
Exemple Créez un dictionnaire qui contient trois dictionnaires :

mafamille = {
  "enfant1" : {
    "nom" : "Mile",
    "année" : 2004
  },
  "Enfant2" : {
    "nom" : "Biatos",
    "année" : 2007
  },
"enfant3" : {
    "nom" : "Nusil",
    "année" : 2011
  }
}
print(mafamille)

Ou, si vous voulez ajouter trois dictionnaires dans un nouveau dictionnaire :
Exemple Créer trois dictionnaires, puis créer un dictionnaire qui contiendra les trois autres dictionnaires :

Enfant1 = {
    "nom" : "Mile",
    "année" : 2004
  }
Enfant2 = {
    "nom" : "Biatos",
    "année" : 2007
  }
Enfant3 = {
    "nom" : "Nusil",
    "année" : 2011
  }
mafamille = {
    "Enfant1":Enfant1,
    "Enfant2":Enfant2,
    "Enfant2":Enfant2
}
print(mafamille)

Cours precedent

Voir aussi nos tutoriel :