ROYAUME DU MAROC

‫مكتب التكوين المهني وإنعاش الشغل‬

office de la formation professionnelle et de la promotion du travail

ISMONTIC TANGER

LES DICTIONNAIRES

ADDARRAZI ILHAM

2021-2022
Introduction
Comme on l’a vu avec les listes et les tuples, à partir des types de base (int,
float, etc.) il est possible d’élaborer de nouveaux types qu’on appelle des types
construits.

Les éléments d’une liste ou d’un tuple sont ordonnés et on accède à un élément
grâce à sa position en utilisant un numéro qu’on appelle l’indice de l’élément.

Un nouvel exemple de type construit est le dictionnaire.

Le dictionnaire ou tableau associatif n'est pas une séquence mais un autre type
composite. Ils ressemblent aux listes dans une certaine mesure (ils sont
modifiables comme elles), mais les éléments que nous allons y enregistrer ne
seront pas disposés dans un ordre immuable.

En revanche, nous pourrons accéder à n'importe lequel d'entre eux à l'aide d'un
index spécifique que l'on appellera une clé, laquelle pourra être alphabétique,
numérique, ou même d'un type composite sous certaines conditions.
Présentation générale
1. Définition
Les dictionnaires en Python (appelés aussi tableaux associatifs ou table de
hachage), permettent d'associer des valeurs à des clés. A partir d'une clé, on peut
accéder à la valeur qui lui est associée.

Le dictionnaire Python est une collection d'éléments non ordonnés. Alors que
d'autres types de données composées ont uniquement la valeur en tant
qu'élément, un dictionnaire possède une paire clé:valeur.

Un dictionnaire en Python fonctionne de manière similaire au dictionnaire dans

un monde réel. Les clés d'un dictionnaire doivent être uniques et de type de
données immuable, telles que chaînes, entiers et tuples, mais les valeurs-clés
peuvent être répétées et être de n'importe quel type.

Chaque clé correspond à une valeur, nous ne pouvons donc pas avoir de clés
dupliquées. Les dictionnaires sont des objets modifiables, ce qui signifie que
nous pouvons ajouter, supprimer ou mettre à jour les éléments après leur
création.
Présentation générale
2. Les caractéristiques
Les dictionnaires sont des conteneurs comme les listes et les tuples.
Les dictionnaires sont des objets mutables : on peut ajouter, supprimer ou
modifier le contenu.
Les dictionnaires ne sont pas des séquences : on ne peut pas accéder à leur
contenu via un indice.
L'ordre des éléments dans un dictionnaire n'a pas d'importance.
Les clés peuvent être de type str, int, float, tuple de nombre, tuple de tuple de
nombre... mais pas de type list ou un tuple de liste.
Les valeurs peuvent être de n'importe quel type.
Les dictionnaires sont de type dict
Création d’un dictionnaire
1. Un dictionnaire vide
Créer un dictionnaire est aussi simple que de placer des éléments entre
accolades {}, séparés par une virgule.

Pour un dictionnaire vide , on utile la syntaxe suivante:

>>>d={}
>>>print(type(d)) #<class 'dict'>
OU
>>>d2=dict()
>>>print(type(d2)) #<class 'dict'>
Création d’un dictionnaire
2. dictionnaire avec des valeurs
Syntaxe: Nom_dictionnaire={clé1:valeur1,clé2:valeur2,...}
dictionnaire avec des clés entières:
>>>d3= {1:"Meknes", 2:"Marrakech", 3:"Essaouira"}
>>>print("d3: ",d3)
dictionnaire avec des clés de type chaines:
>>>d4={"Prenom":"Mostafa", "age":20,"ville":"Meknes"}
>>>print(« d4 : ",d4)
 dictionnaire avec des clés mixtes
>>>d5={1:"Mostafa", "ville":"Meknes", 10.4: 1.78}
Création d'un dictionnaire avec la méthode dict ()
>>>d6 = dict({1: 'Dev', 2: 'Info', 3:'COM'})
>>>print("d5 : ",dict5)
Accéder aux éléments

Un dictionnaire permet d’accéder à partir d’une de ses clés à la valeur de l’item. Pour lire
cette valeur, on utilise l’indexation par la clé, avec une paire de crochets, comme pour
une liste.
Syntaxe: nom_dictionnaire[clé]
Exemple:

D={1:"Mostafa", "ville":"Meknes", 10.4: 1.78}

print("Clé 1 : ", D[1])
print("clé ville ", D["ville"])
print("Clé 10.4 : ", D[10.4])

#Execution:
Clé 1 : Mostafa
clé ville Meknes
Clé 10.4 : 1.78
Manipulation des dictionnaires
1. Ajout et modification des éléments

Dictionnaire sont mutables. Il est possible d’ajouter de nouveaux éléments ou modifier la

valeur des éléments existants à l'aide d'un opérateur d'affectation.
Pour ajouter des valeurs à un dictionnaire il faut indiquer une clé ainsi qu'une valeur.
Si la clé est déjà présente, la valeur est mise à jour, sinon une nouvelle paire clé: valeur
est ajoutée au dictionnaire.
Exemple:

D = {1: "Mostafa", "ville": "Marrakech", 10.4: 1.78}

print(D)

# ajouter une clé age

D["age"] = 32
print(" D : ", D)

# modifier la ville
D["ville"] = "Tanger"
print(" D : ", D)
Manipulation des dictionnaires
1. Ajout et modification des éléments

Exercice d’application:
Ecrire un programme qui demande à l’utilisateur le nom, le prénom et le numéro d’un
étudiant et qui affiche ensuite un dictionnaire etudiant dont les clés sont « nom », « prenom
» et « numero » et les valeurs celles entrées au clavier par l’utilisateur.
Manipulation des dictionnaires
2. Supprimer des éléments
Il est possible de supprimer un élément particulier dans un dictionnaire en utilisant la
méthode pop(). Cette méthode supprime comme élément avec la clé fournie et retourne
la valeur:

D={1:"Mostafa", "ville":"Marrakech", 10.4: 1.78, "age":32, 3:45, "tt":"test"}

print(D)

print("val : ", [Link](1))

print(‘’D : ",D)

La méthode popitem() peut être utilisée pour supprimer et renvoyer un élément

arbitraire (clé, valeur) du dictionnaire.

print("val : ", [Link]())

print("popitem : ",D)
Il est possible d’utiliser le mot-clé del pour supprimer des éléments individuels ou le
dictionnaire entier lui-même.

del D["age"]
print("del : ", D)
Manipulation des dictionnaires
2. Supprimer des éléments

Il est possible de supprimer plusieurs clés en une seule instruction del :

D = {1: "Mostafa", "ville": "Marrakech", 10.4: 1.78}

del(D[1],D["ville"])
print(D)

Tous les éléments peuvent être supprimés à la fois en utilisant la méthode clear().

D = {1: "Mostafa", "ville": "Marrakech", 10.4: 1.78}

[Link]()
print(D) #affiche {} dictionnaire vide
Les dictionnaires: Manipulation
3. Appartenance à un dictionnaire

Il est possible de tester la présence dans un dictionnaire d’une clé avec l’opérateur
d’appartenance in:

D = {1: "Mostafa", "ville": "Marrakech", 10.4: 1.78}

print( 1 in D) # affiche True
print("Mostafa" in D) #affiche True

L’opérateur not in permet de tester la non-appartenance

print( 1 not in D) # affiche False

print("Mostafa" not in D) #affiche True
Manipulation des dictionnaires
4. Parcours de dictionnaire
Un dictionnaire est un conteneur. Il est possible de parcourir ce conteneur pour examiner
les clés ainsi que les valeurs correspondantes.
Parcours suivant les clés:
Le parcours du dictionnaire s’effectue à l’aide d’une boucle for. Pour parcourir le
dictionnaire, on parcourt les clés , ce qui permet d’accéder à la valeur associée à la clé.
L’ordre de parcours du dictionnaire est non spécifié.
Exemple:

D = {1: "Mostafa", "ville": "Marrakech", 10.4: 1.78}

for key in D:
print(key,"==>",D[key])

Execution
1 ==> Mostafa
ville ==> Marrakech
10.4 ==> 1.78
Manipulation des dictionnaires
4. Parcours de dictionnaire
Parcours suivant les valeurs
On peut parcourir les valeurs d’un dictionnaire avec la méthode values :

D = {1: "Mostafa", "ville": "Marrakech", 10.4: 1.78}

for valeur in [Link]():

print("Valeur:",valeur)

Exécution
Valeur: Mostafa
Valeur: Marrakech
Valeur: 1.78
La méthode [Link] retourne un conteneur qui contient des références vers les objets
qui sont les valeurs du dictionnaire.
L’intérêt de la méthode values est souvent limité car dans un dictionnaire, les valeurs
seules, sans les clés, sont peu utilisables.
Manipulation des dictionnaires
5. Autres méthodes de manipulation:

Méthode keys()
Renvoie une nouvelle vue des clés du dictionnaire.
D={1:"Mostafa", "ville":"Marrakech", 10.4: 1.78}
cles=[Link]()
print(cles) #dict_keys([1, 'ville', 10.4])
print(type(cles)) #<class 'dict_keys'>

La méthode keys() renvoie une séquence de type dict_keys. Considérez

l’objet dict_keys comme une liste immuable que vous pouvez utiliser dans une
boucle for ou le transmettre à d’autres fonctions pour un traitement ultérieur.
Si vous voulez une liste ou un tuple, transmettez simplement le résultat de la
méthode keys() au constructeur list() ou tuple() comme suit:

D={1:"Mostafa", "ville":"Marrakech", 10.4: 1.78}

cles=list([Link]())
print(cles)
print(type(cles))
Les dictionnaires: Manipulation
5. Autres méthodes de manipulation:

Méthode items()
Renvoie une nouvelle vue des éléments du dictionnaire (clé, valeur).
D = {1: "Mostafa", "ville": "Marrakech", 10.4: 1.78}

for elem in [Link]():

print(elem)
Exécution
(1, 'Mostafa')
('ville', 'Marrakech')
(10.4, 1.78)
Manipulation des dictionnaires
5. Autres méthodes de manipulation:

Méthode get()
Renvoie la valeur de la clé. Si la clé n'existe pas, retourne d (la valeur par défaut est
None).
Si on essaie d’accéder à une valeur d’un dictionnaire d avec une clé qui n’existe pas, on
obtient un message d’erreur :

D = {1: "Mostafa", "ville": "Marrakech", 10.4: 1.78}

#print(D[2])
print([Link](2)) #affiche Nonne
print([Link](1)) #affiche Mostafa
Manipulation des dictionnaires
5. Autres méthodes de manipulation:

Méthode fromkeys()
Renvoie un nouveau dictionnaire avec les clés de seq et une valeur égale à v (la valeur
par défaut est None).

keys = ["Ahmed", "Hanae", "Wafae", "Ali", "Mohammed"]

d1= [Link](keys)
d2=[Link](keys,42)
print(d1)
print(d2)

Exécution:

d1={'Ahmed': None, 'Hanae': None, 'Wafae': None, 'Ali': None, 'Mohammed': None}
d2={'Ahmed': 42, 'Hanae': 42, 'Wafae': 42, 'Ali': 42, 'Mohammed': 42}
Convertir une liste de tuples en dictionnaire

Créer un dictionnaire avec chaque élément en paire

Initialiser la liste des tuples avec des données: Assurer que chaque tuple de la liste a
exactement deux éléments).
Passer la liste des tuples à dict et stocker le résultat dans une nouvelle variable.
Exemple:

#list de tuples
list_de_tuples = [(1, 'Rabat'), (2, 'Tanger'), (3, 'Casablanca')]

# Convertir en dictionnaire
dictionnaire = dict(list_de_tuples)

print(dictionnaire )
Trier le contenu d’un dictionnaire

En python, l'objet dict ne conserve pas l'ordre dans lequel les éléments sont ajoutés et ne
possède pas de fonction sort permettant de trier les données suivants les clés ou les
valeurs.
Mais, il est possible d’obtenir la représentation du dictionnaire Python trié dans d’autres
types de données comme la liste.
Il est possible de trier les objets d’un dictionnaire en fonction de leurs clés, la méthode la
plus simple consiste à utiliser la méthode « sorted » de Python, qui prend toute itérable
et renvoie une liste des valeurs triées (par ordre croissant par défaut).
D={4:"Ahemd",20:"Mohamed",3:"Hajar"}
Par clé:
Par valeur:
Ds={}
L=[]
for k in sorted([Link]()):
for v in sorted([Link]()):
Ds[k]=D[k]
[Link](v)
Exécution
Exécution
{3: 'Hajar', 4: 'Ahmed', 20: 'Mohamed'}
['Ahmed', 'Hajar', 'Mohamed']
Le tri par valeur : N’obtient que les valeurs triées
Trier le contenu d’un dictionnaire
Utiliser [Link] pour trier le dictionnaire Python:
import operator
d = {4: 'Ahmed', 20:'Mohamed', 3:'Hajar'}
# Trie par cle
sortieParCle = sorted([Link](), key=[Link](0))
print(sortieParCle) # [(3, 'Hajar'), (4, 'Ahmed'), (20, 'Mohamed')]
print(type(sortieParCle)) #<class 'list'>
d2=dict(sortieParCle)
print(d2) # {3: 'Hajar', 4: 'Ahmed', 20: 'Mohamed'}
#Trie par valeur
sortieParVaelur = sorted([Link](), key=[Link](1))
print(sortieParVaelur) #[(4, 'Ahmed'), (3, 'Hajar'), (20, 'Mohamed')]
print(type(sortieParVaelur)) #<class 'list'>
d2=dict(sortieParVaelur)
print(d2) #{4: 'Ahmed', 3: 'Hajar', 20: 'Mohamed'}
 [Link] retourne la paire clé-valeur des éléments du dictionnaire.
 key=[Link](1) spécifie que la clé de comparaison est la valeur du
