12 - Dictionnaires
Pourquoi les dictionnaires ?
Dans une liste, on accède aux éléments par leur indice (un numéro). Mais ce n’est pas toujours la façon la plus naturelle de retrouver une information. Quand on cherche un numéro dans un annuaire, on ne dit pas « je veux l’élément n°37 » mais « je veux le numéro d’Alice ».
Un dictionnaire fonctionne sur ce principe : au lieu d’un indice numérique, on utilise une clé (par exemple un nom, un mot, un code) pour accéder à une valeur (un numéro de téléphone, une définition, une note).
Le programme de NSI appelle p-uplet nommé un tel ensemble de valeurs repérées par des noms (les clés) plutôt que par des positions : c’est ce qu’un dictionnaire Python représente, par opposition au tuple, ou p-uplet, dont les éléments sont repérés par leur indice.
Création d’un dictionnaire
On crée un dictionnaire en plaçant des paires clé: valeur entre accolades {}, séparées par des virgules :
annuaire = {"Alice": "06 12 34 56 78",
"Bob": "07 98 76 54 32",
"Charlie": "06 11 22 33 44"}
print(annuaire)
{'Alice': '06 12 34 56 78', 'Bob': '07 98 76 54 32', 'Charlie': '06 11 22 33 44'}
On peut aussi créer un dictionnaire vide :
d = {}
# ou
d = dict()
Accès à une valeur
On accède à une valeur en indiquant sa clé entre crochets :
annuaire = {"Alice": "06 12 34 56 78",
"Bob": "07 98 76 54 32",
"Charlie": "06 11 22 33 44"}
print(annuaire["Alice"]) # 06 12 34 56 78
print(annuaire["Charlie"]) # 06 11 22 33 44
Attention : si la clé n’existe pas, Python lève une erreur KeyError :
print(annuaire["Diana"]) # KeyError: 'Diana'
Pour éviter cette erreur, on peut utiliser la méthode get() qui renvoie None (ou une valeur par défaut) si la clé est absente :
print(annuaire.get("Diana")) # None
print(annuaire.get("Diana", "???")) # ???
print(annuaire.get("Alice", "???")) # 06 12 34 56 78
Ajouter et modifier des éléments
Pour ajouter un couple clé-valeur ou modifier une valeur existante, on utilise la même syntaxe :
eleve = {"nom": "Dupont", "prenom": "Marie"}
# Ajouter une nouvelle clé
eleve["classe"] = "1NSI"
print(eleve)
# Modifier une valeur existante
eleve["classe"] = "TNSI"
print(eleve)
{'nom': 'Dupont', 'prenom': 'Marie', 'classe': '1NSI'}
{'nom': 'Dupont', 'prenom': 'Marie', 'classe': 'TNSI'}
Si la clé existe déjà, la valeur est remplacée (un dictionnaire ne peut pas contenir deux fois la même clé).
Supprimer un élément
On supprime un couple clé-valeur avec le mot-clé del :
eleve = {"nom": "Dupont", "prenom": "Marie", "classe": "1NSI"}
del eleve["classe"]
print(eleve) # {'nom': 'Dupont', 'prenom': 'Marie'}
Longueur et appartenance
La fonction len() renvoie le nombre de couples clé-valeur :
eleve = {"nom": "Dupont", "prenom": "Marie", "classe": "1NSI"}
print(len(eleve)) # 3
L’opérateur in teste si une clé est présente dans le dictionnaire :
print("nom" in eleve) # True
print("age" in eleve) # False
print("Dupont" in eleve) # False (in teste les CLÉS, pas les valeurs)
Parcourir un dictionnaire
Parcours des clés
Par défaut, une boucle for sur un dictionnaire parcourt ses clés :
eleve = {"nom": "Dupont", "prenom": "Marie", "classe": "1NSI"}
for cle in eleve:
print(f"{cle} : {eleve[cle]}")
nom : Dupont
prenom : Marie
classe : 1NSI
On peut aussi utiliser la méthode keys() pour être plus explicite :
for cle in eleve.keys():
print(cle)
Parcours des valeurs
La méthode values() renvoie les valeurs :
for valeur in eleve.values():
print(valeur)
Dupont
Marie
1NSI
Parcours des couples (clé, valeur)
La méthode items() renvoie les paires sous forme de tuples :
for cle, valeur in eleve.items():
print(f"{cle} → {valeur}")
nom → Dupont
prenom → Marie
classe → 1NSI
Dictionnaires et listes
En pratique, on combine souvent les dictionnaires et les listes. Par exemple, une classe d’élèves peut être représentée comme une liste de dictionnaires :
classe = [
{"nom": "Dupont", "prenom": "Marie", "moyenne": 14.5},
{"nom": "Martin", "prenom": "Alice", "moyenne": 16.0},
{"nom": "Durand", "prenom": "Bob", "moyenne": 12.5}
]
# Afficher les noms et moyennes
for eleve in classe:
print(f"{eleve['prenom']} {eleve['nom']} : {eleve['moyenne']}")
Marie Dupont : 14.5
Alice Martin : 16.0
Bob Durand : 12.5
# Calculer la moyenne de la classe
total = sum([e["moyenne"] for e in classe])
print(f"Moyenne de la classe : {total / len(classe)}")
Moyenne de la classe : 14.333333333333334
Types des clés et des valeurs
Les clés doivent être immutables
Les clés d’un dictionnaire doivent être de type immutable : nombres, chaînes de caractères ou tuples. Les listes et les dictionnaires ne peuvent pas servir de clés.
# Clés de types variés
d = {42: "un entier", "nom": "une chaîne", (0, 1): "un tuple"}
print(d[42]) # un entier
print(d[(0, 1)]) # un tuple
# Une liste comme clé → erreur
d = {[1, 2]: "interdit"} # TypeError: unhashable type: 'list'
Les valeurs peuvent être de n’importe quel type
Les valeurs n’ont aucune contrainte : elles peuvent être des nombres, des chaînes, des listes, d’autres dictionnaires, etc.
fiche = {
"nom": "Dupont",
"notes": [15, 12, 18, 14],
"adresse": {"rue": "10 rue des Lilas", "ville": "Lyon"}
}
print(fiche["notes"][2]) # 18
print(fiche["adresse"]["ville"]) # Lyon
Création par compréhension
Comme les listes, les dictionnaires peuvent être créés par compréhension :
carres = {n: n**2 for n in range(6)}
print(carres) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# Compter les lettres d'un mot
mot = "abracadabra"
frequences = {}
for lettre in mot:
frequences[lettre] = frequences.get(lettre, 0) + 1
print(frequences) # {'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}
Résumé
| Opération | Syntaxe | Exemple |
|---|---|---|
| Création | {clé: valeur, ...} | {"nom": "Alice"} |
| Accès | d[clé] | d["nom"] → "Alice" |
| Accès sûr | d.get(clé, défaut) | d.get("age", 0) |
| Ajout / modification | d[clé] = valeur | d["age"] = 17 |
| Suppression | del d[clé] | del d["age"] |
| Longueur | len(d) | len(d) → 1 |
| Appartenance | clé in d | "nom" in d → True |
| Parcours clés | for k in d: | |
| Parcours valeurs | for v in d.values(): | |
| Parcours couples | for k, v in d.items(): |