\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{Tuples et listes}
\subtitle{QCM}
\author{Première}
\date{\today}

\begin{document}

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

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

% Q2 - Réponse en B
\begin{frame}[fragile]{Question 2 \textemdash{} Création d'un tuple}
    Comment crée-t-on un \textbf{tuple} en
Python ?\medskip
    \begin{itemize}
        \item[A.] Avec la syntaxe \texttt{t = tuple[1, 2, 3]}
        \item[\alert<2>{B.}] \alert<2>{Avec \texttt{t = ()}, \texttt{t = (1, 2, 3)}, ou même \texttt{t = 1, 2, 3}}
        \item[C.] Avec la syntaxe \texttt{t = \{1, 2, 3\}}
        \item[D.] Avec la syntaxe \texttt{t = []}
    \end{itemize}
\end{frame}

% Q3 - Réponse en C
\begin{frame}[fragile]{Question 3 \textemdash{} Mutabilité}
    Quelle est la \textbf{différence
fondamentale} entre un tuple et
une liste ?\medskip
    \begin{itemize}
        \item[A.] Un tuple a forcément deux éléments
        \item[B.] Aucune différence
        \item[\alert<2>{C.}] \alert<2>{Une liste est mutable (modifiable après sa création), tandis qu'un tuple est immuable (figé une fois créé)}
        \item[D.] La couleur d'affichage dans l'éditeur
    \end{itemize}
\end{frame}

% Q4 - Réponse en B
\begin{frame}[fragile]{Question 4 \textemdash{} Accès par indice}
    Que renvoie l'expression
\texttt{["a", "b", "c"][1]} ?\medskip
    \begin{itemize}
        \item[A.] La chaîne \texttt{"c"}
        \item[\alert<2>{B.}] \alert<2>{La chaîne \texttt{"b"}}
        \item[C.] La chaîne \texttt{"a"}
        \item[D.] Une exception est levée
    \end{itemize}
\end{frame}

% Q5 - Réponse en C
\begin{frame}[fragile]{Question 5 \textemdash{} Longueur d'une séquence}
    Comment obtient-on la \textbf{longueur}
d'une liste ou d'un tuple ?\medskip
    \begin{itemize}
        \item[A.] Avec \texttt{liste.size()}
        \item[B.] Avec \texttt{liste.length}
        \item[\alert<2>{C.}] \alert<2>{Avec \texttt{len(liste)}}
        \item[D.] Avec \texttt{size(liste)}
    \end{itemize}
\end{frame}

% Q6 - Réponse en C
\begin{frame}[fragile]{Question 6 \textemdash{} Ajouter à une liste}
    Comment \textbf{ajoute-t-on} l'élément
$42$ à la fin d'une liste \texttt{liste} ?\medskip
    \begin{itemize}
        \item[A.] Avec \texttt{liste += 42}
        \item[B.] Avec \texttt{liste = liste + 42}
        \item[\alert<2>{C.}] \alert<2>{Avec \texttt{liste.append(42)}}
        \item[D.] Avec \texttt{liste.add(42)}
    \end{itemize}
\end{frame}

% Q7 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 7 \textemdash{} Parcours d'une liste}
    Comment \textbf{parcourt-on} tous les
éléments d'une liste pour les
afficher ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
for i in liste.length:
    print(liste[i])
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
print liste
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
for x in liste:
    print(x)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
while liste:
    print(liste)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q7 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 7 \textemdash{} Parcours d'une liste}
    Comment \textbf{parcourt-on} tous les
éléments d'une liste pour les
afficher ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
for i in liste.length:
    print(liste[i])
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
print liste
\end{lstlisting}

        \item[\alert{C.}]~\\
\begin{lstlisting}
for x in liste:
    print(x)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
while liste:
    print(liste)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q8 - Réponse en B
\begin{frame}[fragile]{Question 8 \textemdash{} Test d'appartenance}
    Comment teste-t-on si l'élément
$42$ est présent dans une liste
\texttt{liste} ?\medskip
    \begin{itemize}
        \item[A.] Avec \texttt{liste.has(42)}
        \item[\alert<2>{B.}] \alert<2>{Avec \texttt{42 in liste}}
        \item[C.] Avec \texttt{liste.find(42)}
        \item[D.] Avec \texttt{liste.contains(42)}
    \end{itemize}
\end{frame}

% Q9 - Réponse en B
\begin{frame}[fragile]{Question 9 \textemdash{} Quand utiliser un tuple ?}
    Dans quel cas préfère-t-on un
\textbf{tuple} à une liste ?\medskip
    \begin{itemize}
        \item[A.] Uniquement pour stocker des nombres
        \item[\alert<2>{B.}] \alert<2>{Pour des données qui ne doivent pas être modifiées : constantes, coordonnées, paires nom-valeur}
        \item[C.] Pour économiser quelques touches au clavier
        \item[D.] Pour stocker des données qui changent souvent au cours du programme
    \end{itemize}
\end{frame}

% Q10 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Trace simple}
    Que produit ce code ?
\begin{lstlisting}
l = [1, 2, 3]
l.append(4)
print(len(l))
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Il affiche \texttt{5}
        \item[B.] Il affiche \texttt{3}
        \item[C.] Il affiche \texttt{4}
        \item[D.] Il déclenche une exception
    \end{itemize}
\end{frame}

% Q10 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Trace simple}
    Que produit ce code ?
\begin{lstlisting}
l = [1, 2, 3]
l.append(4)
print(len(l))
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Il affiche \texttt{5}
        \item[B.] Il affiche \texttt{3}
        \item[\alert{C.}] \alert{Il affiche \texttt{4}}
        \item[D.] Il déclenche une exception
    \end{itemize}
\end{frame}

% Q11 - Réponse en B
\begin{frame}[fragile]{Question 11 \textemdash{} Découpage d'une liste}
    Que renvoie l'expression
\texttt{[1, 2, 3, 4, 5][1:4]} ?\medskip
    \begin{itemize}
        \item[A.] La liste \texttt{[1, 2, 3]}
        \item[\alert<2>{B.}] \alert<2>{La liste \texttt{[2, 3, 4]}}
        \item[C.] La liste \texttt{[1, 4]}
        \item[D.] La liste \texttt{[2, 3, 4, 5]}
    \end{itemize}
\end{frame}

% Q12 - Réponse en C
\begin{frame}[fragile]{Question 12 \textemdash{} Affectation multiple}
    Quelles sont les valeurs de \texttt{a},
\texttt{b} et \texttt{c} après l'instruction
\texttt{(a, b, c) = (1, 2, 3)} ?\medskip
    \begin{itemize}
        \item[A.] Le tuple \texttt{((1, 2, 3),)}
        \item[B.] $a = 1$, $b = 1$, $c = 1$
        \item[\alert<2>{C.}] \alert<2>{$a = 1$, $b = 2$, $c = 3$}
        \item[D.] Une exception est levée
    \end{itemize}
\end{frame}

% Q13 - Réponse en A
\begin{frame}[fragile]{Question 13 \textemdash{} Méthode pop}
    Que fait l'appel \texttt{liste.pop()} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Elle retire et renvoie le dernier élément de la liste, en $O(1)$}
        \item[B.] Elle se contente d'afficher le dernier élément
        \item[C.] Elle compte le nombre d'éléments de la liste
        \item[D.] Elle trie la liste sur place
    \end{itemize}
\end{frame}

% Q14 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 14 \textemdash{} Piège de la valeur par défaut mutable}
    \begin{lstlisting}
def f(l=[]):
    l.append(1)
    return l

print(f())
print(f())
\end{lstlisting}
Quel est le résultat de l'exécution
de ce code ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
[1]
[1]
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
[]
[]
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
[1]
[1, 1]
\end{lstlisting}

        \item[D.] Une exception est levée
    \end{itemize}
\end{frame}

% Q14 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 14 \textemdash{} Piège de la valeur par défaut mutable}
    \begin{lstlisting}
def f(l=[]):
    l.append(1)
    return l

print(f())
print(f())
\end{lstlisting}
Quel est le résultat de l'exécution
de ce code ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
[1]
[1]
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
[]
[]
\end{lstlisting}

        \item[\alert{C.}]~\\
\begin{lstlisting}
[1]
[1, 1]
\end{lstlisting}

        \item[D.] Une exception est levée
    \end{itemize}
\end{frame}

% Q15 - Réponse en D
\begin{frame}[fragile]{Question 15 \textemdash{} Méthodes sort et sorted}
    Quelle est la différence entre
\texttt{liste.sort()} et \texttt{sorted(liste)} ?\medskip
    \begin{itemize}
        \item[A.] La méthode \texttt{sort} est plus lente
        \item[B.] Aucune différence
        \item[C.] La fonction \texttt{sorted} ne fonctionne que sur des nombres
        \item[\alert<2>{D.}] \alert<2>{La méthode \texttt{sort} modifie la liste sur place (et renvoie \texttt{None}), tandis que la fonction \texttt{sorted} renvoie une nouvelle liste triée sans modifier l'originale}
    \end{itemize}
\end{frame}

% Q16 - Réponse en B
\begin{frame}[fragile]{Question 16 \textemdash{} Compréhension de liste}
    Quel code crée la liste des
carrés des entiers de $1$ à $10$ ?\medskip
    \begin{itemize}
        \item[A.] \texttt{for i in range(1, 11): liste.append(i  2)}
        \item[\alert<2>{B.}] \alert<2>{\texttt{[i  2 for i in range(1, 11)]}}
        \item[C.] \texttt{(i  2 for i in range(1, 11))}
        \item[D.] \texttt{\{i  2 for i in range(1, 11)\}}
    \end{itemize}
\end{frame}

% Q17 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 17 \textemdash{} Référence et copie}
    \begin{lstlisting}
a = [1, 2, 3]
b = a
b.append(4)
print(a)
\end{lstlisting}
Que produit ce code ?\medskip
    \begin{itemize}
        \item[A.] La liste \texttt{[4]}
        \item[B.] La liste \texttt{[1, 2, 3]}
        \item[C.] Une exception est levée
        \item[D.] La liste \texttt{[1, 2, 3, 4]}
    \end{itemize}
\end{frame}

% Q17 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 17 \textemdash{} Référence et copie}
    \begin{lstlisting}
