$course$/QCM de NSI/Première/Dictionnaires Type construit dict en Python : association
clé-valeur, création, accès, parcours, méthodes
keys, values, items et get. Comparaison
avec les listes, applications classiques (comptage,
indexation), implémentation par table de hachage.

]]> Dictionnaires — Q01 : Notion de dictionnaire Qu'est-ce qu'un dictionnaire Python ?

]]> L'implémentation interne d'un
dictionnaire repose sur une table
de hachage. L'accès à une valeur
par sa clé est en moyenne en
O(1). Depuis Python 3.7,
l'ordre d'insertion des paires
est conservé.

]]> 1.0 0.0 0 true true abc Un fichier au format CSV

]]> Un fichier CSV est un format de
stockage de données tabulaires,
alors qu'un dictionnaire est
une structure de données interne
au programme. On peut
néanmoins construire un
dictionnaire à partir d'un
fichier CSV.

]]> Une liste indexée par des entiers

]]> Cette description correspond
précisément à une liste, et
non à un dictionnaire. Une liste
est indexée par des positions
entières ; un dictionnaire est
indexé par des clés
quelconques.

]]> Une structure associant des clés à des valeurs (par exemple un nom à un âge), permettant un accès rapide par clé

]]> On peut le voir comme un index
ou un annuaire. Un dictionnaire
est aussi appelé « tableau
associatif » dans certains
langages.

]]> Une simple chaîne de caractères

]]> Une chaîne de caractères est
une séquence ordonnée de
caractères, alors qu'un
dictionnaire est une
structure associative.

]]> Dictionnaires — Q02 : Création Comment crée-t-on un dictionnaire
vide en Python ?

]]> Pour créer un dictionnaire avec
des valeurs initiales :
d = {"alice": 17, "bob": 16}.
Les paires sont séparées par des
virgules, et chaque paire est
formée d'une clé et d'une valeur
séparées par deux-points.

]]> 1.0 0.0 0 true true abc Avec la syntaxe d = ()

]]> Cette syntaxe crée un tuple
vide, et non un dictionnaire.

]]> Avec la syntaxe d = []

]]> Cette syntaxe crée une liste
vide, et non un dictionnaire.

]]> Avec la syntaxe d = {}

]]> On utilise des accolades. Une
forme alternative consiste à
écrire d = dict().

]]> Avec la syntaxe d = dict[]

]]> Cette syntaxe n'est pas valide
en Python.

]]> Dictionnaires — Q03 : Accès par clé Comment accède-t-on à la valeur
associée à la clé "nom" dans le
dictionnaire d = {"nom": "Alice"} ?

]]> Pour éviter une KeyError, on
peut utiliser
d.get("nom", default), qui
renvoie la valeur par défaut
indiquée (ou None par défaut)
si la clé n'est pas présente.

]]> 1.0 0.0 0 true true abc Avec d(nom)

]]> Les parenthèses correspondent
à un appel de fonction, pas à
un accès dans un
dictionnaire.

]]> Avec d.nom

]]> Cette syntaxe est utilisée pour
accéder aux attributs d'un
objet, et non aux clés d'un
dictionnaire.

]]> Avec d["nom"]

]]> On utilise les crochets, en
plaçant la clé entre
guillemets s'il s'agit d'une
chaîne. Si la clé n'existe
pas, Python lève une
exception KeyError.

]]> Avec d->nom

]]> Cette syntaxe est utilisée en
C ou en PHP, mais pas en
Python.

]]> Dictionnaires — Q04 : Ajouter une entrée Comment ajoute-t-on la paire
"age": 17 à un dictionnaire d
en Python ?

]]> La même syntaxe permet à la fois
la création d'une nouvelle
entrée et la mise à jour d'une
entrée existante. On ne fait
pas de distinction syntaxique
entre l'ajout et la
modification.

]]> 1.0 0.0 0 true true abc Avec d.append("age", 17)

]]> La méthode append n'existe
pas pour les dictionnaires.
Elle est définie pour les
listes.

]]> Avec d.put("age", 17)

]]> Cette syntaxe est utilisée en
Java ou en Go, mais pas en
Python.

]]> Avec d.add("age": 17)

]]> La méthode add est définie
pour les ensembles (set),
mais pas pour les
dictionnaires.

]]> Avec d["age"] = 17

]]> Si la clé n'existe pas, elle
est créée. Si elle existait
déjà, sa valeur est tout
simplement mise à jour.

]]> Dictionnaires — Q05 : Longueur d'un dictionnaire Comment connaître le nombre de
paires clé-valeur d'un
dictionnaire ?

]]> L'égalité len(d) == 0 revient
à dire que le dictionnaire est
vide. Comme pour les listes, le
test if d: est plus
idiomatique en Python : il est
vrai si et seulement si le
dictionnaire n'est pas vide.

]]> 1.0 0.0 0 true true abc Avec d.length

]]> L'attribut length n'existe
pas pour les dictionnaires
en Python.

]]> Avec len(d)

]]> La fonction native len
fonctionne sur les
dictionnaires comme sur
d'autres conteneurs (listes,
chaînes, ensembles, tuples).

]]> Avec d.size()

]]> La méthode size n'existe
pas pour les dictionnaires
en Python.

]]> Avec count(d)

]]> La fonction count n'est pas
définie sur les
dictionnaires.

]]> Dictionnaires — Q06 : Parcourir un dictionnaire Que parcourt par défaut la boucle
for x in d:, où d est un
dictionnaire ?

]]> Un idiome très courant :

`python
for cle, valeur in d.items():
print(cle, valeur)
`

Cette construction est très
pratique pour parcourir un
dictionnaire tout en conservant
l'association entre clé et
valeur.

]]> 1.0 0.0 0 true true abc Les paires clé-valeur

]]> Pour parcourir les paires
clé-valeur, il faut
explicitement écrire
for k, v in d.items():.

]]> Les clés du dictionnaire

]]> Cette boucle est équivalente à
for x in d.keys():. Pour
parcourir les valeurs, on
écrit for v in d.values():.
Pour parcourir les paires
clé-valeur, on utilise
for k, v in d.items():.

]]> Les valeurs du dictionnaire

]]> Par défaut, la boucle parcourt
les clés du dictionnaire,
et non ses valeurs. Pour
accéder aux valeurs, on
utilise d.values().

]]> Les indices du dictionnaire

]]> Un dictionnaire n'a pas
d'indices entiers comme une
liste. Il a uniquement des
clés, qui peuvent être de
types variés.

]]> Dictionnaires — Q07 : Tester la présence d'une clé Comment teste-t-on si la clé
"nom" existe dans le
dictionnaire d ?

]]> Pour tester la présence parmi
les valeurs, on écrit
valeur in d.values(). Cette
opération est en moyenne en
O(n), donc plus coûteuse que
la recherche d'une clé.

]]> 1.0 0.0 0 true true abc Avec d["nom"]

]]> Cette syntaxe accède
directement à la valeur
associée à la clé. Elle
provoque une exception
KeyError si la clé est
absente.

]]> Avec d.has("nom")

]]> La méthode has n'existe pas
en Python 3. Une méthode
has_key existait en Python
2, mais elle a été supprimée.

]]> Avec d.contains("nom")

]]> La méthode contains n'existe
pas pour les dictionnaires en
Python.

]]> Avec "nom" in d

]]> L'opérateur in testé sur un
dictionnaire vérifie la
présence parmi les clés.
Cette opération est en
O(1) en moyenne.

]]> Dictionnaires — Q08 : Supprimer une entrée Comment supprime-t-on la clé
"age" d'un dictionnaire d ?

]]> Distinction importante : mettre
la valeur à None revient à
dire « la clé existe, mais
avec une valeur nulle » ;
l'opération del supprime
réellement la clé du
dictionnaire.

]]> 1.0 0.0 0 true true abc Avec d.delete("age")

]]> La méthode delete n'existe
pas pour les dictionnaires
en Python.

]]> Avec d["age"] = None

]]> Cette opération met la
valeur à None, mais la
clé reste présente dans le
dictionnaire.

]]> Avec d.remove("age")

]]> La méthode remove est
définie pour les listes,
mais pas pour les
dictionnaires.

]]> Avec del d["age"]

]]> On utilise le mot-clé del.
Si la clé n'existe pas,
Python lève une exception
KeyError. Pour éviter
l'erreur, on peut utiliser
d.pop("age", None), qui
renvoie en plus la valeur
retirée.

]]> Dictionnaires — Q09 : Cas d'usage typique Lequel des cas suivants est un
usage typique d'un
dictionnaire ?

]]> Quelques cas d'usage classiques :
indexation (mot vers
définition), comptage (mot vers
nombre d'occurrences),
mémoïsation (entrée vers
résultat), configuration
(option vers valeur).

]]> 1.0 0.0 0 true true abc Associer un identifiant (la clé) à un ensemble d'informations (la valeur), comme un nom à un âge ou un code postal à une ville

]]> C'est précisément le rôle
d'un dictionnaire. Il offre
une recherche rapide à
partir de la clé.

]]> Compresser des données

]]> La compression de données
est une fonctionnalité
spécifique, sans lien
direct avec la structure de
dictionnaire.

]]> Stocker une séquence ordonnée de notes d'élèves

]]> Pour ce cas, une liste est
plus adaptée. Le
dictionnaire excelle
plutôt pour l'association
entre une clé et une
valeur.

]]> Trier une liste de valeurs

]]> Le tri d'une liste est une
opération qui n'a rien à voir
avec les dictionnaires.

]]> Dictionnaires — Q10 : Trace simple Que produit ce code ?

`python
d = {"a": 1, "b": 2}
d["c"] = 3
print(len(d))
`

]]> Vérifier la longueur d'un
dictionnaire est utile pour
s'assurer qu'on n'a pas écrasé
par mégarde une entrée
existante en utilisant la
même clé.

]]> 1.0 0.0 0 true true abc Il déclenche une erreur

]]> Le code est parfaitement
valide. Aucune erreur n'est
levée.

]]> Il affiche "a", "b", "c"

]]> La fonction len renvoie
un entier, pas la liste des
clés. Pour obtenir les
clés, on utiliserait
list(d.keys()).

]]> Il affiche 3

]]> Le dictionnaire contenait
deux paires au départ. On
en ajoute une troisième
("c": 3), donc len(d)
renvoie 3.

]]> Il affiche 2

]]> Cette réponse ignore l'ajout
de la nouvelle clé "c".

]]> Dictionnaires — Q11 : Compter les occurrences Quel code compte le nombre
d'occurrences de chaque mot dans
une liste mots ?

]]> Ce motif est si fréquent que
Python propose la classe
collections.Counter, qui
automatise le comptage. Par
exemple,
Counter(["a", "b", "a"])
renvoie Counter({"a": 2,
"b": 1}).

]]> 1.0 0.0 0 true true abc `python
c = {}
for m in mots:
c[m] = c.get(m, 0) + 1
`

]]> C'est un motif classique.
L'appel c.get(m, 0)
renvoie 0 si la clé m
n'est pas encore présente.
Une alternative plus
concise consiste à utiliser
Counter(mots) du module
collections.

]]> `python
c = sum(mots)
`

]]> La fonction sum ne
fonctionne pas avec une
liste de chaînes de
caractères. Elle attend
des nombres.

]]> `python
c = dict(mots)
`

]]> Cette construction ne
fonctionne que si mots
contient des paires
clé-valeur, et non des
chaînes simples.

]]> `python
c = mots.count()
`

]]> La méthode count sur une
liste compte les occurrences
d'un seul élément précis,
et non de tous les éléments
en une fois.

]]> Dictionnaires — Q12 : Méthode get avec valeur par défaut Que fait d.get("x", 0) ?

]]> Sans valeur par défaut,
d.get("x") renvoie None si
la clé est absente. Avec une
valeur par défaut, elle renvoie
cette valeur. Très pratique
dans les motifs
d'accumulation.

]]> 1.0 0.0 0 true true abc Elle renvoie la valeur associée à "x" si la clé existe, et 0 sinon (sans lever d'erreur)

]]> Cette méthode est très
utile pour éviter une
exception KeyError. Le
second paramètre est la
valeur par défaut, à
renvoyer en l'absence de
la clé.

]]> Elle renvoie toujours la valeur 0

]]> La méthode renvoie 0
uniquement quand la clé
"x" n'est pas présente.
Sinon, elle renvoie la
valeur associée à la clé.

]]> Elle supprime la clé "x" du dictionnaire

]]> La méthode get se contente
de lire ; elle ne modifie
pas le dictionnaire.

]]> Elle déclenche une erreur si la clé n'existe pas

]]> C'est précisément l'intérêt
de get que de ne pas
déclencher d'erreur en
l'absence de la clé.

]]> Dictionnaires — Q13 : Méthode items Que renvoie l'appel d.items() ?

]]> Trois vues complémentaires sont
disponibles : keys() pour les
clés, values() pour les
valeurs, et items() pour les
paires. Elles sont
dynamiques : elles reflètent
les modifications du
dictionnaire au fur et à
mesure.

]]> 1.0 0.0 0 true true abc Une liste contenant uniquement les clés

]]> Cette description correspond
plutôt à d.keys(). La
méthode items renvoie
autre chose.

]]> Un ensemble contenant les valeurs

]]> Pour obtenir les valeurs,
on utilise plutôt
d.values(). La méthode
items renvoie les paires
complètes.

]]> La taille du dictionnaire

]]> La taille du dictionnaire
s'obtient avec la fonction
len(d).

]]> Une vue itérable sur les paires (clé, valeur) du dictionnaire

]]> Cette vue permet d'itérer
sur les deux à la fois,
avec la syntaxe
for k, v in d.items():.

]]> Dictionnaires — Q14 : Clés autorisées dans un dictionnaire Lequel des types suivants ne peut
pas être utilisé comme clé de
dictionnaire ?

]]> La règle est la suivante : la
clé doit être immuable.
Un tuple composé d'éléments
immuables est donc autorisé,
mais un tuple contenant une
liste ne l'est pas.

]]> 1.0 0.0 0 true true abc Le type str (chaîne)

]]> Les chaînes sont sans
doute le type de clé le
plus utilisé dans la
pratique.

]]> Le type tuple, à condition que tous ses éléments soient eux-mêmes utilisables comme clés

]]> Un tuple est autorisé
comme clé tant que tous
ses éléments sont eux-mêmes
immuables.

]]> Le type list (liste)

]]> Les listes sont mutables,
ce qui les empêche d'être
utilisées comme clés.
Tenter d'écrire
d[[1, 2]] = 5 provoque
une TypeError.

]]> Le type int (entier)

]]> Les entiers sont
parfaitement utilisables
comme clés de
dictionnaire.

]]> Dictionnaires — Q15 : Dictionnaire et liste Pour rechercher une valeur à
partir d'un identifiant (par
exemple « l'élève dont
l'identifiant est 42 »),
pourquoi préfère-t-on un
dictionnaire à une liste ?

]]> Compromis : le dictionnaire
consomme plus de mémoire
(table de hachage interne),
mais offre une recherche
très rapide. La liste, plus
compacte, est lente pour la
recherche par clé.

]]> 1.0 0.0 0 true true abc Pour la rapidité d'accès : un accès en O(1) avec un dictionnaire, contre O(n) avec une liste utilisée pour une recherche linéaire

]]> Sur de gros volumes de
données, la différence est
considérable. Pour un
million d'éléments, on
parle d'environ 1 µs
avec un dictionnaire,
contre plusieurs
millisecondes avec une
liste.

]]> Parce que les listes ne supportent pas les nombres

]]> Cette affirmation est
fausse. Les listes
peuvent contenir tout
type de valeurs,
notamment des nombres.

]]> Pour économiser de la mémoire

]]> Au contraire, un
dictionnaire occupe en
général plus de mémoire
qu'une liste équivalente.

]]> Aucune différence notable

]]> Il existe au contraire
une différence majeure
de performance, comme
expliqué dans la bonne
réponse.

]]> Dictionnaires — Q16 : Représenter une table de traduction Comment représenter une table
de traduction simple du
français vers l'anglais en
Python ?

]]> Pour une petite table de
traduction, un dictionnaire
simple convient. Pour des
bases volumineuses, on a
plutôt recours à une base
de données ou à des
fichiers indexés.

]]> 1.0 0.0 0 true true abc `python
{"chat": "cat", "chien": "dog"}
`

]]> On utilise un dictionnaire,
ce qui permet un accès
immédiat :
traduction["chat"]
renvoie "cat".

]]> `python
("chat", "cat")
`

]]> Ce tuple ne contient
qu'un seul couple. Il ne
permet pas de stocker
l'ensemble des
traductions.

]]> `python
["chat", "cat", "chien", "dog"]
`

]]> Cette structure est une
liste plate qui ne
permet pas une recherche
rapide par mot
français. Il faudrait
parcourir la liste pour
retrouver la
traduction.

]]> `python
chat = "cat"; chien = "dog"
`

]]> Définir une variable par
mot est très peu
pratique : la solution
ne passe pas à
l'échelle dès que le
nombre de mots
augmente.

]]> Dictionnaires — Q17 : Modification d'une valeur `python
d = {"a": 1, "b": 2}
d["a"] = d["a"] + 10
print(d)
`
Que produit ce code ?

]]> Une forme abrégée
idiomatique consiste à
écrire d["a"] += 10,
plus concise et plus
lisible.

]]> 1.0 0.0 0 true true abc Il affiche {"a": 11, "b": 2}

]]> La valeur initiale de
d["a"] est 1, à
laquelle on ajoute 10.
La nouvelle valeur est
donc 11.

]]> Il déclenche une erreur

]]> Le code est parfaitement
valide.

]]> Il affiche {"a": 1, "b": 2}

]]> Cette réponse ignore la
modification de d["a"],
qui passe de 1 à 11.

]]> Il affiche {"a": 10, "b": 2}

]]> On ajoute 10 à la
valeur précédente, on ne
remplace pas la valeur
par 10.

]]> Dictionnaires — Q18 : Le type defaultdict Que fournit l'instruction
from collections import
defaultdict ?

]]> Le module collections
regroupe plusieurs outils
très utiles : defaultdict,
Counter, OrderedDict,
namedtuple, et d'autres
encore.

]]> 1.0 0.0 0 true true abc Elle importe une simple variable

]]> Cette interprétation est
imprécise. Il s'agit en
réalité d'un type
spécialisé, comme
expliqué dans la bonne
réponse.

]]> Elle crée un dictionnaire vide

]]> Le dictionnaire vide se
crée avec {} ou
dict(). La classe
defaultdict apporte
une fonctionnalité
supplémentaire : la
création automatique de
valeurs par défaut.

]]> Elle importe un fichier annexe

]]> Cette instruction concerne
un type Python, et non
un fichier sur le
disque.

]]> Elle importe un type de dictionnaire qui crée automatiquement une valeur par défaut lorsqu'on accède à une clé inexistante (utile pour les comptages ou les regroupements)

]]> Par exemple, en écrivant
c = defaultdict(int),
on peut directement
incrémenter
c[mot] += 1 sans
tester d'abord la
présence de la clé.
C'est très pratique.

]]> Dictionnaires — Q19 : Ordre des entrées Depuis Python 3.7, dans quel
ordre les entrées d'un
dictionnaire sont-elles
parcourues ?

]]> Pour un parcours trié par
clé, on écrit
for k in sorted(d):. Pour
un parcours trié par
valeur, on écrit
for k in sorted(d, key=d.get):.

]]> 1.0 0.0 0 true true abc Dans un ordre aléatoire à chaque exécution

]]> L'ordre est en réalité
déterministe depuis
Python 3.7 : les
entrées sont parcourues
dans l'ordre où elles
ont été insérées.

]]> Dans l'ordre d'insertion des paires

]]> C'est un changement
subtil mais important.
Avant Python 3.7,
l'ordre n'était pas
garanti, ce qui pouvait
surprendre.

]]> Dans l'ordre alphabétique des clés

]]> Aucun tri automatique sur
les clés n'est effectué.

]]> Par taille croissante des valeurs

]]> Aucun tri automatique
n'est effectué sur les
valeurs.

]]> Dictionnaires — Q20 : Cas du dictionnaire vide Que vaut bool({}) ?

]]> Convention dite « truthy /
falsy » : sont faux
False, 0, 0.0, "",
[], {}, (), et
None. Tous les autres
objets sont considérés
comme vrais dans un
contexte booléen.

]]> 1.0 0.0 0 true true abc Une exception

]]> Le code est parfaitement
valide.

]]> False

]]> C'est la convention
Python : les structures
vides sont fausses.
C'est utile pour
tester rapidement avec
if d:, qui se lit
« si le dictionnaire
n'est pas vide ».

]]> La valeur 0

]]> La fonction bool
renvoie un booléen, pas
un entier.

]]> True

]]> Un dictionnaire vide est
considéré comme faux en
Python, au même titre que
[], "", 0 et
None.

]]> Dictionnaires — Q21 : Hachage et collisions Pourquoi l'accès à un
dictionnaire est-il en
moyenne en O(1), mais
au pire en O(n) ?

]]> Cette garantie est
probabiliste, et non
déterministe. Pour des
situations adversariales
(sécurité), Python
randomise le hachage des
chaînes via la variable
d'environnement
PYTHONHASHSEED.

]]> 1.0 0.0 0 true true abc Aucune raison particulière

]]> Cette différence
s'explique au contraire
par le fonctionnement
interne de la table de
hachage, comme expliqué
dans la bonne réponse.

]]> Parce que les clés sont triées en interne

]]> Les clés ne sont pas
triées dans une table
de hachage. C'est
précisément ce qui
permet l'accès en O(1)
en moyenne.

]]> Parce que la table de hachage peut subir des collisions (deux clés qui se retrouvent au même emplacement). Au pire (toutes les clés au même emplacement), on retombe sur une recherche linéaire

]]> Ce phénomène reste
néanmoins rare en
pratique. Python utilise
des stratégies internes
(adressage ouvert,
redimensionnement) qui
maintiennent les
collisions à un niveau
acceptable.

]]> Parce que les dictionnaires sont mal conçus en Python

]]> Cette affirmation est
incorrecte. Les
dictionnaires Python
sont au contraire
réputés pour leur
excellente performance.

]]> Dictionnaires — Q22 : La méthode setdefault Que fait d.setdefault("k",
0) ?

]]> Cette méthode est utile
mais elle est souvent
remplacée par
defaultdict, plus
expressif. Elle reste
pratique surtout quand la
valeur par défaut est
coûteuse à calculer.

]]> 1.0 0.0 0 true true abc Elle écrase systématiquement la valeur de la clé "k" avec 0

]]> La méthode n'écrase pas
la valeur existante.
Elle ne définit la
valeur par défaut que si
la clé n'est pas déjà
présente.

]]> La méthode setdefault n'existe pas en Python

]]> Cette méthode existe
bel et bien, et fait
partie de l'interface
standard des
dictionnaires.

]]> Elle déclenche systématiquement une erreur

]]> La méthode setdefault
ne lève pas d'erreur ;
c'est précisément son
intérêt par rapport à
un accès direct.

]]> Si la clé "k" existe, elle renvoie sa valeur. Sinon, elle l'ajoute avec la valeur 0 et renvoie 0

]]> Cette méthode combine
deux opérations en une
seule : elle est utile
pour initialiser une
clé à la première
rencontre.

]]> Dictionnaires — Q23 : Modifier un dictionnaire pendant son parcours Pourquoi est-il dangereux de
modifier un dictionnaire
pendant qu'on l'itère ?

]]> Règle générale : ne
jamais modifier une
collection (dictionnaire,
ensemble, liste, etc.)
pendant son parcours. Il
vaut mieux travailler sur
une copie ou collecter les
modifications dans une
structure auxiliaire.

]]> 1.0 0.0 0 true true abc Le code s'exécute plus rapidement

]]> Aucune amélioration de
performance n'est
obtenue par cette
modification ; c'est
au contraire une source
potentielle de bugs.

]]> Cette modification est interdite par la loi

]]> Cette interprétation
littérale n'a aucun sens
en programmation.

]]> Aucune conséquence particulière

]]> Cette modification a au
contraire des
conséquences sérieuses,
comme expliqué dans la
bonne réponse.

]]> Cela peut lever une exception RuntimeError indiquant que la taille du dictionnaire a changé pendant l'itération, ou produire des comportements imprévisibles

]]> Python détecte la
modification et lève une
erreur. Pour modifier
en sécurité, il faut
itérer sur une copie
de la liste des clés,
par exemple
for k in list(d):.

]]> Dictionnaires — Q24 : Compréhension de dictionnaire Quel code crée le dictionnaire
{1: 1, 2: 4, 3: 9, ...,
10: 100} (le carré de
chaque entier) ?

]]> Quatre formes de
compréhension existent en
Python : [...] pour les
listes, {x for ...} pour
les ensembles,
{k: v for ...} pour les
dictionnaires, et
(... for ...) pour les
générateurs.

]]> 1.0 0.0 0 true true abc {i: i 2 for i in range(1, 11)}

]]> C'est une compréhension
de dictionnaire. Sa
syntaxe est
{cle: valeur for ... in
...}. Cette construction
est concise et
idiomatique en Python.

]]> {i 2 for i in range(1, 11)}

]]> Cette syntaxe crée un
ensemble, et non un
dictionnaire, car il
n'y a pas de paires
clé-valeur.

]]> [i: i 2 for i in range(1, 11)]

]]> Cette syntaxe est
invalide en Python. Les
crochets ne permettent
pas de définir une
compréhension avec des
paires clé-valeur.

]]> dict(i, i 2 for i in range(1, 11))

]]> Cette syntaxe est
invalide. La fonction
dict ne s'utilise pas
de cette manière.

]]> Dictionnaires — Q25 : Synthèse Parmi les affirmations
suivantes sur les
dictionnaires, laquelle est
fausse ?

]]> Mémo utile : la clé d'un
dictionnaire doit être
stable dans le temps. Tout
ce qui est mutable n'est
donc pas autorisé comme
clé.

]]> 1.0 0.0 0 true true abc La méthode d.get(k, default) renvoie default si la clé est absente, sans lever d'erreur

]]> Cette affirmation est
correcte. C'est
précisément l'intérêt
de cette méthode par
rapport à un accès
direct.

]]> L'accès par clé est en O(1) en moyenne

]]> Cette affirmation est
correcte. C'est la
conséquence directe de
l'implémentation par
table de hachage.

]]> Une liste peut être utilisée comme clé d'un dictionnaire

]]> Cette affirmation est
fausse (donc c'est la
bonne réponse). Les
listes étant mutables,
elles ne peuvent pas
servir de clés. Seuls
les objets immuables
(entier, chaîne,
flottant, tuple,
ensemble figé) peuvent
être utilisés comme
clés.

]]> Depuis Python 3.7, l'ordre d'insertion des paires est conservé lors du parcours

]]> Cette affirmation est
correcte. C'est une
garantie introduite à
partir de Python 3.7.

]]> Dictionnaires — Q26 : Méthode values On dispose du dictionnaire suivant :

`python
stock = {"stylo": 5, "cahier": 12, "gomme": 3}

