Dictionnaire Python

Dans ce didacticiel, vous apprendrez tout sur les dictionnaires Python ; comment ils sont créés, accéder, ajouter, supprimer des éléments et diverses méthodes intégrées.

Vidéo :Dictionnaires Python pour stocker des paires clé/valeur

Le dictionnaire Python est une collection non ordonnée d'éléments. Chaque élément d'un dictionnaire a un key/value paire.

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

Création d'un dictionnaire Python

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

Un article a un key et un value correspondant exprimé sous forme de couple (clé :valeur ).

Alors que les valeurs peuvent être de n'importe quel type de données et peuvent se répéter, les clés doivent être de type immuable (chaîne, nombre ou tuple avec des éléments immuables) et doivent être uniques.

# empty dictionary
my_dict = {}

# dictionary with integer keys
my_dict = {1: 'apple', 2: 'ball'}

# dictionary with mixed keys
my_dict = {'name': 'John', 1: [2, 4, 3]}

# using dict()
my_dict = dict({1:'apple', 2:'ball'})

# from sequence having each item as a pair
my_dict = dict([(1,'apple'), (2,'ball')])

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

Accéder aux éléments du dictionnaire

Alors que l'indexation est utilisée avec d'autres types de données pour accéder aux valeurs, un dictionnaire utilise keys . Les clés peuvent être utilisées soit entre crochets [] ou avec le get() méthode.

Si nous utilisons les crochets [] , KeyError est déclenchée si une clé n'est pas trouvée dans le dictionnaire. En revanche, le get() la méthode renvoie None si la clé n'est pas trouvée.

# get vs [] for retrieving elements
my_dict = {'name': 'Jack', 'age': 26}

# Output: Jack
print(my_dict['name'])

# Output: 26
print(my_dict.get('age'))

# Trying to access keys which doesn't exist throws error
# Output None
print(my_dict.get('address'))

# KeyError
print(my_dict['address'])

Sortie

Jack
26
None
Traceback (most recent call last):
  File "<string>", line 15, in <module>
    print(my_dict['address'])
KeyError: 'address'

Modification et ajout d'éléments de dictionnaire

Les dictionnaires sont modifiables. Nous pouvons ajouter de nouveaux éléments ou modifier la valeur d'éléments existants à l'aide d'un opérateur d'affectation.

Si la clé est déjà présente, la valeur existante est mise à jour. Si la clé n'est pas présente, une nouvelle (clé :valeur ) paire est ajoutée au dictionnaire.

# Changing and adding Dictionary Elements
my_dict = {'name': 'Jack', 'age': 26}

# update value
my_dict['age'] = 27

#Output: {'age': 27, 'name': 'Jack'}
print(my_dict)

# add item
my_dict['address'] = 'Downtown'

# Output: {'address': 'Downtown', 'age': 27, 'name': 'Jack'}
print(my_dict)

Sortie

{'name': 'Jack', 'age': 27}
{'name': 'Jack', 'age': 27, 'address': 'Downtown'}

Supprimer des éléments du dictionnaire

Nous pouvons supprimer un élément particulier dans un dictionnaire en utilisant le pop() méthode. Cette méthode supprime un élément avec le key fourni et renvoie le value .

Le popitem() peut être utilisée pour supprimer et renvoyer un (key, value) arbitraire paire d'éléments du dictionnaire. Tous les éléments peuvent être supprimés en une fois, en utilisant le clear() méthode.

On peut aussi utiliser le del mot-clé pour supprimer des éléments individuels ou le dictionnaire entier lui-même.

# Removing elements from a dictionary