a = [1, 2, 3]
b = a
b.append(4)
print(a)
\end{lstlisting}
Que produit ce code ?\medskip
    \begin{itemize}
        \item[A.] La liste \texttt{[4]}
        \item[B.] La liste \texttt{[1, 2, 3]}
        \item[C.] Une exception est levée
        \item[\alert{D.}] \alert{La liste \texttt{[1, 2, 3, 4]}}
    \end{itemize}
\end{frame}

% Q18 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 18 \textemdash{} Retours multiples par tuple}
    Que renvoie cette fonction ?
\begin{lstlisting}
def min_max(l):
    return min(l), max(l)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Une chaîne de caractères
        \item[B.] La valeur \texttt{None}
        \item[C.] Une liste contenant deux éléments
        \item[D.] Un tuple de la forme \texttt{(min, max)}
    \end{itemize}
\end{frame}

% Q18 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 18 \textemdash{} Retours multiples par tuple}
    Que renvoie cette fonction ?
\begin{lstlisting}
def min_max(l):
    return min(l), max(l)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Une chaîne de caractères
        \item[B.] La valeur \texttt{None}
        \item[C.] Une liste contenant deux éléments
        \item[\alert{D.}] \alert{Un tuple de la forme \texttt{(min, max)}}
    \end{itemize}