Que renvoie l'expression sum(stock.values())` ?

]]> Trois vues complémentaires sur un dictionnaire :
d.keys() (les clés), d.values() (les valeurs)
et d.items() (les couples). Combinées avec les
fonctions natives sum, max, min ou len,
elles permettent d'écrire des traitements concis.

]]> 1.0 0.0 0 true true abc La somme des longueurs des clés (16)

]]> Erreur : values agit sur les valeurs, pas sur
les clés. La longueur des chaînes utilisées
comme clés n'intervient pas ici.

]]> Une erreur de type

]]> Erreur : la fonction sum accepte parfaitement
un itérable de nombres. La méthode values
renvoie justement un itérable, donc
l'opération est valide.

]]> 20

]]> Bonne réponse : stock.values() renvoie une vue
sur les valeurs [5, 12, 3], et sum calcule
leur total : 5 + 12 + 3 = 20.

]]> 3

]]> Erreur : ce serait le nombre de clés, soit
la longueur du dictionnaire (len(stock)).
La somme demandée porte sur les valeurs, pas
sur le nombre d'entrées.

]]> Dictionnaires — Q27 : Inverser un dictionnaire On souhaite, à partir d'un dictionnaire d aux
valeurs distinctes, obtenir un nouveau dictionnaire
où les clés et les valeurs sont échangées. Quelle
compréhension convient ?

]]> Cette technique ne fonctionne correctement que si
les valeurs sont uniques. Si plusieurs clés
partagent une même valeur, la conversion
« écrasera » les doublons et ne conservera qu'une
des associations possibles. Pour un mappage
multivalué, il faudrait construire un dictionnaire
de listes.

]]> 1.0 0.0 0 true true abc {v: k for k in d}

]]> Erreur : sans appeler d.items(), la variable
v n'est pas définie. Cette syntaxe ne
fonctionne qu'avec for k in d, où k est
une clé, pas un couple.

]]> {d[k]: k for k in d.values()}

]]> Erreur : la boucle parcourt les valeurs de
d, pas ses clés. L'expression d[k] est donc
incorrecte (les valeurs ne sont pas des clés
du dictionnaire).

]]> {v: k for k, v in d.items()}

]]> Bonne réponse : la méthode items() renvoie une
séquence de couples (clé, valeur). Le
déballage for k, v in d.items() permet ensuite
d'écrire le couple inversé v: k dans le
nouveau dictionnaire.

]]> {k: v for v, k in d.items()}

]]> Erreur : on a inversé l'ordre des variables
dans le déballage, mais on a oublié de
réécrire la paire v: k à gauche. Le résultat
ne sera pas inversé : on retrouve le
dictionnaire d'origine.

]]> Dictionnaires — Q28 : Construction depuis une liste de couples Que renvoie l'expression
dict([("rouge", 1), ("vert", 2), ("bleu", 3)]) ?

]]> Trois façons usuelles de créer un dictionnaire :
littéral {"a": 1, "b": 2}, fonction
dict(a=1, b=2) (clés en chaînes implicites) et
dict(zip(cles, valeurs)) (depuis deux listes
parallèles). La forme « liste de couples » est très
utile lors de la lecture de fichiers structurés.

]]> 1.0 0.0 0 true true abc {'rouge': 1, 'vert': 2, 'bleu': 3}

]]> Bonne réponse : la fonction dict accepte un
itérable de couples (clé, valeur) et construit
le dictionnaire correspondant. C'est une façon
courante de bâtir un dictionnaire à partir de
données structurées (par exemple le résultat
d'un zip sur deux listes).

]]> {'rouge', 'vert', 'bleu'}

]]> Erreur : ce serait un ensemble (set).
dict produit un dictionnaire avec des clés
et des valeurs ; il ne se limite pas aux
clés.

]]> Une erreur de syntaxe

]]> Erreur : la fonction dict est native en Python
et accepte plusieurs formes d'appel. La
construction depuis une liste de couples est
parfaitement valide.

]]> [('rouge', 1), ('vert', 2), ('bleu', 3)]

]]> Erreur : ce serait la liste d'origine inchangée.
La fonction native dict transforme cette liste
en un véritable dictionnaire.

]]>