Dictionnaires en Python

Les Dictionnaires Python

Les dictionnaires sont le type de mappage fondamental de Python. Ils stockent des collections de paires clé-valeur (key-value pairs), où chaque clé (key) doit être unique et immuable (immutable) (comme les chaînes de caractères (strings), les nombres ou les tuples (tuples) ne contenant que des éléments immuables). Les valeurs (values) peuvent être de n’importe quel type et peuvent être dupliquées.

Les dictionnaires sont définis à l’aide d’accolades {}. Un dictionnaire vide est {}. Les éléments sont séparés par des virgules, avec un deux-points : séparant chaque clé de sa valeur.

# Création de dictionnaires
empty_dict = {}
student = {
    'name': 'Zara',
    'age': 17,
    'courses': ['Math', 'Physics']
}
config = dict(host='localhost', port=8080) # Alternative utilisant dict()

Note importante : À partir de Python 3.7+, les dictionnaires standard conservent l’ordre d’insertion des éléments. Dans les versions antérieures (3.6 et inférieures), les dictionnaires étaient non ordonnés.

Accéder aux valeurs dans un dictionnaire

Vous accédez à la valeur associée à une clé en utilisant la notation entre crochets [].

student = {'name': 'Zara', 'age': 17, 'class': 'First'}

print(f"Nom de l'étudiant : {student['name']}")
print(f"Âge de l'étudiant : {student['age']}")

Sortie :

Nom de l'étudiant : Zara
Âge de l'étudiant : 17

Tenter d’accéder à une clé qui n’existe pas avec [] lèvera une KeyError.

student = {'name': 'Zara', 'age': 17}

# Ceci provoquera une erreur :
# print(f"Note de l'étudiant : {student['grade']}")

Pour accéder aux clés en toute sécurité, vous pouvez utiliser la méthode get(), qui renvoie None (ou une valeur par défaut spécifiée) si la clé n’est pas trouvée.

grade = student.get('grade') # Returns None
default_grade = student.get('grade', 'N/A') # Returns 'N/A'
print(f"Note (accès sécurisé) : {grade}")
print(f"Note (avec valeur par défaut) : {default_grade}")

Mettre à jour un dictionnaire

Vous pouvez ajouter de nouvelles paires clé-valeur ou modifier celles existantes en utilisant l’opérateur d’affectation = avec la notation entre crochets.

student = {'name': 'Zara', 'age': 17, 'class': 'First'}

# Mettre à jour une entrée existante
student['age'] = 18

# Ajouter une nouvelle entrée
student['school'] = "Springfield High"
student['contact'] = {'email': 'zara@example.com'} # Les valeurs peuvent être complexes

print(f"Âge mis à jour : {student['age']}")
print(f"École : {student['school']}")
print(f"Coordonnées : {student['contact']}")
print(f"Dictionnaire complet : {student}")

Sortie :

Âge mis à jour : 18
École : Springfield High
Coordonnées : {'email': 'zara@example.com'}
Dictionnaire complet : {'name': 'Zara', 'age': 18, 'class': 'First', 'school': 'Springfield High', 'contact': {'email': 'zara@example.com'}}

Vous pouvez également fusionner des dictionnaires en utilisant la méthode update() ou l’opérateur de fusion | (Python 3.9+).

more_info = {'city': 'Shelbyville', 'age': 19} # Notez que 'age' se chevauche
student.update(more_info) # Met à jour les clés existantes, ajoute les nouvelles
print(f"Après update() : {student}")

# Utilisation de l'opérateur de fusion (Python 3.9+)
extra = {'country': 'USA'}
merged_student = student | extra
print(f"Après merge | : {merged_student}")

Supprimer des éléments de dictionnaire

Vous pouvez supprimer des paires clé-valeur individuelles, vider l’intégralité du dictionnaire ou supprimer l’objet dictionnaire lui-même.

student = {'name': 'Zara', 'age': 18, 'class': 'First', 'school': 'Springfield High'}

# Supprimer l'entrée avec la clé 'class' en utilisant del
del student['class']
print(f"Après del student['class'] : {student}")

# Supprimer l'entrée avec la clé 'school' en utilisant pop() (renvoie la valeur)
school = student.pop('school')
print(f"École supprimée : {school}")
print(f"Après pop('school') : {student}")

# Supprimer le dernier élément inséré (Python 3.7+)
last_item = student.popitem()
print(f"Dernier élément supprimé : {last_item}")
print(f"Après popitem() : {student}")

# Supprimer toutes les entrées du dictionnaire
student.clear()
print(f"Après clear() : {student}")

# Supprimer entièrement l'objet dictionnaire
del student
# print(student) # Ceci lèverait maintenant une NameError

Sortie (variera légèrement pour popitem en fonction de l’ordre d’insertion exact) :

