Langage Python

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Les dictionnaires en Python

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.

Les dictionnaires sont optimisés pour récupérer des valeurs lorsque la clé est connue.

Créer un dictionnaire

Créer un dictionnaire est aussi simple que de placer des éléments entre accolades {}, séparés par une virgule.

Exemple 1 :
                                # dictionnaire vide
                                dict1={}
                                print("dict1 : ",dict1)

                                #dictionnaire avec des clés de type chaines
                                dict2={"Prenom":"Mostafa", "age":20,"ville":"Meknes"}
                                print("dict2 : ",dict2)

                                # dictionnaire avec des clés entières
                                dict3= {1:"Meknes", 2:"Marrakech", 3:"Essaouira"}
                                print("dict3 : ",dict3)

                                # dictionnaire avec des clés mixtes
                                dict4={1:"Mostafa", "ville":"Meknes", 10.4: 1.78}
                                print("dict4 : ",dict4)

                                # Création d'un dictionnaire avec la méthode dict ()
                                dict5 = dict({1: 'Dev', 2: 'Info', 3:'COM'}) 
                                print("dict5 : ",dict5)

                                # Créer un dictionnaire avec chaque élément en paire
                                dict6 = dict([(1, 'Geeks'), (2, 'For')]) 
                                print("dict6 : ",dict6)
                            
dict1 : {}
dict2 : {'Prenom': 'Mostafa', 'age': 20, 'ville': 'Meknes'}
dict3 : {1: 'Meknes', 2: 'Marrakech', 3: 'Essaouira'}
dict4 : {1: 'Mostafa', 'ville': 'Meknes', 10.4: 1.78}
dict5 : {1: 'Dev', 2: 'Info', 3: 'COM'}
dict6 : {1: 'Geeks', 2: 'For'}

Comme vous pouvez le voir ci-dessus, nous pouvons également créer un dictionnaire en utilisant la fonction intégrée dict().

Comment accéder aux éléments d'un dictionnaire?

Comme indiqué précédemment, l'ordre des éléments dans un dictionnaire peut varier. Par conséquent, nous ne pouvons pas utiliser l'indice de l'élément pour accéder à la valeur. Au lieu de cela, nous utilisons une clé. Pour accéder à la valeur du dictionnaire, nous utilisons la syntaxe suivante:

                                nom_dictionnaire[clé]
                            
Exemple 2 :
                                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])

                            
Clé 1 : Mostafa
clé ville Meknes
Clé 10.4 : 1.78

Si la clé spécifiée n'existe pas, une exception KeyError sera déclenchée.

Exemple 3 :
                                D={1:"Mostafa", "ville":"Meknes", 10.4: 1.78}
                                print(D[2])

                            
Traceback (most recent call last):
File "prog.py", line 2, in < module>
print(D[2])
KeyError: 2

Ajout et modification des éléments

Dictionnaire sont mutables. Nous pouvons ajouter de nouveaux éléments ou modifier la valeur des éléments existants à l'aide d'un opérateur d'affectation.

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 4 :
                                D={1:"Mostafa", "ville":"Marrakech", 10.4: 1.78}
                                print(D)

                                # modifier la ville
                                D["ville"]="Meknes"
                                print(" D : ", D)

                                # ajouter une clé age
                                D["age"]=32
                                print(" D : ", D)



                            
{1: 'Mostafa', 'ville': 'Marrakech', 10.4: 1.78}
D : {1: 'Mostafa', 'ville': 'Meknes', 10.4: 1.78}
D : {1: 'Mostafa', 'ville': 'Meknes', 10.4: 1.78, 'age': 32}

Supprimer des éléments

Nous pouvons 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.

La méthode popitem() peut être utilisée pour supprimer et renvoyer un élément arbitraire (clé, valeur) du dictionnaire. Tous les éléments peuvent être supprimés à la fois en utilisant la méthode clear().

Nous pouvons également utiliser le mot-clé del pour supprimer des éléments individuels ou le dictionnaire entier lui-même.

Exemple 5 :
                                D={1:"Mostafa", "ville":"Marrakech", 10.4: 1.78, "age":32, 3:45, "tt":"test"}
                                print(D)

                                print("val : ", D.pop(1))
                                print("pop : ",D)

                                print("val : ", D.popitem())
                                print("popitem : ",D)

                                del D["age"]
                                print("del : ", D)

                                # vider le dictionnaire
                                D.clear()
                                print(D)

                            
{1: 'Mostafa', 'ville': 'Marrakech', 10.4: 1.78, 'age': 32, 3: 45, 'tt': 'test'}
val : Mostafa
pop : {'ville': 'Marrakech', 10.4: 1.78, 'age': 32, 3: 45, 'tt': 'test'}

val : ('tt', 'test')
popitem : {'ville': 'Marrakech', 10.4: 1.78, 'age': 32, 3: 45}

del : {'ville': 'Marrakech', 10.4: 1.78, 3: 45}

{}

Méthodes de dictionnaire

Les méthodes disponibles avec dictionnaire sont résumées ci-dessous. Certains d'entre eux ont déjà été utilisés dans les exemples ci-dessus.

MéthodeDescription
clear()Supprimer tous les éléments du dictionnaire.
copy()Retourne une copie superficielle du dictionnaire.
fromkeys( seq[, v])Renvoie un nouveau dictionnaire avec les clés de seq et une valeur égale à v (la valeur par défaut est None).
get( clé[, d])Renvoie la valeur de la clé. Si la clé n'existe pas, retourne d (la valeur par défaut est None).
items()Renvoie une nouvelle vue des éléments du dictionnaire (clé, valeur).
keys()Renvoie une nouvelle vue des clés du dictionnaire.
pop( clé[, d])Supprimez l'élément avec "clé" et renvoyez sa valeur ou "d" si "clé" est introuvable. Si "d" n'est pas fourni et que "key" n'est pas trouvé, KeyError est levé.
popitem()Supprimer et renvoyer un élément arbitraire (clé, valeur). KeyError si le dictionnaire est vide.
setdefault( clé[, d])Si "clé" est dans le dictionnaire, retourne sa valeur. Sinon, insérez "key" avec la valeur "d" et renvoyez "d" (la valeur par défaut est None).
update([ dict])Mettez à jour le dictionnaire avec les paires clé/valeur de dict en remplaçant les clés existantes.
values()Renvoyer une nouvelle vue des valeurs du dictionnaire
Exemple 6 :
                                D={1:"Mostafa", "ville":"Marrakech", 10.4: 1.78}
                                cles=D.keys()
                                print(cles)
                                print(type(cles))
                            
dict_keys([1, 'ville', 10.4])
< 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:

Exemple 7 :
                                D={1:"Mostafa", "ville":"Marrakech", 10.4: 1.78}
                                cles=list(D.keys())
                                print(cles)
                                print(type(cles))
                            
[1, 'ville', 10.4]
< class 'list'>
Exemple 8 :
                                D={1:"Mostafa", "ville":"Marrakech", 10.4: 1.78}
                                
                                for elem in D.items():
                                    print(elem)
                            
(1, 'Mostafa')
('ville', 'Marrakech')
(10.4, 1.78)

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :