\documentclass[a4paper,11pt]{article}

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[francais,bloc,completemulti]{automultiplechoice}
\usepackage[french]{babel}
\usepackage{amsmath, amssymb}

\title{Tuples et listes}
\date{Numérique et sciences informatiques}

\begin{document}

\noindent\textbf{Tuples et listes} \hfill \textit{Numérique et sciences informatiques}\\[0.4em]
Nom~: \dotfill\ Prénom~: \dotfill

\bigskip

\element{premieretupleslistes}{
  \begin{question}{q01}
    Comment crée-t-on une \textbf{liste} vide en
Python ?
    \begin{choices}
    \correctchoice{Avec la syntaxe \texttt{liste = []}}
    \wrongchoice{Avec la syntaxe \texttt{liste = ()}}
    \wrongchoice{Avec la syntaxe \texttt{liste = \{\}}}
    \wrongchoice{Avec la syntaxe \texttt{liste = null}}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q02}
    Comment crée-t-on un \textbf{tuple} en
Python ?
    \begin{choices}
    \wrongchoice{Avec la syntaxe \texttt{t = tuple[1, 2, 3]}}
    \correctchoice{Avec \texttt{t = ()}, \texttt{t = (1, 2, 3)}, ou même \texttt{t = 1, 2, 3}}
    \wrongchoice{Avec la syntaxe \texttt{t = \{1, 2, 3\}}}
    \wrongchoice{Avec la syntaxe \texttt{t = []}}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q03}
    Quelle est la \textbf{différence
fondamentale} entre un tuple et
une liste ?
    \begin{choices}
    \wrongchoice{Un tuple a forcément deux éléments}
    \wrongchoice{Aucune différence}
    \correctchoice{Une liste est mutable (modifiable après sa création), tandis qu'un tuple est immuable (figé une fois créé)}
    \wrongchoice{La couleur d'affichage dans l'éditeur}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q04}
    Que renvoie l'expression
\texttt{["a", "b", "c"][1]} ?
    \begin{choices}
    \wrongchoice{La chaîne \texttt{"c"}}
    \correctchoice{La chaîne \texttt{"b"}}
    \wrongchoice{La chaîne \texttt{"a"}}
    \wrongchoice{Une exception est levée}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q05}
    Comment obtient-on la \textbf{longueur}
d'une liste ou d'un tuple ?
    \begin{choices}
    \wrongchoice{Avec \texttt{liste.size()}}
    \wrongchoice{Avec \texttt{liste.length}}
    \correctchoice{Avec \texttt{len(liste)}}
    \wrongchoice{Avec \texttt{size(liste)}}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q06}
    Comment \textbf{ajoute-t-on} l'élément
$42$ à la fin d'une liste \texttt{liste} ?
    \begin{choices}
    \wrongchoice{Avec \texttt{liste += 42}}
    \wrongchoice{Avec \texttt{liste = liste + 42}}
    \correctchoice{Avec \texttt{liste.append(42)}}
    \wrongchoice{Avec \texttt{liste.add(42)}}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q07}
    Comment \textbf{parcourt-on} tous les
éléments d'une liste pour les
afficher ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
for i in liste.length:
    print(liste[i])
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
print liste
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
for x in liste:
    print(x)
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
while liste:
    print(liste)
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q08}
    Comment teste-t-on si l'élément
$42$ est présent dans une liste
\texttt{liste} ?
    \begin{choices}
    \wrongchoice{Avec \texttt{liste.has(42)}}
    \correctchoice{Avec \texttt{42 in liste}}
    \wrongchoice{Avec \texttt{liste.find(42)}}
    \wrongchoice{Avec \texttt{liste.contains(42)}}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q09}
    Dans quel cas préfère-t-on un
\textbf{tuple} à une liste ?
    \begin{choices}
    \wrongchoice{Uniquement pour stocker des nombres}
    \correctchoice{Pour des données qui ne doivent pas être modifiées : constantes, coordonnées, paires nom-valeur}
    \wrongchoice{Pour économiser quelques touches au clavier}
    \wrongchoice{Pour stocker des données qui changent souvent au cours du programme}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q10}
    Que produit ce code ?