\end{frame}

% Q19 - Réponse en C
\begin{frame}[fragile]{Question 19 \textemdash{} Tuple comme clé de dictionnaire}
    Pourquoi un tuple peut-il être
utilisé comme \textbf{clé} de
dictionnaire, alors qu'une liste
ne le peut pas ?\medskip
    \begin{itemize}
        \item[A.] Aucune des deux structures ne peut servir de clé
        \item[B.] Aucune raison particulière
        \item[\alert<2>{C.}] \alert<2>{Parce qu'un tuple est immuable : sa valeur ne peut pas changer après création, ce qui permet d'en calculer une empreinte stable}
        \item[D.] Pour des raisons purement historiques
    \end{itemize}
\end{frame}

% Q20 - Réponse en B
\begin{frame}[fragile]{Question 20 \textemdash{} Tuple à un élément}
    Que vaut l'expression \texttt{len((42))} ?\medskip
    \begin{itemize}
        \item[A.] La valeur $0$
        \item[\alert<2>{B.}] \alert<2>{Une exception (\texttt{TypeError}), car la fonction \texttt{len} n'est pas définie sur les entiers}
        \item[C.] La valeur $42$
        \item[D.] La valeur $1$
    \end{itemize}
\end{frame}

% Q21 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 21 \textemdash{} Trace de pop}
    \begin{lstlisting}
