$course$/QCM de NSI/Première/Dictionnaires Type construit dict en Python : association
clé-valeur, création, accès, parcours, méthodes
keys, values et items, test in. 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 chargé en mémoire

]]> 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 dont les indices sont des entiers consécutifs

]]> 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 qui associe des clés à des valeurs

]]> Bonne réponse : l'accès à une valeur se
fait directement par sa clé, rapidement.
On peut le voir comme un index
ou un annuaire. Un dictionnaire
est aussi appelé « tableau
associatif » dans certains
langages.

]]> Une chaîne de caractères ordonnée, indexée par position

]]> 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
teste d'abord la présence de la
clé avec if "nom" in d: avant
de lire d["nom"]. Le test
"age" in d vaut False si le
dictionnaire n'a pas de clé
"age".

]]> 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 n'existe pas
pour les dictionnaires ; elle
appartient aux ensembles, un
autre type de collection qui
n'est pas au programme de
première.

]]> 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 : Méthode keys Soit d = {"a": 1, "b": 2}. Que vaut
list(d.keys()) ?

]]> Trois vues sur un dictionnaire : keys() (les
clés), values() (les valeurs) et items() (les
couples). Parcourir directement d revient à
parcourir d.keys().

]]> 1.0 0.0 0 true true abc [1, 2]

]]> Erreur : ce sont les valeurs, que renvoie
d.values(). La méthode keys ne fournit que
les clés.

]]> ['a', 'b']

]]> Bonne réponse : d.keys() fournit les clés du
dictionnaire, dans l'ordre d'insertion, et
list(...) les range dans une liste. C'est
aussi ce que parcourt for k in d:.

]]> [('a', 1), ('b', 2)]

]]> Erreur : les couples (clé, valeur) sont
fournis par d.items(), pas par keys.

]]> ['a', 1, 'b', 2]

]]> Erreur : clés et valeurs ne sont jamais
mélangées dans une même liste. keys ne
renvoie que les clés, values que les valeurs.

]]> 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 à des informations, comme un nom à un âge

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

]]> Compresser efficacement de grandes quantités de 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 : Clé fournie par une variable Que produit ce code ?

`python
nom = "Alice"
d = {"Alice": 17}
print(d[nom])
`

]]> La clé entre crochets est une expression quelconque :
un littéral (d["Alice"]), une variable (d[nom])
ou un calcul. Distinguer d[nom] (valeur de la
variable) de d["nom"] (chaîne littérale) évite
bien des KeyError.

]]> 1.0 0.0 0 true true abc Il lève une KeyError, car nom n'est pas une clé de d

]]> Erreur : entre les crochets, Python évalue
d'abord l'expression nom, qui vaut
"Alice". C'est cette chaîne qui sert de clé,
et elle est bien présente.

]]> Il affiche 17

]]> Bonne réponse : d[nom] équivaut à
d["Alice"], puisque nom contient la chaîne
"Alice". La valeur associée, 17, est
affichée.

]]> Il affiche Alice

]]> Erreur : l'accès par clé renvoie la valeur
associée, pas la clé elle-même. Alice n'est
que le contenu de la variable nom.

]]> Il lève une KeyError, car il manque les guillemets autour de nom

]]> Erreur : avec des guillemets, d["nom"]
chercherait la clé "nom", absente, et c'est
là que KeyError surviendrait. Sans
guillemets, nom est une variable dont la
valeur "Alice" sert de clé.

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

]]> Ce motif « tester puis créer ou incrémenter »
s'applique à tout comptage avec un dictionnaire :
la clé est l'objet compté, la valeur le nombre de
rencontres. Le test in évite la KeyError
qu'entraînerait la lecture d'une clé absente.

]]> 1.0 0.0 0 true true abc `python
c = {}
for m in mots:
if m in c:
c[m] = c[m] + 1
else:
c[m] = 1
`

]]> Bonne réponse : c'est le motif classique du
comptage. Le test m in c distingue la
première rencontre d'un mot (compteur créé
à 1) des suivantes (compteur incrémenté).

]]> `python
c = {}
for m in mots:
c[m] = c[m] + 1
`

]]> Erreur : c[m] + 1 lit c[m] avant d'écrire.
À la première occurrence d'un mot, la clé
n'existe pas encore et Python lève KeyError.
Il manque le test if m in c.

]]> `python
c = {}
for m in mots:
if m in c:
c[m] = c[m] + 1
else:
c[m] = 0
`

]]> Erreur : la première occurrence est comptée
pour 0 au lieu de 1. Chaque mot finit avec
un compte inférieur d'une unité au vrai nombre
d'occurrences : sur ["a", "b", "a"], on
obtient {"a": 1, "b": 0} au lieu de
{"a": 2, "b": 1}.

]]> `python
c = {}
for m in mots:
c[m] = 1
`

]]> Erreur : chaque occurrence remet le compteur à
1 au lieu de l'incrémenter. À la fin, tous
les mots ont pour valeur 1.

]]> Dictionnaires — Q12 : Une valeur qui est une liste Que produit ce code ?