Après del student['class'] : {'name': 'Zara', 'age': 18, 'school': 'Springfield High'}
École supprimée : Springfield High
Après pop('school') : {'name': 'Zara', 'age': 18}
Dernier élément supprimé : ('age', 18)
Après popitem() : {'name': 'Zara'}
Après clear() : {}

Propriétés des clés de dictionnaire

Les clés de dictionnaire possèdent deux propriétés importantes :

1. Les clés doivent être uniques : Un dictionnaire ne peut pas avoir de clés dupliquées. Si vous assignez une valeur à une clé existante, la valeur originale est écrasée.
2. Les clés doivent être immuables : Les clés doivent être d’un type hachable (hashable). Cela inclut les nombres (int, float), les chaînes de caractères (strings), les booléens (booleans) et les tuples ne contenant que des éléments immuables. Les listes (lists), les dictionnaires ou les ensembles (sets) ne peuvent pas être utilisés comme clés car ils sont mutables (mutable) (leur contenu peut changer).

Exemple (Clés dupliquées) :

dict_dup = {
    'name': 'Zara',
    'age': 7,
    'name': 'Manni' # Cette affectation écrase le 'name' précédent
}

print(f"dict_dup['name'] : {dict_dup['name']}") # Sortie : Manni

Exemple (Clés immuables) :

# Clés valides
valid_keys = {
    10: 'Number',
    'user': 'Admin',
    (1, 2): 'Tuple Key',
    True: 'Boolean Key'
}
print(valid_keys)

# Clé invalide (la liste est mutable)
# invalid_keys = {
#    ['list_key']: 'This will fail'
# }
# TypeError: type inhashable : 'list'

Méthodes et opérations des dictionnaires

Les dictionnaires Python prennent en charge diverses fonctions et méthodes intégrées :

Fonctions courantes :

Fonction	Description
len(dict)	Renvoie le nombre de paires clé-valeur (éléments) dans le dictionnaire.
str(dict)	Renvoie une représentation textuelle imprimable du dictionnaire.
type(variable)	Renvoie le type de la variable. S’il s’agit d’un dictionnaire, renvoie <class 'dict'>.

Méthodes clés des dictionnaires :

Méthode	Description
dict.clear()	Supprime tous les éléments du dictionnaire.
dict.copy()	Renvoie une copie superficielle (shallow copy) du dictionnaire.
dict.fromkeys(seq[, value])	Crée un nouveau dictionnaire avec des clés provenant de seq et des valeurs définies à value (par défaut None). (Méthode de classe)
dict.get(key[, default])	Renvoie la valeur pour key si key est dans le dictionnaire, sinon default. Si default n’est pas fourni, il est par défaut None.
dict.items()	Renvoie un objet vue (view object) affichant une liste de paires clé-valeur sous forme de tuples du dictionnaire. Les modifications apportées au dictionnaire sont reflétées dans la vue.
dict.keys()	Renvoie un objet vue affichant une liste des clés du dictionnaire. Les modifications apportées au dictionnaire sont reflétées dans la vue.
dict.values()	Renvoie un objet vue affichant une liste des valeurs du dictionnaire. Les modifications apportées au dictionnaire sont reflétées dans la vue.
dict.pop(key[, default])	Supprime la clé spécifiée et renvoie la valeur correspondante. Si la clé n’est pas trouvée, default est renvoyé si fourni, sinon une KeyError est levée.
dict.popitem()	Supprime et renvoie la dernière paire clé-valeur insérée (sous forme de tuple). Lève une KeyError si le dictionnaire est vide. (Avant Python 3.7, supprimait une paire arbitraire).
dict.setdefault(key[, default])	Si key est dans le dictionnaire, renvoie sa valeur. Sinon, insère key avec une valeur de default et renvoie default. default est par défaut None.
dict.update([other])	Met à jour le dictionnaire avec les paires clé-valeur de other (un autre dictionnaire ou un itérable de paires clé-valeur), écrasant les clés existantes.

Vérifier l’existence d’une clé :

La manière préférée de vérifier si une clé existe est d’utiliser l’opérateur in :

student = {'name': 'Zara', 'age': 18}

if 'age' in student:
    print("La clé 'age' existe.")

if 'grade' not in student:
    print("La clé 'grade' n'existe pas.")

Note : La méthode dict.has_key(key) utilisée dans Python 2 est obsolète et a été supprimée dans Python 3. Utilisez l’opérateur in à la place.

Compréhensions de dictionnaires (Dictionary Comprehensions)

Similaire aux compréhensions de listes (list comprehensions), vous pouvez créer des dictionnaires de manière concise :

squares = {x: x*x for x in range(1, 6)}
# squares sera : {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
print(squares)