\begin{lstlisting}
l = [1, 2, 3]
l.append(4)
print(len(l))
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Il affiche \texttt{5}}
    \wrongchoice{Il affiche \texttt{3}}
    \correctchoice{Il affiche \texttt{4}}
    \wrongchoice{Il déclenche une exception}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q11}
    Que renvoie l'expression
\texttt{[1, 2, 3, 4, 5][1:4]} ?
    \begin{choices}
    \wrongchoice{La liste \texttt{[1, 2, 3]}}
    \correctchoice{La liste \texttt{[2, 3, 4]}}
    \wrongchoice{La liste \texttt{[1, 4]}}
    \wrongchoice{La liste \texttt{[2, 3, 4, 5]}}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q12}
    Quelles sont les valeurs de \texttt{a},
\texttt{b} et \texttt{c} après l'instruction
\texttt{(a, b, c) = (1, 2, 3)} ?
    \begin{choices}
    \wrongchoice{Le tuple \texttt{((1, 2, 3),)}}
    \wrongchoice{$a = 1$, $b = 1$, $c = 1$}
    \correctchoice{$a = 1$, $b = 2$, $c = 3$}
    \wrongchoice{Une exception est levée}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q13}
    Que fait l'appel \texttt{liste.pop()} ?
    \begin{choices}
    \correctchoice{Elle retire et renvoie le dernier élément de la liste, en $O(1)$}
    \wrongchoice{Elle se contente d'afficher le dernier élément}
    \wrongchoice{Elle compte le nombre d'éléments de la liste}
    \wrongchoice{Elle trie la liste sur place}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q14}
    \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 ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
[1]
[1]
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
[]
[]
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
[1]
[1, 1]
\end{lstlisting}
}
    \wrongchoice{Une exception est levée}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q15}
    Quelle est la différence entre
\texttt{liste.sort()} et \texttt{sorted(liste)} ?
    \begin{choices}
    \wrongchoice{La méthode \texttt{sort} est plus lente}
    \wrongchoice{Aucune différence}
    \wrongchoice{La fonction \texttt{sorted} ne fonctionne que sur des nombres}
    \correctchoice{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{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q16}
    Quel code crée la liste des
carrés des entiers de $1$ à $10$ ?
    \begin{choices}
    \wrongchoice{\texttt{for i in range(1, 11): liste.append(i  2)}}
    \correctchoice{\texttt{[i  2 for i in range(1, 11)]}}
    \wrongchoice{\texttt{(i  2 for i in range(1, 11))}}
    \wrongchoice{\texttt{\{i  2 for i in range(1, 11)\}}}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q17}
    \begin{lstlisting}
a = [1, 2, 3]
b = a
b.append(4)
print(a)
\end{lstlisting}
Que produit ce code ?
    \begin{choices}
    \wrongchoice{La liste \texttt{[4]}}
    \wrongchoice{La liste \texttt{[1, 2, 3]}}
    \wrongchoice{Une exception est levée}
    \correctchoice{La liste \texttt{[1, 2, 3, 4]}}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q18}
    Que renvoie cette fonction ?
\begin{lstlisting}
def min_max(l):
    return min(l), max(l)
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Une chaîne de caractères}
    \wrongchoice{La valeur \texttt{None}}
    \wrongchoice{Une liste contenant deux éléments}
    \correctchoice{Un tuple de la forme \texttt{(min, max)}}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q19}
    Pourquoi un tuple peut-il être
utilisé comme \textbf{clé} de
dictionnaire, alors qu'une liste
ne le peut pas ?
    \begin{choices}
    \wrongchoice{Aucune des deux structures ne peut servir de clé}
    \wrongchoice{Aucune raison particulière}
    \correctchoice{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}
    \wrongchoice{Pour des raisons purement historiques}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q20}
    Que vaut l'expression \texttt{len((42))} ?
    \begin{choices}
    \wrongchoice{La valeur $0$}
    \correctchoice{Une exception (\texttt{TypeError}), car la fonction \texttt{len} n'est pas définie sur les entiers}
    \wrongchoice{La valeur $42$}
    \wrongchoice{La valeur $1$}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q21}
    \begin{lstlisting}