l = [10, 20, 30]
x = l.pop(0)
print(x, l)
\end{lstlisting}
Que produit ce code ?\medskip
    \begin{itemize}
        \item[A.] La sortie \texttt{30 [10, 20]}
        \item[B.] Une exception est levée
        \item[C.] La sortie \texttt{10 [10, 20, 30]}
        \item[D.] La sortie \texttt{10 [20, 30]}
    \end{itemize}
\end{frame}

% Q21 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 21 \textemdash{} Trace de pop}
    \begin{lstlisting}
l = [10, 20, 30]
x = l.pop(0)
print(x, l)
\end{lstlisting}
Que produit ce code ?\medskip
    \begin{itemize}
        \item[A.] La sortie \texttt{30 [10, 20]}
        \item[B.] Une exception est levée
        \item[C.] La sortie \texttt{10 [10, 20, 30]}
        \item[\alert{D.}] \alert{La sortie \texttt{10 [20, 30]}}
    \end{itemize}
\end{frame}

% Q22 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 22 \textemdash{} Liste de listes}
    \begin{lstlisting}
grille = [[0] * 3] * 3
grille[0][0] = 1
print(grille)
\end{lstlisting}
Que produit ce code ?\medskip
    \begin{itemize}
        \item[A.] \texttt{[[1, 0, 0], [1, 0, 0], [1, 0, 0]]}
        \item[B.] Une exception est levée
        \item[C.] \texttt{[[1, 0, 0], [0, 0, 0], [0, 0, 0]]}
        \item[D.] \texttt{[[0, 0, 0], [0, 0, 0], [0, 0, 0]]}
    \end{itemize}
\end{frame}

% Q22 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 22 \textemdash{} Liste de listes}
    \begin{lstlisting}
grille = [[0] * 3] * 3
grille[0][0] = 1
print(grille)
\end{lstlisting}
Que produit ce code ?\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{\texttt{[[1, 0, 0], [1, 0, 0], [1, 0, 0]]}}
        \item[B.] Une exception est levée
        \item[C.] \texttt{[[1, 0, 0], [0, 0, 0], [0, 0, 0]]}
        \item[D.] \texttt{[[0, 0, 0], [0, 0, 0], [0, 0, 0]]}
    \end{itemize}
\end{frame}

% Q23 - Réponse en A
\begin{frame}[fragile]{Question 23 \textemdash{} Méthodes append et extend}
    Quelle est la différence entre