# create a dictionary
squares = {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# remove a particular item, returns its value
# Output: 16
print(squares.pop(4))

# Output: {1: 1, 2: 4, 3: 9, 5: 25}
print(squares)

# remove an arbitrary item, return (key,value)
# Output: (5, 25)
print(squares.popitem())

# Output: {1: 1, 2: 4, 3: 9}
print(squares)

# remove all items
squares.clear()

# Output: {}
print(squares)

# delete the dictionary itself
del squares

# Throws Error
print(squares)

Sortie

16
{1: 1, 2: 4, 3: 9, 5: 25}
(5, 25)
{1: 1, 2: 4, 3: 9}
{}
Traceback (most recent call last):
  File "<string>", line 30, in <module>
    print(squares)
NameError: name 'squares' is not defined

Méthodes du dictionnaire Python

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

Méthode	Description
effacer()	Supprime tous les éléments du dictionnaire.
copier()	Renvoie une copie superficielle du dictionnaire.
fromkeys(seq[, v])	Renvoie un nouveau dictionnaire avec les clés de `seq` et valeur égale à `v` (par défaut à `None` ).
obtenir(clé[,d])	Renvoie la valeur de la `clé` . Si la `clé` n'existe pas, renvoie `d` (par défaut `None` ).
éléments()	Renvoyer un nouvel objet des éléments du dictionnaire au format (clé, valeur).
clés()	Renvoie un nouvel objet des clés du dictionnaire.
pop(touche[,d])	Supprime l'élément avec la `clé` et renvoie sa valeur ou `d` si `clé` n'est pas trouvé. Si `d` n'est pas fourni et la `clé` n'est pas trouvé, il lève `KeyError` .
popitem()	Supprime et renvoie un élément arbitraire (clé, valeur ). Augmente `KeyError` si le dictionnaire est vide.
setdefault(clé[,d])	Renvoie la valeur correspondante si la `clé` est dans le dictionnaire. Sinon, insère la `clé` avec une valeur de `d` et renvoie `d` (par défaut à `None` ).
mettre à jour([autre])	Met à jour le dictionnaire avec les paires clé/valeur de `other` , écrasant les clés existantes.
valeurs()	Renvoie un nouvel objet des valeurs du dictionnaire

Voici quelques exemples de cas d'utilisation de ces méthodes.

# Dictionary Methods
marks = {}.fromkeys(['Math', 'English', 'Science'], 0)

# Output: {'English': 0, 'Math': 0, 'Science': 0}
print(marks)

for item in marks.items():
    print(item)

# Output: ['English', 'Math', 'Science']
print(list(sorted(marks.keys())))

Sortie

{'Math': 0, 'English': 0, 'Science': 0}
('Math', 0)
('English', 0)
('Science', 0)
['English', 'Math', 'Science']

Compréhension du dictionnaire Python

La compréhension du dictionnaire est une manière élégante et concise de créer un nouveau dictionnaire à partir d'un itérable en Python.

La compréhension du dictionnaire consiste en une paire d'expressions (clé :valeur ) suivi d'un for instruction entre accolades {} .

Voici un exemple pour faire un dictionnaire avec chaque élément étant une paire d'un nombre et son carré.

# Dictionary Comprehension
squares = {x: x*x for x in range(6)}

print(squares)

Sortie

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Ce code est équivalent à

squares = {}
for x in range(6):
    squares[x] = x*x
print(squares)

Sortie

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Une compréhension de dictionnaire peut éventuellement contenir plus d'instructions for ou if.

Un if facultatif peut filtrer les éléments pour former le nouveau dictionnaire.

Voici quelques exemples pour créer un dictionnaire avec uniquement des éléments impairs.

# Dictionary Comprehension with if conditional
odd_squares = {x: x*x for x in range(11) if x % 2 == 1}

print(odd_squares)

Sortie

{1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

Pour en savoir plus sur les compréhensions du dictionnaire, visitez Python Dictionary Comprehension.

Autres opérations de dictionnaire

Test d'adhésion au dictionnaire

Nous pouvons tester si un key est dans un dictionnaire ou n'utilise pas le mot clé in . Notez que le test d'appartenance est uniquement pour le keys et pas pour le values .

# Membership Test for Dictionary Keys
squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

# Output: True
print(1 in squares)

# Output: True
print(2 not in squares)

# membership tests for key only not value
# Output: False
print(49 in squares)

Sortie

True
True
False

Itérer dans un dictionnaire

Nous pouvons parcourir chaque clé d'un dictionnaire en utilisant un for boucle.

# Iterating through a Dictionary
squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
for i in squares:
    print(squares[i])

Sortie

Fonctions intégrées du dictionnaire

Fonctions intégrées telles que all() , any() , len() , cmp() , sorted() , etc. sont couramment utilisés avec des dictionnaires pour effectuer différentes tâches.

Fonction	Description
tous()	Renvoyer `True` si toutes les clés du dictionnaire sont vraies (ou si le dictionnaire est vide).
tout()	Renvoyer `True` si une clé du dictionnaire est vraie. Si le dictionnaire est vide, retourne `False` .
len()	Renvoyer la longueur (le nombre d'éléments) dans le dictionnaire.
cmp()	Compare les éléments de deux dictionnaires. (Non disponible en Python 3)
trié()	Renvoyer une nouvelle liste triée de clés dans le dictionnaire.

Voici quelques exemples qui utilisent des fonctions intégrées pour travailler avec un dictionnaire.

# Dictionary Built-in Functions
squares = {0: 0, 1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

# Output: False
print(all(squares))

# Output: True
print(any(squares))

# Output: 6
print(len(squares))

# Output: [0, 1, 3, 5, 7, 9]
print(sorted(squares))

Sortie

False
True
6
[0, 1, 3, 5, 7, 9]

Ensembles Python E/S de fichier Python

Python