l = [10, 20, 30]
x = l.pop(0)
print(x, l)
\end{lstlisting}
Que produit ce code ?
    \begin{choices}
    \wrongchoice{La sortie \texttt{30 [10, 20]}}
    \wrongchoice{Une exception est levée}
    \wrongchoice{La sortie \texttt{10 [10, 20, 30]}}
    \correctchoice{La sortie \texttt{10 [20, 30]}}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q22}
    \begin{lstlisting}
grille = [[0] * 3] * 3
grille[0][0] = 1
print(grille)
\end{lstlisting}
Que produit ce code ?
    \begin{choices}
    \correctchoice{\texttt{[[1, 0, 0], [1, 0, 0], [1, 0, 0]]}}
    \wrongchoice{Une exception est levée}
    \wrongchoice{\texttt{[[1, 0, 0], [0, 0, 0], [0, 0, 0]]}}
    \wrongchoice{\texttt{[[0, 0, 0], [0, 0, 0], [0, 0, 0]]}}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q23}
    Quelle est la différence entre
les méthodes \texttt{append} et \texttt{extend}
d'une liste ?
    \begin{choices}
    \correctchoice{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}
    \wrongchoice{Aucune différence notable}
    \wrongchoice{La méthode \texttt{append} est plus rapide qu'\texttt{extend}}
    \wrongchoice{La méthode \texttt{extend} n'existe pas en Python}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q24}
    Pour stocker des \textbf{constantes}
que l'on ne modifiera jamais,
quelle structure est la plus
indiquée ?
    \begin{choices}
    \wrongchoice{Un dictionnaire}
    \correctchoice{Un tuple, qui signale clairement l'immuabilité, est légèrement plus rapide à créer et consomme un peu moins de mémoire}
    \wrongchoice{Une liste}
    \wrongchoice{Une chaîne de caractères}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q25}
    Parmi les affirmations suivantes
sur les tuples et les listes,
laquelle est \textbf{fausse} ?
    \begin{choices}
    \wrongchoice{Les deux structures supportent l'indexation et le découpage}
    \correctchoice{Les listes peuvent être utilisées comme clés de dictionnaire}
    \wrongchoice{\texttt{liste = []} crée une liste vide ; \texttt{t = ()} crée un tuple vide}
    \wrongchoice{Une liste est mutable, un tuple est immuable}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q26}
    On dispose d'une liste \texttt{t = [10, 20, 30, 40, 50]}.
Que vaut \texttt{t[::-1]} ?
    \begin{choices}
    \correctchoice{\texttt{[50, 40, 30, 20, 10]}}
    \wrongchoice{\texttt{[10, 20, 30, 40, 50]}}
    \wrongchoice{Une erreur d'indice}
    \wrongchoice{\texttt{[]}}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q27}
    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)} ?
    \begin{choices}
    \wrongchoice{\texttt{5} puis \texttt{3}}
    \correctchoice{\texttt{3} puis \texttt{4}}
    \wrongchoice{\texttt{5} puis \texttt{5}}
    \wrongchoice{\texttt{3} puis \texttt{5}}
    \end{choices}
  \end{question}
}

\element{premieretupleslistes}{
  \begin{question}{q28}
    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 ?
    \begin{choices}
    \wrongchoice{Le code lève une erreur}
    \correctchoice{\texttt{[1, 2, 3, [4, 5]]}}
    \wrongchoice{\texttt{[1, 2, 3, 4, 5]}}
    \wrongchoice{\texttt{[[1, 2, 3], 4, 5]}}
    \end{choices}
  \end{question}
}


\onecopy{1}{
  \shufflegroup{premieretupleslistes}
  \insertgroup{premieretupleslistes}
}

\end{document}