les méthodes \texttt{append} et \texttt{extend}
d'une liste ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{La méthode \texttt{append(x)} ajoute x comme un seul élément ; la méthode \texttt{extend(iterable)} ajoute chaque élément de l'itérable un par un}
        \item[B.] Aucune différence notable
        \item[C.] La méthode \texttt{append} est plus rapide qu'\texttt{extend}
        \item[D.] La méthode \texttt{extend} n'existe pas en Python
    \end{itemize}
\end{frame}

% Q24 - Réponse en B
\begin{frame}[fragile]{Question 24 \textemdash{} Tuples pour les constantes}
    Pour stocker des \textbf{constantes}
que l'on ne modifiera jamais,
quelle structure est la plus
indiquée ?\medskip
    \begin{itemize}
        \item[A.] Un dictionnaire
        \item[\alert<2>{B.}] \alert<2>{Un tuple, qui signale clairement l'immuabilité, est légèrement plus rapide à créer et consomme un peu moins de mémoire}
        \item[C.] Une liste
        \item[D.] Une chaîne de caractères
    \end{itemize}
\end{frame}

% Q25 - Réponse en B
\begin{frame}[fragile]{Question 25 \textemdash{} Synthèse}
    Parmi les affirmations suivantes
sur les tuples et les listes,
laquelle est \textbf{fausse} ?\medskip
    \begin{itemize}
        \item[A.] Les deux structures supportent l'indexation et le découpage
        \item[\alert<2>{B.}] \alert<2>{Les listes peuvent être utilisées comme clés de dictionnaire}
        \item[C.] \texttt{liste = []} crée une liste vide ; \texttt{t = ()} crée un tuple vide
        \item[D.] Une liste est mutable, un tuple est immuable
    \end{itemize}
\end{frame}

% Q26 - Réponse en A
\begin{frame}[fragile]{Question 26 \textemdash{} Renverser une liste}
    On dispose d'une liste \texttt{t = [10, 20, 30, 40, 50]}.
Que vaut \texttt{t[::-1]} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{[50, 40, 30, 20, 10]}}
        \item[B.] \texttt{[10, 20, 30, 40, 50]}
        \item[C.] Une erreur d'indice
        \item[D.] \texttt{[]}
    \end{itemize}
\end{frame}

% Q27 - Réponse en B
\begin{frame}[fragile]{Question 27 \textemdash{} Compter et trouver dans une liste}
    Soit \texttt{t = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]}. Que
renvoient successivement les expressions
\texttt{t.count(5)} et \texttt{t.index(5)} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{5} puis \texttt{3}
        \item[\alert<2>{B.}] \alert<2>{\texttt{3} puis \texttt{4}}
        \item[C.] \texttt{5} puis \texttt{5}
        \item[D.] \texttt{3} puis \texttt{5}
    \end{itemize}
\end{frame}

% Q28 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 28 \textemdash{} append, extend et concaténation}
    On exécute :

\begin{lstlisting}
a = [1, 2, 3]
b = [4, 5]
a.append(b)
\end{lstlisting}

Que vaut la liste \texttt{a} après cette exécution ?\medskip
    \begin{itemize}
        \item[A.] Le code lève une erreur
        \item[B.] \texttt{[1, 2, 3, [4, 5]]}
        \item[C.] \texttt{[1, 2, 3, 4, 5]}
        \item[D.] \texttt{[[1, 2, 3], 4, 5]}
    \end{itemize}
\end{frame}

% Q28 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 28 \textemdash{} append, extend et concaténation}
    On exécute :

\begin{lstlisting}
a = [1, 2, 3]
b = [4, 5]
a.append(b)
\end{lstlisting}

Que vaut la liste \texttt{a} après cette exécution ?\medskip
    \begin{itemize}
        \item[A.] Le code lève une erreur
        \item[\alert{B.}] \alert{\texttt{[1, 2, 3, [4, 5]]}}
        \item[C.] \texttt{[1, 2, 3, 4, 5]}
        \item[D.] \texttt{[[1, 2, 3], 4, 5]}
    \end{itemize}
\end{frame}

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

\end{document}