dictionnaire, tandis que [Link](0) a la clé de comparaison de la clé du
dictionnaire
Trier le contenu d’un dictionnaire
Utiliser la fonction lambda dans la clé de sorted pour obtenir la clé de comparaison
au lieu de [Link].
d = {4: 'Ahmed', 20:'Mohamed', 3:'Hajar'}
# Trie par cle
sortieParCle = sorted([Link](), key=lambda x:x[0])
print(sortieParCle) # [(3, 'Hajar'), (4, 'Ahmed'), (20, 'Mohamed')]
print(type(sortieParCle)) #<class 'list'>
d2=dict(sortieParCle)
print(d2) # {3: 'Hajar', 4: 'Ahmed', 20: 'Mohamed'}
#Trie par valeur
sortieParVaelur = sorted([Link](), key=lambda x:x[1])
print(sortieParVaelur) #[(4, 'Ahmed'), (3, 'Hajar'), (20, 'Mohamed')]
print(type(sortieParVaelur)) #<class 'list'>
d2=dict(sortieParVaelur)
print(d2) #{4: 'Ahmed', 3: 'Hajar', 20: 'Mohamed'}
 [Link] retourne retourne une liste de paires clé-valeur du dictionnaire et le type de
données de son élément est tuple. x est l’élément de ce tuple, où x[0] est la clé et x[1]
est la valeur. key=lambda x:x[1] indique que la clé de comparaison est la valeur des
éléments du dictionnaire
Trier le contenu d’un dictionnaire
Tri croissant /décroissant
Le trie par défaut est croissant
Le paramètre optionnel reverse peut être défini comme True si les valeurs doivent être
triées en ordre décroissant.
d = {4: 'Ahmed', 20:'Mohamed', 3:'Hajar'}
==>Soit avec fonction lambda
sortieParCle = sorted([Link](), key=lambda x:x[0],reverse=True)
print(sortieParCle ) #[(20, 'Mohamed'), (4, 'Ahmed'), (3, 'Hajar')]
print(type(sortieParCle )) #<class 'list'>
d2=dict(sortieParCle )
print(d2) #{20: 'Mohamed', 4: 'Ahmed', 3: 'Hajar'}

==>Soit avec [Link]

sortieParVaelur = sorted([Link](), key=[Link](1),reverse=True)
print(sortieParVaelur) # [(20, 'Mohamed'), (3, 'Hajar'), (4, 'Ahmed')]
print(type(sortieParVaelur)) #<class 'list'>
d2=dict(sortieParVaelur)
print(d2) # {20: 'Mohamed', 3: 'Hajar', 4: 'Ahmed'}
Manipuler deux dictionnaires
1. Fusionner deux dictionnaires
Étant donné deux dictionnaires d1 et d2, la méthode update permet de fusionner d1 et d2
en d1 tout en laissant intact d2 :

d1 = {"paris" : 30, "madrid" : 35, "oslo" : 20}

d2 = {"new-york" : 28, "madrid" : 40}
print(d1) # {'paris': 30, 'madrid': 35, 'oslo': 20}
print(d2) # {'new-york': 28, 'madrid': 40}
[Link](d2)
print(d1) # {'paris': 30, 'madrid': 40, 'oslo': 20, 'new-york': 28}
print(d2) # {'new-york': 28, 'madrid': 40}

D’une façon générale, si d1 et d2 sont deux dictionnaires alors [Link](d2) étend le

dictionnaire d1 de tous les items de d2. Le dictionnaire d1 est donc en général modifié par
la méthode update.
Plus précisément:
— si k est une clé présente dans d1 et d2, la valeur de k sera remplacée dans d1 par la
valeur de k dans d2
— si k est une clé de d2 non présente dans d1, alors k deviendra une nouvelle clé de d1 et
la valeur de k sera la valeur de k dans d2.
Manipuler deux dictionnaires
2. Copier un dictionnaire
Il y a deux façons équivalentes de procéder à une copie d’un dictionnaire d :
— on utilise la méthode copy de d
— on appelle le constructeur dict sur d
La méthode copy:
d = {"ahmed" : 25, "Hanae" : 70, "Wafae" : 40, "Mohammed" : 15, "Ali" : 18 }
d1=[Link]()
print(d) # {'ahmed': 25, 'Hanae': 70, 'Wafae': 40, 'Mohammed': 15, 'Ali': 18}
print(d1) # {'ahmed': 25, 'Hanae': 70, 'Wafae': 40, 'Mohammed': 15, 'Ali': 18}
d["Hanae"]=100
print(d) # {'ahmed': 25, 'Hanae': 100, 'Wafae': 40, 'Mohammed': 15, 'Ali': 18}
print(d1) # {'ahmed': 25, 'Hanae': 70, 'Wafae': 40, 'Mohammed': 15, 'Ali': 18}
d1["Ali"]=200
print(d) # {'ahmed': 25, 'Hanae': 100, 'Wafae': 40, 'Mohammed': 15, 'Ali': 18}
print(d1) # {'ahmed': 25, 'Hanae': 70, 'Wafae': 40, 'Mohammed': 15, 'Ali': 200}

 d1 est une copie de d.

 si on modifie ou on ajoute une clé, ces médications n’affectent pas le dictionnaire
originel d (c’est en cela que c’est une copie).
Clé d'un dictionnaire avec plusieurs valeurs
associées
Pour avoir plusieurs valeurs associées à une seule clé, il faut associer à la clé un élément
dit itérable comme une liste ou un tuple.

Exemple avec une liste:

d = {'a': [1, 2, 3], 'b': [4, 5, 6, 7], 'c': [8, 9]}
print(type(d)) #<class 'dict'>
print(type(d['a'])) #<class 'list'>
#Parcourir en focntion d cle
for cle in d:
print(cle,d[cle]) #a [1, 2, 3] b [4, 5, 6, 7] c [8, 9]

#parcourir en fonction d valeur

for valeurs in [Link]():
print(valeurs) #[1, 2, 3] [4, 5, 6, 7] [8, 9]

#Parcourir en focntion cle:Valeur

for cle,valeurs in [Link]():
print(cle,valeurs) #a [1, 2, 3] b [4, 5, 6, 7] c [8, 9]
Clé d'un dictionnaire avec plusieurs valeurs
associées
Il est possible d’associer une liste vide et ajouter par la suite des valeurs comme ici:

d = {'a':[], 'b':[], 'c':[]}

d['a'].append(4)
d['a'].append(7)
[Link]('a').append(3)

for k,v in [Link]():

print(k,":",v)

Exécution:
a : [4, 7, 3]
b : []
c : []
Clé d'un dictionnaire avec plusieurs valeurs
associées
Exemple avec un tuple:
d = {'a':(1,2,3), 'b':(3,5), 'c':(5,9)}
print(type(d['a']))
for k,v in [Link]():
print(k,":",v)

Exécution :
<class 'tuple'>
a : (1, 2, 3)
b : (3, 5)
c : (5, 9)