\documentclass[10pt,aspectratio=169]{beamer}

% --- Thème ---
\usetheme[language=french]{Celestia}

% Avec [allowframebreaks] sur les frames de questions, Beamer ajoute
% par défaut « (1) », « (2) », « (3) »... sur chaque sous-slide. On
% supprime entièrement cette annotation : un template vide pour
% « frametitle continuation ». L'enseignant identifie visuellement la
% continuation par le contenu de la slide. (Les variantes [from second]
% et [roman] interagissent mal avec un titre contenant \textemdash{}
% sous Celestia : elles déclenchent une erreur « Missing $ inserted ».)
\setbeamertemplate{frametitle continuation}{}

\subject{Numérique et sciences informatiques}
\title{Dictionnaires}
\subtitle{QCM}
\author{Première}
\date{\today}

\begin{document}

\begin{frame}
    \titlepage
\end{frame}

% Q1 - Réponse en C
\begin{frame}[fragile]{Question 1 \textemdash{} Notion de dictionnaire}
    Qu'est-ce qu'un \textbf{dictionnaire} Python ?\medskip
    \begin{itemize}
        \item[A.] Un fichier au format CSV
        \item[B.] Une liste indexée par des entiers
        \item[\alert<2>{C.}] \alert<2>{Une structure associant des clés à des valeurs (par exemple un nom à un âge), permettant un accès rapide par clé}
        \item[D.] Une simple chaîne de caractères
    \end{itemize}
\end{frame}

% Q2 - Réponse en C
\begin{frame}[fragile]{Question 2 \textemdash{} Création}
    Comment crée-t-on un dictionnaire
vide en Python ?\medskip
    \begin{itemize}
        \item[A.] Avec la syntaxe \texttt{d = ()}
        \item[B.] Avec la syntaxe \texttt{d = []}
        \item[\alert<2>{C.}] \alert<2>{Avec la syntaxe \texttt{d = \{\}}}
        \item[D.] Avec la syntaxe \texttt{d = dict[]}
    \end{itemize}
\end{frame}

% Q3 - Réponse en C
\begin{frame}[fragile]{Question 3 \textemdash{} Accès par clé}
    Comment accède-t-on à la \textbf{valeur}
associée à la clé \texttt{"nom"} dans le
dictionnaire \texttt{d = \{"nom": "Alice"\}} ?\medskip
    \begin{itemize}
        \item[A.] Avec \texttt{d(nom)}
        \item[B.] Avec \texttt{d.nom}
        \item[\alert<2>{C.}] \alert<2>{Avec \texttt{d["nom"]}}
        \item[D.] Avec \texttt{d->nom}
    \end{itemize}
\end{frame}

% Q4 - Réponse en D
\begin{frame}[fragile]{Question 4 \textemdash{} Ajouter une entrée}
    Comment ajoute-t-on la paire
\texttt{"age": 17} à un dictionnaire \texttt{d}
en Python ?\medskip
    \begin{itemize}
        \item[A.] Avec \texttt{d.append("age", 17)}
        \item[B.] Avec \texttt{d.put("age", 17)}
        \item[C.] Avec \texttt{d.add("age": 17)}
        \item[\alert<2>{D.}] \alert<2>{Avec \texttt{d["age"] = 17}}
    \end{itemize}
\end{frame}

% Q5 - Réponse en B
\begin{frame}[fragile]{Question 5 \textemdash{} Longueur d'un dictionnaire}
    Comment connaître le \textbf{nombre de
paires} clé-valeur d'un
dictionnaire ?\medskip
    \begin{itemize}
        \item[A.] Avec \texttt{d.length}
        \item[\alert<2>{B.}] \alert<2>{Avec \texttt{len(d)}}
        \item[C.] Avec \texttt{d.size()}
        \item[D.] Avec \texttt{count(d)}
    \end{itemize}
\end{frame}

% Q6 - Réponse en B
\begin{frame}[fragile]{Question 6 \textemdash{} Parcourir un dictionnaire}
    Que parcourt par défaut la boucle
\texttt{for x in d:}, où \texttt{d} est un
dictionnaire ?\medskip
    \begin{itemize}
        \item[A.] Les paires clé-valeur
        \item[\alert<2>{B.}] \alert<2>{Les clés du dictionnaire}
        \item[C.] Les valeurs du dictionnaire
        \item[D.] Les indices du dictionnaire
    \end{itemize}
\end{frame}

% Q7 - Réponse en D
\begin{frame}[fragile]{Question 7 \textemdash{} Tester la présence d'une clé}
    Comment teste-t-on si la clé
\texttt{"nom"} existe dans le
dictionnaire \texttt{d} ?\medskip
    \begin{itemize}
        \item[A.] Avec \texttt{d["nom"]}
        \item[B.] Avec \texttt{d.has("nom")}
        \item[C.] Avec \texttt{d.contains("nom")}
        \item[\alert<2>{D.}] \alert<2>{Avec \texttt{"nom" in d}}
    \end{itemize}
\end{frame}

% Q8 - Réponse en D
\begin{frame}[fragile]{Question 8 \textemdash{} Supprimer une entrée}
    Comment \textbf{supprime-t-on} la clé
\texttt{"age"} d'un dictionnaire \texttt{d} ?\medskip
    \begin{itemize}
        \item[A.] Avec \texttt{d.delete("age")}
        \item[B.] Avec \texttt{d["age"] = None}
        \item[C.] Avec \texttt{d.remove("age")}
        \item[\alert<2>{D.}] \alert<2>{Avec \texttt{del d["age"]}}
    \end{itemize}
\end{frame}

% Q9 - Réponse en A
\begin{frame}[fragile]{Question 9 \textemdash{} Cas d'usage typique}
    Lequel des cas suivants est un
usage \textbf{typique} d'un
dictionnaire ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Associer un identifiant (la clé) à un ensemble d'informations (la valeur), comme un nom à un âge ou un code postal à une ville}
        \item[B.] Compresser des données
        \item[C.] Stocker une séquence ordonnée de notes d'élèves
        \item[D.] Trier une liste de valeurs
    \end{itemize}
\end{frame}

% Q10 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Trace simple}
    Que produit ce code ?

\begin{lstlisting}
d = {"a": 1, "b": 2}
d["c"] = 3
print(len(d))
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Il déclenche une erreur
        \item[B.] Il affiche \texttt{"a", "b", "c"}
        \item[C.] Il affiche \texttt{3}
        \item[D.] Il affiche \texttt{2}
    \end{itemize}
\end{frame}

% Q10 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Trace simple}
    Que produit ce code ?

\begin{lstlisting}
d = {"a": 1, "b": 2}
d["c"] = 3
print(len(d))
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Il déclenche une erreur
        \item[B.] Il affiche \texttt{"a", "b", "c"}
        \item[\alert{C.}] \alert{Il affiche \texttt{3}}
        \item[D.] Il affiche \texttt{2}
    \end{itemize}
\end{frame}

% Q11 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 11 \textemdash{} Compter les occurrences}
    Quel code \textbf{compte} le nombre
d'occurrences de chaque mot dans
une liste \texttt{mots} ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
c = {}
for m in mots:
    c[m] = c.get(m, 0) + 1
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
c = sum(mots)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
c = dict(mots)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
c = mots.count()
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q11 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 11 \textemdash{} Compter les occurrences}
    Quel code \textbf{compte} le nombre
d'occurrences de chaque mot dans
une liste \texttt{mots} ?\medskip
    \begin{itemize}
        \item[\alert{A.}]~\\
\begin{lstlisting}
c = {}
for m in mots:
    c[m] = c.get(m, 0) + 1
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
c = sum(mots)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
c = dict(mots)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
c = mots.count()
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q12 - Réponse en A
\begin{frame}[fragile]{Question 12 \textemdash{} Méthode get avec valeur par défaut}
    Que fait \texttt{d.get("x", 0)} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Elle renvoie la valeur associée à \texttt{"x"} si la clé existe, et $0$ sinon (sans lever d'erreur)}
        \item[B.] Elle renvoie toujours la valeur $0$
        \item[C.] Elle supprime la clé \texttt{"x"} du dictionnaire
        \item[D.] Elle déclenche une erreur si la clé n'existe pas
    \end{itemize}
\end{frame}

% Q13 - Réponse en D
\begin{frame}[fragile]{Question 13 \textemdash{} Méthode items}
    Que renvoie l'appel \texttt{d.items()} ?\medskip
    \begin{itemize}
        \item[A.] Une liste contenant uniquement les clés
        \item[B.] Un ensemble contenant les valeurs
        \item[C.] La taille du dictionnaire
        \item[\alert<2>{D.}] \alert<2>{Une vue itérable sur les paires \texttt{(clé, valeur)} du dictionnaire}
    \end{itemize}
\end{frame}

% Q14 - Réponse en C
\begin{frame}[fragile]{Question 14 \textemdash{} Clés autorisées dans un dictionnaire}
    Lequel des types suivants ne peut
\textbf{pas} être utilisé comme clé de
dictionnaire ?\medskip
    \begin{itemize}
        \item[A.] Le type \texttt{str} (chaîne)
        \item[B.] Le type \texttt{tuple}, à condition que tous ses éléments soient eux-mêmes utilisables comme clés
        \item[\alert<2>{C.}] \alert<2>{Le type \texttt{list} (liste)}
        \item[D.] Le type \texttt{int} (entier)
    \end{itemize}
\end{frame}

% Q15 - Réponse en A
\begin{frame}[fragile]{Question 15 \textemdash{} 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 ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{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}
        \item[B.] Parce que les listes ne supportent pas les nombres
        \item[C.] Pour économiser de la mémoire
        \item[D.] Aucune différence notable
    \end{itemize}
\end{frame}

% Q16 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 16 \textemdash{} Représenter une table de traduction}
    Comment représenter une \textbf{table
de traduction} simple du
français vers l'anglais en
Python ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
{"chat": "cat", "chien": "dog"}
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
("chat", "cat")
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
["chat", "cat", "chien", "dog"]
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
chat = "cat"; chien = "dog"
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q16 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 16 \textemdash{} Représenter une table de traduction}
    Comment représenter une \textbf{table
de traduction} simple du
français vers l'anglais en
Python ?\medskip
    \begin{itemize}
        \item[\alert{A.}]~\\
\begin{lstlisting}
{"chat": "cat", "chien": "dog"}
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
("chat", "cat")
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
["chat", "cat", "chien", "dog"]
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
chat = "cat"; chien = "dog"
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q17 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 17 \textemdash{} Modification d'une valeur}
    \begin{lstlisting}
d = {"a": 1, "b": 2}
d["a"] = d["a"] + 10
print(d)
\end{lstlisting}
Que produit ce code ?\medskip
    \begin{itemize}
        \item[A.] Il affiche \texttt{\{"a": 11, "b": 2\}}
        \item[B.] Il déclenche une erreur
        \item[C.] Il affiche \texttt{\{"a": 1, "b": 2\}}
        \item[D.] Il affiche \texttt{\{"a": 10, "b": 2\}}
    \end{itemize}
\end{frame}

% Q17 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 17 \textemdash{} Modification d'une valeur}
    \begin{lstlisting}
d = {"a": 1, "b": 2}
d["a"] = d["a"] + 10
print(d)
\end{lstlisting}
Que produit ce code ?\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{Il affiche \texttt{\{"a": 11, "b": 2\}}}
        \item[B.] Il déclenche une erreur
        \item[C.] Il affiche \texttt{\{"a": 1, "b": 2\}}
        \item[D.] Il affiche \texttt{\{"a": 10, "b": 2\}}
    \end{itemize}
\end{frame}

% Q18 - Réponse en D
\begin{frame}[fragile]{Question 18 \textemdash{} Le type defaultdict}
    Que fournit l'instruction
\texttt{from collections import
defaultdict} ?\medskip
    \begin{itemize}
        \item[A.] Elle importe une simple variable
        \item[B.] Elle crée un dictionnaire vide
        \item[C.] Elle importe un fichier annexe
        \item[\alert<2>{D.}] \alert<2>{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)}
    \end{itemize}
\end{frame}

% Q19 - Réponse en B
\begin{frame}[fragile]{Question 19 \textemdash{} Ordre des entrées}
    Depuis Python 3.7, dans quel
ordre les entrées d'un
dictionnaire sont-elles
parcourues ?\medskip
    \begin{itemize}
        \item[A.] Dans un ordre aléatoire à chaque exécution
        \item[\alert<2>{B.}] \alert<2>{Dans l'ordre d'insertion des paires}
        \item[C.] Dans l'ordre alphabétique des clés
        \item[D.] Par taille croissante des valeurs
    \end{itemize}
\end{frame}

% Q20 - Réponse en B
\begin{frame}[fragile]{Question 20 \textemdash{} Cas du dictionnaire vide}
    Que vaut \texttt{bool(\{\})} ?\medskip
    \begin{itemize}
        \item[A.] Une exception
        \item[\alert<2>{B.}] \alert<2>{\texttt{False}}
        \item[C.] La valeur $0$
        \item[D.] \texttt{True}
    \end{itemize}
\end{frame}

% Q21 - Réponse en C
\begin{frame}[fragile]{Question 21 \textemdash{} Hachage et collisions}
    Pourquoi l'accès à un
dictionnaire est-il en
moyenne en $O(1)$, mais
au pire en $O(n)$ ?\medskip
    \begin{itemize}
        \item[A.] Aucune raison particulière
        \item[B.] Parce que les clés sont triées en interne
        \item[\alert<2>{C.}] \alert<2>{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}
        \item[D.] Parce que les dictionnaires sont mal conçus en Python
    \end{itemize}
\end{frame}

% Q22 - Réponse en D
\begin{frame}[fragile]{Question 22 \textemdash{} La méthode setdefault}
    Que fait \texttt{d.setdefault("k",
0)} ?\medskip
    \begin{itemize}
        \item[A.] Elle écrase systématiquement la valeur de la clé \texttt{"k"} avec $0$
        \item[B.] La méthode \texttt{setdefault} n'existe pas en Python
        \item[C.] Elle déclenche systématiquement une erreur
        \item[\alert<2>{D.}] \alert<2>{Si la clé \texttt{"k"} existe, elle renvoie sa valeur. Sinon, elle l'ajoute avec la valeur $0$ et renvoie $0$}
    \end{itemize}
\end{frame}

% Q23 - Réponse en D
\begin{frame}[fragile]{Question 23 \textemdash{} Modifier un dictionnaire pendant son parcours}
    Pourquoi est-il dangereux de
modifier un dictionnaire
pendant qu'on l'\textbf{itère} ?\medskip
    \begin{itemize}
        \item[A.] Le code s'exécute plus rapidement
        \item[B.] Cette modification est interdite par la loi
        \item[C.] Aucune conséquence particulière
        \item[\alert<2>{D.}] \alert<2>{Cela peut lever une exception \texttt{RuntimeError} indiquant que la taille du dictionnaire a changé pendant l'itération, ou produire des comportements imprévisibles}
    \end{itemize}
\end{frame}

% Q24 - Réponse en A
\begin{frame}[fragile]{Question 24 \textemdash{} Compréhension de dictionnaire}
    Quel code crée le dictionnaire
\texttt{\{1: 1, 2: 4, 3: 9, ...,
10: 100\}} (le carré de
chaque entier) ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{\{i: i  2 for i in range(1, 11)\}}}
        \item[B.] \texttt{\{i  2 for i in range(1, 11)\}}
        \item[C.] \texttt{[i: i  2 for i in range(1, 11)]}
        \item[D.] \texttt{dict(i, i  2 for i in range(1, 11))}
    \end{itemize}
\end{frame}

% Q25 - Réponse en C
\begin{frame}[fragile]{Question 25 \textemdash{} Synthèse}
    Parmi les affirmations
suivantes sur les
dictionnaires, laquelle est
\textbf{fausse} ?\medskip
    \begin{itemize}
        \item[A.] La méthode \texttt{d.get(k, default)} renvoie \texttt{default} si la clé est absente, sans lever d'erreur
        \item[B.] L'accès par clé est en $O(1)$ en moyenne
        \item[\alert<2>{C.}] \alert<2>{Une liste peut être utilisée comme clé d'un dictionnaire}
        \item[D.] Depuis Python 3.7, l'ordre d'insertion des paires est conservé lors du parcours
    \end{itemize}
\end{frame}

% Q26 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Méthode values}
    On dispose du dictionnaire suivant :

\begin{lstlisting}
stock = {"stylo": 5, "cahier": 12, "gomme": 3}
\end{lstlisting}

Que renvoie l'expression \texttt{sum(stock.values())} ?\medskip
    \begin{itemize}
        \item[A.] La somme des longueurs des clés (16)
        \item[B.] Une erreur de type
        \item[C.] $20$
        \item[D.] $3$
    \end{itemize}
\end{frame}

% Q26 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Méthode values}
    On dispose du dictionnaire suivant :

\begin{lstlisting}
stock = {"stylo": 5, "cahier": 12, "gomme": 3}
\end{lstlisting}

Que renvoie l'expression \texttt{sum(stock.values())} ?\medskip
    \begin{itemize}
        \item[A.] La somme des longueurs des clés (16)
        \item[B.] Une erreur de type
        \item[\alert{C.}] \alert{$20$}
        \item[D.] $3$
    \end{itemize}
\end{frame}

% Q27 - Réponse en C
\begin{frame}[fragile]{Question 27 \textemdash{} Inverser un dictionnaire}
    On souhaite, à partir d'un dictionnaire \texttt{d} aux
valeurs distinctes, obtenir un nouveau dictionnaire
où les clés et les valeurs sont échangées. Quelle
compréhension convient ?\medskip
    \begin{itemize}
        \item[A.] \texttt{\{v: k for k in d\}}
        \item[B.] \texttt{\{d[k]: k for k in d.values()\}}
        \item[\alert<2>{C.}] \alert<2>{\texttt{\{v: k for k, v in d.items()\}}}
        \item[D.] \texttt{\{k: v for v, k in d.items()\}}
    \end{itemize}
\end{frame}

% Q28 - Réponse en A
\begin{frame}[fragile]{Question 28 \textemdash{} Construction depuis une liste de couples}
    Que renvoie l'expression
\texttt{dict([("rouge", 1), ("vert", 2), ("bleu", 3)])} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{\{'rouge': 1, 'vert': 2, 'bleu': 3\}}}
        \item[B.] \texttt{\{'rouge', 'vert', 'bleu'\}}
        \item[C.] Une erreur de syntaxe
        \item[D.] \texttt{[('rouge', 1), ('vert', 2), ('bleu', 3)]}
    \end{itemize}
\end{frame}

\begin{frame}[standout]{}
    Fin de l'évaluation
\end{frame}

\end{document}