`python
d = {"fruits": ["pomme"]}
d["fruits"].append("poire")
print(d)
`

]]> Une valeur de dictionnaire peut être une liste, un
tuple ou un autre dictionnaire. Comme
d["fruits"] renvoie l'objet lui-même, les
méthodes qui modifient une liste agissent
directement sur la valeur stockée.

]]> 1.0 0.0 0 true true abc Il affiche {'fruits': ['pomme', 'poire']}

]]> Bonne réponse : d["fruits"] renvoie la liste
rangée dans le dictionnaire, pas une copie.
L'appel append allonge donc cette liste, et
le changement est visible dans d.

]]> Il affiche {'fruits': ['pomme']}

]]> Erreur : l'accès d["fruits"] ne copie pas la
liste. append agit sur l'objet même qui est
stocké dans le dictionnaire.

]]> Il affiche {'fruits': ['poire']}

]]> Erreur : append ajoute un élément à la fin de
la liste sans effacer les autres. Seule une
affectation d["fruits"] = ["poire"]
remplacerait la valeur.

]]> Il lève une AttributeError, car un dictionnaire n'a pas de méthode append

]]> Erreur : la méthode n'est pas appelée sur d
mais sur d["fruits"], qui est une liste. Une
liste possède bien la méthode append.

]]> 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 l'ensemble des 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)

]]> 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é de l'accès par clé

]]> Bonne réponse : l'accès par clé est en
O(1) en moyenne, contre O(n) pour
parcourir une liste. 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 qu'une liste ne peut pas contenir d'identifiants numériques

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

]]> Pour économiser une part importante de la mémoire

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

]]> Aucune raison, les deux structures se valent pour cet usage

]]> Erreur : il existe une différence majeure
de performance. Avec une liste, il faut
parcourir les éléments un à un jusqu'à
trouver l'identifiant.

]]> 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 : Construction depuis deux listes `python
noms = ["Lou", "Max"]
ages = [16, 17]
d = {}
for i in range(len(noms)):
d[noms[i]] = ages[i]
print(d)
`
Que produit ce code ?

]]> Le parcours par indice range(len(noms)) permet
d'apparier deux listes de même longueur, et
l'affectation d[cle] = valeur remplit le
dictionnaire entrée par entrée. C'est une façon
courante de construire un dictionnaire à partir de
données tabulaires.

]]> 1.0 0.0 0 true true abc Il affiche {'Lou': 16, 'Max': 17}

]]> Bonne réponse : à chaque tour, noms[i] fournit
la clé et ages[i] la valeur de même rang.
L'affectation d[cle] = valeur crée l'entrée
si la clé est absente.

]]> Il affiche {16: 'Lou', 17: 'Max'}

]]> Erreur : dans d[noms[i]] = ages[i],
l'expression entre crochets est la clé.
Ce sont donc les noms qui servent de clés et
les âges qui sont les valeurs.

]]> Il affiche {0: 'Lou', 1: 'Max'}

]]> Erreur : l'indice i ne sert qu'à lire les deux
listes au même rang ; il n'est jamais utilisé
comme clé. La clé est noms[i], une chaîne.

]]> Il lève une KeyError, car les clés 'Lou' et 'Max' n'existent pas encore

]]> Erreur : KeyError ne concerne que la
lecture d'une clé absente. Ici on écrit
dans d, et l'affectation crée la clé si elle
n'existe pas.

]]> 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 — 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 Parce que les modifications sont perdues à la fin du parcours

]]> Erreur : les modifications ne sont pas
perdues. Le danger est que Python lève
RuntimeError si la taille change, ou que
le parcours devienne imprévisible.

]]> Parce que le dictionnaire est copié à chaque tour de boucle

]]> Erreur : aucune copie n'est faite. Le
parcours travaille sur le dictionnaire
lui-même, ce qui est justement le
problème.

]]> Aucun danger, Python applique les modifications au tour suivant

]]> Erreur : Python détecte le changement de
taille et lève RuntimeError au lieu de
continuer.

]]> Parce que le parcours peut échouer ou devenir imprévisible

]]> Bonne réponse : ajouter ou supprimer une
clé change la taille du dictionnaire ;
Python le détecte et lève RuntimeError
(« dictionary changed size during
iteration »). 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 — 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 L'opérateur in teste la présence d'une clé, pas celle d'une valeur

]]> Cette affirmation est
correcte. Sur un
dictionnaire, k in d
cherche k parmi les
clés ; pour les valeurs,
il faut écrire
v in d.values().

]]> 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, construire un nouveau
dictionnaire inv où les clés et les valeurs sont
échangées. Quel code convient ?

]]> Cette technique ne fonctionne correctement que si
les valeurs sont uniques. Si plusieurs clés
partagent une même valeur, chaque affectation
inv[v] = k écrase celle déjà rangée sous cette
clé et une seule association survit. Pour un mappage
multivalué, il faudrait construire un dictionnaire
de listes.

]]> 1.0 0.0 0 true true abc `python
inv = {}
for k in d:
inv[v] = k
`

]]> Erreur : la boucle for k in d ne fournit que
la clé k ; la variable v n'est définie nulle
part et Python lève NameError. Il faut
obtenir la valeur par d[k] ou par items().

]]> `python
inv = {}
for v in d.values():
inv[v] = d[v]
`

]]> Erreur : la boucle parcourt les valeurs de
d, et d[v] cherche une valeur parmi les
clés, d'où une KeyError dès le premier tour.
Les valeurs ne sont pas des clés de d.

]]> `python
inv = {}
for k, v in d.items():
inv[v] = k
`

]]> Bonne réponse : items() fournit chaque couple
(clé, valeur), dépaqueté dans k et v.
L'affectation inv[v] = k range le couple
inversé dans le nouveau dictionnaire.

]]> `python
inv = {}
for k, v in d.items():
inv[k] = v
`

]]> Erreur : l'affectation inv[k] = v recopie
chaque couple dans le même sens. On obtient une
copie de d, pas son inverse ; il faut
échanger les rôles avec inv[v] = k.

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

]]> Deux façons usuelles de créer un dictionnaire :
le littéral {"a": 1, "b": 2} et la fonction
dict appliquée à une liste de couples. Pour
bâtir un dictionnaire à partir de deux listes
parallèles cles et valeurs, on part d'un
dictionnaire vide d = {} et l'on écrit
for i in range(len(cles)): d[cles[i]] = valeurs[i].
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 une
liste 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 des couples
lus ligne par ligne dans un fichier).

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

]]> Erreur : des accolades sans deux-points
formeraient un ensemble, un autre type de
collection qui n'est pas au programme. 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.

]]> Dictionnaires — Q29 : Pourquoi un dictionnaire pour appartenir On dispose de dix mille valeurs distinctes et l'on doit,
pour chacune des nombreuses entrées suivantes lues au
clavier, déterminer si la valeur saisie figure dans la
collection. En Python, il est nettement plus efficace
de placer ces dix mille valeurs dans un dictionnaire
(ou un ensemble) plutôt que dans une liste. Pourquoi ?

]]> En pratique, on range les dix mille valeurs comme clés
d'un dictionnaire (par exemple d[valeur] = True dans
une boucle), puis chaque test s'écrit saisie in d.
L'ensemble évoqué dans l'énoncé est un autre type
Python, hors programme de première, qui ne stocke que
les clés sans valeur associée ; il repose sur la même
structure interne, une table de hachage qui transforme
chaque clé en un indice de tableau, d'où le temps moyen
constant.

]]> 1.0 0.0 0 true true abc Parce que la recherche d'une clé est en moyenne à temps constant (table de hachage), alors qu'une liste parcourt tous ses éléments

]]> Bonne réponse : un dictionnaire (ou un ensemble)
repose sur une table de hachage. Tester
l'appartenance d'une valeur coûte en moyenne un
temps constant, indépendamment de la taille de la
collection. Une liste, au contraire, est parcourue
séquentiellement, ce qui donne un coût proportionnel
au nombre d'éléments dans le pire des cas.

]]> Parce qu'un dictionnaire occupe systématiquement moins de mémoire qu'une liste de même taille

]]> Erreur : c'est plutôt l'inverse. Un dictionnaire est
plus coûteux en mémoire (table interne avec des
cases vides). Le gain se situe sur la vitesse de
recherche, pas sur l'empreinte mémoire.

]]> Parce qu'un dictionnaire est automatiquement trié, ce qui rend la recherche dichotomique

]]> Erreur : un dictionnaire Python n'est pas trié sur
ses clés (il préserve l'ordre d'insertion depuis
Python 3.7, ce qui est différent). L'accès rapide
ne vient pas du tri mais du hachage.

]]> Parce qu'une liste interdit les valeurs en double et que ce contrôle ralentit chaque recherche

]]> Erreur : une liste accepte parfaitement les
doublons, ce sont les ensembles et les clés d'un
dictionnaire qui sont uniques. Et le contrôle
d'unicité n'est pas la raison de la rapidité.

]]> Dictionnaires — Q30 : Liste impossible comme clé L'instruction d = {[1, 2]: "premier"} provoque une
erreur TypeError: unhashable type: 'list'. En revanche,
d = {(1, 2): "premier"} est acceptée. Pourquoi cette
différence ?

]]> Règle générale en Python : seuls les objets immuables
peuvent servir de clés de dictionnaire. Les types
usuels acceptés sont les entiers, les flottants, les
chaînes, les booléens et les tuples dont les éléments
sont eux-mêmes hachables. Les listes et les
dictionnaires, modifiables, ne peuvent pas être des
clés.

]]> 1.0 0.0 0 true true abc Parce qu'une liste est modifiable : son hachage changerait et l'entrée deviendrait introuvable ; un tuple immuable a un hachage stable

]]> Bonne réponse : un dictionnaire est implémenté par
une table de hachage. Chaque clé est stockée à
l'emplacement déterminé par sa valeur de hachage.
Si une clé pouvait changer après insertion, l'entrée
ne serait plus retrouvée, et la table deviendrait
incohérente. C'est pourquoi Python n'autorise que
des objets immuables comme clés.

]]> Parce qu'une liste occupe trop de mémoire alors qu'un tuple n'en utilise pas

]]> Erreur : le tuple consomme également de la mémoire,
simplement un peu moins qu'une liste. La raison du
refus n'est pas la taille mais la mutabilité.

]]> Parce qu'une liste ne peut contenir que des entiers, alors qu'un tuple peut contenir tout type de valeur

]]> Erreur : une liste peut contenir n'importe quel
type de valeur en Python (entiers, chaînes,
objets, autres listes, etc.).

]]> Parce que les tuples sont, en Python, les seuls objets ordonnés et hachables par construction

]]> Erreur : beaucoup d'autres objets sont hachables
en Python (entiers, flottants, chaînes, booléens).
Le critère est l'immuabilité, pas l'appartenance
à la famille des tuples.

]]>